.github/dependabot.yml

@@ -2,13 +2,7 @@
 version: 2
 updates:
 - package-ecosystem: pip
-  directory: /dependencies/default
-  schedule:
-    interval: weekly
-  open-pull-requests-limit: 10
-  target-branch: main
-- package-ecosystem: pip
-  directory: /dependencies/docs
+  directory: /
   schedule:
     interval: weekly
   open-pull-requests-limit: 10

.github/workflows/main.yml

@@ -10,40 +10,32 @@ on:
   merge_group:
   workflow_dispatch:
 
+permissions: {}
+
 env:
   PYTHON_LATEST: 3.13
 
 jobs:
-  lint:
-    name: Run linters
+  build:
+    name: Build package
     runs-on: ubuntu-latest
     outputs:
       version: ${{ steps.version.outputs.version }}
       prerelease: ${{ steps.version.outputs.prerelease }}
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@v5
+        persist-credentials: false
+    - uses: actions/setup-python@v6
       with:
         python-version: ${{ env.PYTHON_LATEST }}
-    - name: Install GitHub matcher for ActionLint checker
-      run: |
-        echo "::add-matcher::.github/actionlint-matcher.json"
-    - name: Install pre-commit
-      run: python -m pip install pre-commit
-    - name: Run pre-commit checks
-      run: pre-commit run --all-files --show-diff-on-failure
-    - name: Install check-wheel-content, and twine
-      run: python -m pip install build check-wheel-contents twine
-    - name: Build package
-      run: python -m build
+    - name: Install tox
+      run: python -m pip install tox
+    - name: Build package and check distributions
+      run: tox run -e build
     - name: List result
       run: ls -l dist
-    - name: Check wheel contents
-      run: check-wheel-contents dist/*.whl
-    - name: Check long_description
-      run: python -m twine check dist/*
     - name: Install pytest-asyncio
       run: pip install .
     - name: Get version info
@@ -55,23 +47,48 @@ jobs:
         name: dist
         path: dist
 
+  lint:
+    name: Run linters
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+      with:
+        fetch-depth: 0
+        persist-credentials: false
+    - uses: actions/setup-python@v6
+      with:
+        python-version: ${{ env.PYTHON_LATEST }}
+    - name: Install GitHub matcher for ActionLint checker
+      run: |
+        echo "::add-matcher::.github/actionlint-matcher.json"
+    - name: Install pre-commit
+      run: python -m pip install pre-commit
+    - name: Run pre-commit checks
+      run: pre-commit run --all-files --show-diff-on-failure
+
   test:
     name: ${{ matrix.os }} - Python ${{ matrix.python-version }}
     runs-on: ${{ matrix.os }}-latest
-
+    continue-on-error: ${{ !matrix.required }}
     strategy:
       matrix:
         os: [ubuntu, windows]
         python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        required: [true]
+        include:
+        - os: ubuntu
+          python-version: 3.14-dev
+          required: false
+        - os: windows
+          python-version: 3.14-dev
+          required: false
+
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      if: "!endsWith(matrix.python-version, '-dev')"
+    - uses: actions/checkout@v5
       with:
-        python-version: ${{ matrix.python-version }}
-    - uses: deadsnakes/action@v3.2.0
-      if: endsWith(matrix.python-version, '-dev')
+        persist-credentials: false
+    - uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
@@ -91,26 +108,34 @@ jobs:
         path: coverage/coverage.*
         if-no-files-found: error
 
+  lint-github-actions:
+    name: Lint GitHub Actions
+    permissions:
+      security-events: write
+    uses: zizmorcore/workflow/.github/workflows/reusable-zizmor.yml@3bb5e95068d0f44b6d2f3f7e91379bed1d2f96a8
+
   check:
     name: Check
     if: always()
-    needs: [lint, test]
+    needs: [build, lint, test]
     runs-on: ubuntu-latest
     steps:
     - name: Decide whether the needed jobs succeeded or failed
-      uses: re-actors/alls-green@release/v1
+      uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe  # v1.2.2
       with:
         jobs: ${{ toJSON(needs) }}
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v5
+      with:
+        persist-credentials: false
+    - uses: actions/setup-python@v6
       with:
         python-version: ${{ env.PYTHON_LATEST }}
     - name: Install Coverage.py
       run: |
         set -xe
         python -m pip install --upgrade coverage[toml]
     - name: Download coverage data for all test runs
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v5
       with:
         pattern: coverage-*
         path: coverage
@@ -120,47 +145,107 @@ jobs:
         coverage combine
         coverage xml
     - name: Upload coverage report
-      uses: codecov/codecov-action@v5
+      uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7  # v5.5.1
       with:
         files: coverage.xml
         fail_ci_if_error: true
         token: ${{ secrets.CODECOV_TOKEN }}
 
-  deploy:
-    name: Deploy
-    environment: release
-        # Run only on pushing a tag
-    if: github.event_name == 'push' && contains(github.ref, 'refs/tags/')
-    needs: [lint, check]
+  create-github-release:
+    name: Create GitHub release
+    needs: [build, lint, check]
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
+    - name: Checkout
+      uses: actions/checkout@v5
+      with:
+        fetch-depth: 0
+        persist-credentials: false
+    - name: Install Python
+      uses: actions/setup-python@v6
+    - name: Install towncrier
+      run: pip install towncrier==24.8.0
     - name: Install pandoc
       run: |
         sudo apt-get install -y pandoc
-    - name: Checkout
-      uses: actions/checkout@v4
+    - name: Install pytest-asyncio
+      run: pip install .
+    - name: Compile Release Notes Draft
+      if: ${{ !contains(github.ref, 'refs/tags/') }}
+      run: towncrier build --draft --version "${version}" > release-notes.rst
+      env:
+        version: ${{ needs.build.outputs.version }}
+    - name: Extract release notes from Git tag
+      if: github.event_name == 'push' && contains(github.ref, 'refs/tags/')
+      run: |
+        set -e
+        git fetch --tags --force  # see https://github.com/actions/checkout/issues/290
+        git for-each-ref "${GITHUB_REF}" --format='%(contents)' > release-notes.rst
+        # Strip signature from signed tags
+        sed -i -e "/-----BEGIN PGP SIGNATURE-----/,/-----END PGP SIGNATURE-----\n/d" \
+          -e "/-----BEGIN SSH SIGNATURE-----/,/-----END SSH SIGNATURE-----\n/d" release-notes.rst
+    - name: Convert Release Notes to Markdown
+      run: |
+        pandoc --wrap=preserve -o release-notes.md release-notes.rst
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: release-notes.md
+        path: release-notes.md
+    - name: Download distributions
+      uses: actions/download-artifact@v5
+      with:
+        name: dist
+        path: dist
+    - name: Create GitHub Release
+      if: github.event_name == 'push' && contains(github.ref, 'refs/tags/')
+      uses: ncipollo/release-action@b7eabc95ff50cbeeedec83973935c8f306dfcd0b  # v1.20.0
+      with:
+        name: pytest-asyncio ${{ needs.build.outputs.version }}
+        artifacts: dist/*
+        bodyFile: release-notes.md
+        prerelease: ${{ needs.build.outputs.prerelease }}
+        token: ${{ secrets.GITHUB_TOKEN }}
+        allowUpdates: true
+        draft: true
+        skipIfReleaseExists: true
+
+  publish-test-pypi:
+    name: Publish packages to test.pypi.org
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: [build, lint, check, create-github-release]
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
     - name: Download distributions
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v5
+      with:
+        name: dist
+        path: dist
+    - name: Upload to test.pypi.org
+      uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e  # v1.13.0
+      with:
+        repository-url: https://test.pypi.org/legacy/
+
+  publish-pypi:
+    name: Publish packages to pypi.org
+    environment: release
+    if: github.event_name == 'push' && contains(github.ref, 'refs/tags/')
+    needs: [build, lint, check, create-github-release]
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+    - name: Download distributions
+      uses: actions/download-artifact@v5
       with:
         name: dist
         path: dist
     - name: Collected dists
       run: |
         tree dist
-    - name: Convert README.rst to Markdown
-      run: |
-        pandoc -s -o README.md README.rst
     - name: PyPI upload
-      uses: pypa/gh-action-pypi-publish@v1.12.3
-      with:
-        attestations: true
-        packages-dir: dist
-        password: ${{ secrets.PYPI_API_TOKEN }}
-    - name: GitHub Release
-      uses: ncipollo/release-action@v1
-      with:
-        name: pytest-asyncio ${{ needs.lint.outputs.version }}
-        artifacts: dist/*
-        bodyFile: README.md
-        prerelease: ${{ needs.lint.outputs.prerelease }}
-        token: ${{ secrets.GITHUB_TOKEN }}
+      uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e  # v1.13.0

.gitignore

@@ -62,7 +62,3 @@ target/
 
 # pyenv
 .python-version
-
-
-# generated by setuptools_scm
-pytest_asyncio/_version.py

.pre-commit-config.yaml

@@ -1,21 +1,32 @@
 ---
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v5.0.0
+  rev: v6.0.0
   hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
   - id: check-merge-conflict
     exclude: rst$
+  - id: check-case-conflict
+  - id: check-json
+  - id: check-xml
+  - id: check-yaml
+  - id: debug-statements
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.8.2
+  rev: v0.13.3
   hooks:
   - id: ruff
     args: [--fix]
+- repo: https://github.com/asottile/pyupgrade
+  rev: v3.20.0
+  hooks:
+  - id: pyupgrade
 - repo: https://github.com/asottile/yesqa
   rev: v1.5.0
   hooks:
   - id: yesqa
 - repo: https://github.com/Zac-HD/shed
-  rev: 2024.10.1
+  rev: 2025.6.1
   hooks:
   - id: shed
     args:
@@ -29,20 +40,8 @@ repos:
   hooks:
   - id: yamlfmt
     args: [--mapping, '2', --sequence, '2', --offset, '0']
-- repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v5.0.0
-  hooks:
-  - id: trailing-whitespace
-  - id: end-of-file-fixer
-  - id: fix-encoding-pragma
-    args: [--remove]
-  - id: check-case-conflict
-  - id: check-json
-  - id: check-xml
-  - id: check-yaml
-  - id: debug-statements
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.13.0
+  rev: v1.18.2
   hooks:
   - id: mypy
     exclude: ^(docs|tests)/.*
@@ -53,7 +52,7 @@ repos:
   hooks:
   - id: python-use-type-annotations
 - repo: https://github.com/rhysd/actionlint
-  rev: v1.7.4
+  rev: v1.7.7
   hooks:
   - id: actionlint-docker
     args:
@@ -65,15 +64,19 @@ repos:
     - 'SC1004:'
     stages: [manual]
 - repo: https://github.com/sirosen/check-jsonschema
-  rev: 0.30.0
+  rev: 0.34.0
   hooks:
   - id: check-github-actions
 - repo: https://github.com/tox-dev/pyproject-fmt
-  rev: v2.5.0
+  rev: v2.7.0
   hooks:
   - id: pyproject-fmt
       # https://pyproject-fmt.readthedocs.io/en/latest/#calculating-max-supported-python-version
-    additional_dependencies: [tox>=4.9]
+    additional_dependencies: [tox>=4.28]
+- repo: https://github.com/zizmorcore/zizmor-pre-commit
+  rev: v1.14.2
+  hooks:
+  - id: zizmor
 ci:
   skip:
   - actionlint-docker

constraints.txt

@@ -0,0 +1,66 @@
+alabaster==0.7.16
+annotated-types-0.7.0
+attrs==25.4.0
+babel==2.17.0
+backports.asyncio.runner==1.2.0
+backports.tarfile==1.2.0
+certifi==2025.10.5
+charset-normalizer==3.4.3
+check-wheel-contents==0.6.1
+cffi==2.0.0
+click==8.1.8
+coverage==7.10.7
+cryptography==46.0.2
+docutils==0.21.2
+exceptiongroup==1.3.0
+hypothesis==6.140.3
+iniconfig==2.1.0
+id==1.5.0
+idna==3.10
+imagesize==1.4.1
+importlib_metadata==8.7.0
+iniconfig==2.1.0
+jaraco.classes==3.4.0
+jaraco.context==6.0.1
+jaraco.functools==4.3.0
+jeepney==0.9.0
+Jinja2==3.1.6
+keyring==25.6.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+more-itertools==10.8.0
+nh3==0.3.0
+packaging==25.0
+pluggy==1.6.0
+Pygments==2.19.2
+pycparser==2.23
+pydantic==2.11.10
+pydantic-core==2.33.2
+pytest==8.4.2
+readme-renderer==44.0
+requests==2.32.5
+requests-toolbelt==1.0.0
+rfc3986==2.0.0
+rich==14.1.0
+SecretStorage==3.3.3
+setuptools==80.9.0
+setuptools-scm==9.2.0
+snowballstemmer==3.0.1
+sortedcontainers==2.4.0
+Sphinx==8.0.2
+sphinx-rtd-theme==3.0.2
+sphinxcontrib-applehelp==2.0.0
+sphinxcontrib-devhelp==2.0.0
+sphinxcontrib-htmlhelp==2.1.0
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==2.0.0
+sphinxcontrib-serializinghtml==2.0.0
+tomli==2.2.1
+twine==6.2.0
+typing_extensions==4.15.0
+typing-inspection==0.4.2
+urllib3==2.5.0
+wheel-filename==1.4.2
+zipp==3.23.0

dependencies/docs/constraints.txt

@@ -1,16 +1,16 @@
 alabaster==0.7.16
-Babel==2.16.0
-certifi==2024.8.30
-charset-normalizer==3.4.0
+Babel==2.17.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
 docutils==0.21.2
 idna==3.10
 imagesize==1.4.1
-Jinja2==3.1.4
+Jinja2==3.1.6
 MarkupSafe==3.0.2
-packaging==24.2
-Pygments==2.18.0
-requests==2.32.3
-snowballstemmer==2.2.0
+packaging==25.0
+Pygments==2.19.2
+requests==2.32.5
+snowballstemmer==3.0.1
 Sphinx==8.0.2
 sphinx-rtd-theme==3.0.2
 sphinxcontrib-applehelp==2.0.0
@@ -20,4 +20,4 @@ sphinxcontrib-jquery==4.1
 sphinxcontrib-jsmath==1.0.1
 sphinxcontrib-qthelp==2.0.0
 sphinxcontrib-serializinghtml==2.0.0
-urllib3==2.2.3
+urllib3==2.5.0

docs/concepts.rst

@@ -47,8 +47,12 @@ Assigning neighboring tests to different event loop scopes is discouraged as it
 Test discovery modes
 ====================
 
-Pytest-asyncio provides two modes for test discovery, *strict* and *auto*.
+Pytest-asyncio provides two modes for test discovery, *strict* and *auto*. This can be set through Pytest's ``--asyncio-mode`` command line flag, or through the configuration file:
 
+.. code-block:: toml
+
+    [tool.pytest.ini_options]
+    asyncio_mode = "auto" # or "strict"
 
 Strict mode
 -----------
@@ -67,3 +71,15 @@ In *auto* mode pytest-asyncio automatically adds the *asyncio* marker to all asy
 This mode is intended for projects that use *asyncio* as their only asynchronous programming library. Auto mode makes for the simplest test and fixture configuration and is the recommended default.
 
 If you intend to support multiple asynchronous programming libraries, e.g. *asyncio* and *trio*, strict mode will be the preferred option.
+
+.. _concepts/concurrent_execution:
+
+Test execution and concurrency
+==============================
+
+pytest-asyncio runs async tests sequentially, just like how pytest runs synchronous tests. Each asynchronous test runs within its assigned event loop. For example, consider the following two tests:
+
+.. include:: concepts_concurrent_execution_example.py
+    :code: python
+
+This sequential execution is intentional and important for maintaining test isolation. Running tests concurrently could introduce race conditions and side effects where one test could interfere with another, making test results unreliable and difficult to debug.

docs/concepts_concurrent_execution_example.py

@@ -0,0 +1,16 @@
+import asyncio
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_first():
+    await asyncio.sleep(2)  # Takes 2 seconds
+
+
+@pytest.mark.asyncio
+async def test_second():
+    await asyncio.sleep(2)  # Takes 2 seconds
+
+
+# Total execution time: ~4 seconds, not ~2 seconds

docs/how-to-guides/change_default_test_loop.rst

@@ -0,0 +1,24 @@
+=======================================================
+How to change the default event loop scope of all tests
+=======================================================
+The :ref:`configuration/asyncio_default_test_loop_scope` configuration option sets the default event loop scope for asynchronous tests. The following code snippets configure all tests to run in a session-scoped loop by default:
+
+.. code-block:: ini
+    :caption: pytest.ini
+
+    [pytest]
+    asyncio_default_test_loop_scope = session
+
+.. code-block:: toml
+    :caption: pyproject.toml
+
+    [tool.pytest.ini_options]
+    asyncio_default_test_loop_scope = "session"
+
+.. code-block:: ini
+    :caption: setup.cfg
+
+    [tool:pytest]
+    asyncio_default_test_loop_scope = session
+
+Please refer to :ref:`configuration/asyncio_default_test_loop_scope` for other valid scopes.

docs/how-to-guides/index.rst

@@ -9,11 +9,12 @@ How-To Guides
   migrate_from_0_23
   change_fixture_loop
   change_default_fixture_loop
+  change_default_test_loop
   run_class_tests_in_same_loop
   run_module_tests_in_same_loop
   run_package_tests_in_same_loop
-  run_session_tests_in_same_loop
   multiple_loops
+  parametrize_with_asyncio
   uvloop
   test_item_is_async
 

docs/how-to-guides/multiple_loops_example.py

@@ -1,5 +1,9 @@
 import asyncio
-from asyncio import DefaultEventLoopPolicy
+import warnings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from asyncio import DefaultEventLoopPolicy
 
 import pytest
 
@@ -20,5 +24,6 @@ def event_loop_policy(request):
 
 
 @pytest.mark.asyncio
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
 async def test_uses_custom_event_loop_policy():
     assert isinstance(asyncio.get_event_loop_policy(), CustomEventLoopPolicy)

docs/how-to-guides/parametrize_with_asyncio.rst

@@ -0,0 +1,11 @@
+=====================================
+How to parametrize asynchronous tests
+=====================================
+
+The ``pytest.mark.parametrize`` marker works with asynchronous tests the same as with synchronous tests. You can apply both ``pytest.mark.asyncio`` and ``pytest.mark.parametrize`` to asynchronous test functions:
+
+.. include:: parametrize_with_asyncio_example.py
+    :code: python
+
+.. note::
+   Whilst asynchronous tests can be parametrized, each individual test case still runs sequentially, not concurrently. For more information about how pytest-asyncio executes tests, see :ref:`concepts/concurrent_execution`.

docs/how-to-guides/parametrize_with_asyncio_example.py

@@ -0,0 +1,10 @@
+import asyncio
+
+import pytest
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("value", [1, 2, 3])
+async def test_parametrized_async_function(value):
+    await asyncio.sleep(1)
+    assert value > 0

docs/how-to-guides/uvloop.rst

@@ -2,7 +2,7 @@
 How to test with uvloop
 =======================
 
-Redefinig the *event_loop_policy* fixture will parametrize all async tests. The following example causes all async tests to run multiple times, once for each event loop in the fixture parameters:
+Redefining the *event_loop_policy* fixture will parametrize all async tests. The following example causes all async tests to run multiple times, once for each event loop in the fixture parameters:
 Replace the default event loop policy in your *conftest.py:*
 
 .. code-block:: python

docs/reference/changelog.rst

@@ -2,15 +2,131 @@
 Changelog
 =========
 
+All notable changes to this project will be documented in this file.
+
+The format is based on `Keep a Changelog <https://keepachangelog.com/en/1.1.0/>`__, and this project adheres to `Semantic Versioning <https://semver.org/spec/v2.0.0.html>`__.
+
+This project uses `towncrier <https://towncrier.readthedocs.io/>`__ for changlog management and the changes for the upcoming release can be found in https://github.com/pytest-dev/pytest-asyncio/tree/main/changelog.d/.
+
+.. towncrier release notes start
+
+`1.2.0 <https://github.com/pytest-dev/pytest-asyncio/tree/1.2.0>`_ - 2025-09-12
+===============================================================================
+
+Added
+-----
+
+- ``--asyncio-debug`` CLI option and ``asyncio_debug`` configuration option to enable asyncio debug mode for the default event loop. (`#980 <https://github.com/pytest-dev/pytest-asyncio/issues/980>`_)
+- A ``pytest.UsageError`` for invalid configuration values of ``asyncio_default_fixture_loop_scope`` and ``asyncio_default_test_loop_scope``. (`#1189 <https://github.com/pytest-dev/pytest-asyncio/issues/1189>`_)
+- Compatibility with the `Pyright` type checker (`#731 <https://github.com/pytest-dev/pytest-asyncio/issues/731>`_)
+
+
+Fixed
+-----
+
+- ``RuntimeError: There is no current event loop in thread 'MainThread'`` when any test unsets the event loop (such as when using ``asyncio.run`` and ``asyncio.Runner``). (`#1177 <https://github.com/pytest-dev/pytest-asyncio/issues/1177>`_)
+- Deprecation warning when decorating an asynchronous fixture with ``@pytest.fixture`` in `strict` mode. The warning message now refers to the correct package. (`#1198 <https://github.com/pytest-dev/pytest-asyncio/issues/1198>`_)
+
+
+Notes for Downstream Packagers
+------------------------------
+
+- Bump the minimum required version of tox to v4.28. This change is only relevant if you use the ``tox.ini`` file provided by pytest-asyncio to run tests.
+- Extend dependency on typing-extensions>=4.12 from Python<3.10 to Python<3.13.
+
+
+`1.1.0 <https://github.com/pytest-dev/pytest-asyncio/tree/1.1.0>`_ - 2025-07-16
+===============================================================================
+
+Added
+-----
+
+- Propagation of ContextVars from async fixtures to other fixtures and tests on Python 3.10 and older (`#127 <https://github.com/pytest-dev/pytest-asyncio/issues/127>`_)
+- Cancellation of tasks when the `loop_scope` ends (`#200 <https://github.com/pytest-dev/pytest-asyncio/issues/200>`_)
+- Warning when the current event loop is closed by a test
+
+
+Fixed
+-----
+
+- Error about missing loop when calling functions requiring a loop in the `finally` clause of a task (`#878 <https://github.com/pytest-dev/pytest-asyncio/issues/878>`_)
+- An error that could cause duplicate warnings to be issued
+
+
+Notes for Downstream Packagers
+------------------------------
+
+- Added runtime dependency on `backports.asyncio.runner <https://pypi.org/project/backports.asyncio.runner/>`__ for use with Python 3.10 and older
+
+
+`1.0.0 <https://github.com/pytest-dev/pytest-asyncio/tree/1.0.0>`_ - 2025-05-26
+===============================================================================
+
+Removed
+-------
+
+- The deprecated *event_loop* fixture. (`#1106 <https://github.com/pytest-dev/pytest-asyncio/issues/1106>`_)
+
+
+Added
+-----
+
+- Prelimiary support for Python 3.14 (`#1025 <https://github.com/pytest-dev/pytest-asyncio/issues/1025>`_)
+
+
+Changed
+-------
+
+- Scoped event loops (e.g. module-scoped loops) are created once rather than per scope (e.g. per module). This reduces the number of fixtures and speeds up collection time, especially for large test suites. (`#1107 <https://github.com/pytest-dev/pytest-asyncio/issues/1107>`_)
+- The *loop_scope* argument to ``pytest.mark.asyncio`` no longer forces that a pytest Collector exists at the level of the specified scope. For example, a test function marked with ``pytest.mark.asyncio(loop_scope="class")`` no longer requires a class surrounding the test. This is consistent with the behavior of the *scope* argument to ``pytest_asyncio.fixture``. (`#1112 <https://github.com/pytest-dev/pytest-asyncio/issues/1112>`_)
+
+
+Fixed
+-----
+
+- An error caused when using pytest's `--setup-plan` option. (`#630 <https://github.com/pytest-dev/pytest-asyncio/issues/630>`_)
+- Unsuppressed import errors with pytest option ``--doctest-ignore-import-errors`` (`#797 <https://github.com/pytest-dev/pytest-asyncio/issues/797>`_)
+- A "fixture not found" error in connection with package-scoped loops (`#1052 <https://github.com/pytest-dev/pytest-asyncio/issues/1052>`_)
+
+
+Notes for Downstream Packagers
+------------------------------
+
+- Removed a test that had an ordering dependency on other tests. (`#1114 <https://github.com/pytest-dev/pytest-asyncio/issues/1114>`_)
+
+
+0.26.0 (2025-03-25)
+===================
+- Adds configuration option that sets default event loop scope for all tests `#793 <https://github.com/pytest-dev/pytest-asyncio/issues/793>`_
+- Improved type annotations for ``pytest_asyncio.fixture`` `#1045 <https://github.com/pytest-dev/pytest-asyncio/pull/1045>`_
+- Added ``typing-extensions`` as additional dependency for Python ``<3.10`` `#1045 <https://github.com/pytest-dev/pytest-asyncio/pull/1045>`_
+
+
+0.25.3 (2025-01-28)
+===================
+- Avoid errors in cleanup of async generators when event loop is already closed `#1040 <https://github.com/pytest-dev/pytest-asyncio/issues/1040>`_
+
+
+0.25.2 (2025-01-08)
+===================
+- Call ``loop.shutdown_asyncgens()`` before closing the event loop to ensure async generators are closed in the same manner as ``asyncio.run`` does `#1034 <https://github.com/pytest-dev/pytest-asyncio/pull/1034>`_
+
+
+0.25.1 (2025-01-02)
+===================
+- Fixes an issue that caused a broken event loop when a function-scoped test was executed in between two tests with wider loop scope `#950 <https://github.com/pytest-dev/pytest-asyncio/issues/950>`_
+- Improves test collection speed in auto mode `#1020 <https://github.com/pytest-dev/pytest-asyncio/pull/1020>`_
+- Corrects the warning that is emitted upon redefining the event_loop fixture
+
+
 0.25.0 (2024-12-13)
 ===================
-- Deprecated: Added warning when asyncio test requests async ``@pytest.fixture`` in strict mode. This will become an error in a future version of flake8-asyncio. `#979 <https://github.com/pytest-dev/pytest-asyncio/pull/979>`_
+- Deprecated: Added warning when asyncio test requests async ``@pytest.fixture`` in strict mode. This will become an error in a future version of pytest-asyncio. `#979 <https://github.com/pytest-dev/pytest-asyncio/pull/979>`_
 - Updates the error message about `pytest.mark.asyncio`'s `scope` keyword argument to say `loop_scope` instead. `#1004 <https://github.com/pytest-dev/pytest-asyncio/pull/1004>`_
 - Verbose log displays correct parameter name: asyncio_default_fixture_loop_scope `#990 <https://github.com/pytest-dev/pytest-asyncio/pull/990>`_
 - Propagates `contextvars` set in async fixtures to other fixtures and tests on Python 3.11 and above. `#1008 <https://github.com/pytest-dev/pytest-asyncio/pull/1008>`_
 
 
-
 0.24.0 (2024-08-22)
 ===================
 - BREAKING: Updated minimum supported pytest version to v8.2.0

docs/reference/configuration.rst

@@ -8,6 +8,35 @@ asyncio_default_fixture_loop_scope
 ==================================
 Determines the default event loop scope of asynchronous fixtures. When this configuration option is unset, it defaults to the fixture scope. In future versions of pytest-asyncio, the value will default to ``function`` when unset. Possible values are: ``function``, ``class``, ``module``, ``package``, ``session``
 
+.. _configuration/asyncio_default_test_loop_scope:
+
+asyncio_default_test_loop_scope
+===============================
+Determines the default event loop scope of asynchronous tests. When this configuration option is unset, it default to function scope. Possible values are: ``function``, ``class``, ``module``, ``package``, ``session``
+
+.. _configuration/asyncio_debug:
+
+asyncio_debug
+=============
+Enables `asyncio debug mode <https://docs.python.org/3/library/asyncio-dev.html#debug-mode>`_ for the default event loop used by asynchronous tests and fixtures.
+
+The debug mode can be set by the ``asyncio_debug`` configuration option in the `configuration file
+<https://docs.pytest.org/en/latest/reference/customize.html>`_:
+
+.. code-block:: ini
+
+   # pytest.ini
+   [pytest]
+   asyncio_debug = true
+
+The value can also be set via the ``--asyncio-debug`` command-line option:
+
+.. code-block:: bash
+
+   $ pytest tests --asyncio-debug
+
+By default, asyncio debug mode is disabled.
+
 asyncio_mode
 ============
 The pytest-asyncio mode can be set by the ``asyncio_mode`` configuration option in the `configuration file

docs/reference/fixtures/event_loop_policy_example.py

@@ -1,9 +1,14 @@
 import asyncio
+import warnings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from asyncio import DefaultEventLoopPolicy
 
 import pytest
 
 
-class CustomEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+class CustomEventLoopPolicy(DefaultEventLoopPolicy):
     pass
 
 
@@ -13,5 +18,6 @@ def event_loop_policy(request):
 
 
 @pytest.mark.asyncio(loop_scope="module")
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
 async def test_uses_custom_event_loop_policy():
     assert isinstance(asyncio.get_event_loop_policy(), CustomEventLoopPolicy)

docs/reference/fixtures/event_loop_policy_parametrized_example.py

@@ -1,10 +1,14 @@
 import asyncio
-from asyncio import DefaultEventLoopPolicy
+import warnings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from asyncio import DefaultEventLoopPolicy
 
 import pytest
 
 
-class CustomEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+class CustomEventLoopPolicy(DefaultEventLoopPolicy):
     pass
 
 
@@ -19,5 +23,6 @@ def event_loop_policy(request):
 
 
 @pytest.mark.asyncio
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
 async def test_uses_custom_event_loop_policy():
     assert isinstance(asyncio.get_event_loop_policy(), DefaultEventLoopPolicy)

docs/reference/fixtures/index.rst

@@ -2,24 +2,6 @@
 Fixtures
 ========
 
-event_loop
-==========
-Creates a new asyncio event loop based on the current event loop policy. The new loop
-is available as the return value of this fixture for synchronous functions, or via `asyncio.get_running_loop <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.get_running_loop>`__ for asynchronous functions.
-The event loop is closed when the fixture scope ends.
-The fixture scope defaults to ``function`` scope.
-
-.. include:: event_loop_example.py
-    :code: python
-
-Note that, when using the ``event_loop`` fixture, you need to interact with the event loop using methods like ``event_loop.run_until_complete``. If you want to *await* code inside your test function, you need to write a coroutine and use it as a test function. The `asyncio <#pytest-mark-asyncio>`__ marker
-is used to mark coroutines that should be treated as test functions.
-
-If you need to change the type of the event loop, prefer setting a custom event loop policy over redefining the ``event_loop`` fixture.
-
-If the ``pytest.mark.asyncio`` decorator is applied to a test function, the ``event_loop``
-fixture will be requested automatically by the test function.
-
 event_loop_policy
 =================
 Returns the event loop policy used to create asyncio event loops.

docs/reference/markers/class_scoped_loop_custom_policies_strict_mode_example.py

@@ -1,12 +1,16 @@
-import asyncio
+import warnings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from asyncio import DefaultEventLoopPolicy
 
 import pytest
 
 
 @pytest.fixture(
     params=[
-        asyncio.DefaultEventLoopPolicy(),
-        asyncio.DefaultEventLoopPolicy(),
+        DefaultEventLoopPolicy(),
+        DefaultEventLoopPolicy(),
     ]
 )
 def event_loop_policy(request):

docs/reference/markers/index.rst

@@ -2,6 +2,8 @@
 Markers
 =======
 
+.. _reference/markers/asyncio:
+
 ``pytest.mark.asyncio``
 =======================
 A coroutine or async generator with this marker is treated as a test function by pytest.
@@ -19,21 +21,17 @@ The ``pytest.mark.asyncio`` marker can be omitted entirely in |auto mode|_ where
 
 By default, each test runs in it's own asyncio event loop.
 Multiple tests can share the same event loop by providing a *loop_scope* keyword argument to the *asyncio* mark.
-The supported scopes are *class,* and *module,* and *package*.
+The supported scopes are *function,* *class,* and *module,* *package,* and *session*.
 The following code example provides a shared event loop for all tests in `TestClassScopedLoop`:
 
 .. include:: class_scoped_loop_strict_mode_example.py
     :code: python
 
-If you request class scope for a test that is not part of a class, it will result in a *UsageError*.
 Similar to class-scoped event loops, a module-scoped loop is provided when setting mark's scope to *module:*
 
 .. include:: module_scoped_loop_strict_mode_example.py
     :code: python
 
-Package-scoped loops only work with `regular Python packages. <https://docs.python.org/3/glossary.html#term-regular-package>`__
-That means they require an *__init__.py* to be present.
-Package-scoped loops do not work in `namespace packages. <https://docs.python.org/3/glossary.html#term-namespace-package>`__
 Subpackages do not share the loop with their parent package.
 
 Tests marked with *session* scope share the same event loop, even if the tests exist in different packages.

pyproject.toml

@@ -1,34 +1,38 @@
 [build-system]
 build-backend = "setuptools.build_meta"
-
 requires = [
-  "setuptools>=51",
+  "setuptools>=77",
   "setuptools-scm[toml]>=6.2",
-  "wheel>=0.36",
 ]
 
 [project]
 name = "pytest-asyncio"
 description = "Pytest support for asyncio"
 readme.content-type = "text/x-rst"
 readme.file = "README.rst"
-license.text = "Apache 2.0"
+license = "Apache-2.0"
+license-files = [
+  "LICENSE",
+]
+maintainers = [
+  { name = "Michael Seifert", email = "m.seifert@digitalernachschub.de" },
+]
 authors = [
-  { name = "Tin Tvrtković <tinchester@gmail.com>", email = "tinchester@gmail.com" },
+  { name = "Tin Tvrtković", email = "tinchester@gmail.com" },
 ]
 requires-python = ">=3.9"
 classifiers = [
-  "Development Status :: 4 - Beta",
+  "Development Status :: 5 - Production/Stable",
   "Framework :: AsyncIO",
   "Framework :: Pytest",
   "Intended Audience :: Developers",
-  "License :: OSI Approved :: Apache Software License",
   "Programming Language :: Python :: 3 :: Only",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Testing",
   "Typing :: Typed",
 ]
@@ -37,7 +41,9 @@ dynamic = [
 ]
 
 dependencies = [
+  "backports-asyncio-runner>=1.1,<2; python_version<'3.11'",
   "pytest>=8.2,<9",
+  "typing-extensions>=4.12; python_version<'3.13'",
 ]
 optional-dependencies.docs = [
   "sphinx>=5.3",
@@ -59,12 +65,9 @@ packages = [
   "pytest_asyncio",
 ]
 include-package-data = true
-license-files = [
-  "LICENSE",
-]
 
 [tool.setuptools_scm]
-write_to = "pytest_asyncio/_version.py"
+local_scheme = "no-local-version"
 
 [tool.ruff]
 line-length = 88
@@ -108,6 +111,9 @@ lint.ignore = [
   "D415", # First line should end with a period, question mark, or exclamation point
 ]
 
+[tool.pyproject-fmt]
+max_supported_python = "3.14"
+
 [tool.pytest.ini_options]
 python_files = [
   "test_*.py",
@@ -123,7 +129,6 @@ asyncio_default_fixture_loop_scope = "function"
 junit_family = "xunit2"
 filterwarnings = [
   "error",
-  "ignore:The event_loop fixture provided by pytest-asyncio has been redefined.*:DeprecationWarning",
 ]
 
 [tool.coverage.run]
@@ -132,10 +137,48 @@ source = [
 ]
 branch = true
 data_file = "coverage/coverage"
-omit = [
-  "*/_version.py",
-]
 parallel = true
 
 [tool.coverage.report]
 show_missing = true
+
+[tool.towncrier]
+directory = "changelog.d"
+filename = "docs/reference/changelog.rst"
+title_format = "`{version} <https://github.com/pytest-dev/pytest-asyncio/tree/{version}>`_ - {project_date}"
+issue_format = "`#{issue} <https://github.com/pytest-dev/pytest-asyncio/issues/{issue}>`_"
+
+[[tool.towncrier.type]]
+directory = "security"
+name = "Security"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removed"
+name = "Removed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "deprecated"
+name = "Deprecated"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "added"
+name = "Added"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "changed"
+name = "Changed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "fixed"
+name = "Fixed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "downstream"
+name = "Notes for Downstream Packagers"
+showcontent = true

pytest_asyncio/__init__.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from ._version import version as __version__  # noqa: F401
+from importlib.metadata import version
+
 from .plugin import fixture, is_async_test
 
+__version__ = version(__name__)
+
 __all__ = ("fixture", "is_async_test")

tests/async_fixtures/test_async_fixtures_contextvars.py

@@ -5,8 +5,8 @@
 
 from __future__ import annotations
 
-import sys
 from textwrap import dedent
+from typing import Literal
 
 import pytest
 from pytest import Pytester
@@ -56,11 +56,6 @@ async def test(check_var_fixture):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_from_async_generator_propagates_to_sync(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -86,11 +81,6 @@ async def test(check_var_fixture):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_from_async_fixture_propagates_to_sync(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -115,11 +105,6 @@ def test(check_var_fixture):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_from_generator_reset_before_previous_fixture_cleanup(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -149,11 +134,6 @@ async def test(var_fixture):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_from_fixture_reset_before_previous_fixture_cleanup(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -183,11 +163,6 @@ async def test(var_fixture):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_previous_value_restored_after_fixture(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -216,11 +191,6 @@ async def test(var_fixture_2):
     result.assert_outcomes(passed=1)
 
 
-@pytest.mark.xfail(
-    sys.version_info < (3, 11),
-    reason="requires asyncio Task context support",
-    strict=True,
-)
 def test_var_set_to_existing_value_ok(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -245,3 +215,56 @@ async def test(same_var_fixture):
     )
     result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=1)
+
+
+def test_no_isolation_against_context_changes_in_sync_tests(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """
+            import pytest
+            import pytest_asyncio
+            from contextvars import ContextVar
+
+            _context_var = ContextVar("my_var")
+
+            def test_sync():
+                _context_var.set("new_value")
+
+            @pytest.mark.asyncio
+            async def test_async():
+                assert _context_var.get() == "new_value"
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-mode=strict")
+    result.assert_outcomes(passed=2)
+
+
+@pytest.mark.parametrize("loop_scope", ("function", "module"))
+def test_isolation_against_context_changes_in_async_tests(
+    pytester: Pytester, loop_scope: Literal["function", "module"]
+):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            f"""
+            import pytest
+            import pytest_asyncio
+            from contextvars import ContextVar
+
+            _context_var = ContextVar("my_var")
+
+            @pytest.mark.asyncio(loop_scope="{loop_scope}")
+            async def test_async_first():
+                _context_var.set("new_value")
+
+            @pytest.mark.asyncio(loop_scope="{loop_scope}")
+            async def test_async_second():
+                with pytest.raises(LookupError):
+                    _context_var.get()
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-mode=strict")
+    result.assert_outcomes(passed=2)

tests/conftest.py

@@ -1,34 +1,3 @@
 from __future__ import annotations
 
-import asyncio
-
-import pytest
-
 pytest_plugins = "pytester"
-
-
-@pytest.fixture
-def dependent_fixture(event_loop):
-    """A fixture dependent on the event_loop fixture, doing some cleanup."""
-    counter = 0
-
-    async def just_a_sleep():
-        """Just sleep a little while."""
-        nonlocal event_loop
-        await asyncio.sleep(0.1)
-        nonlocal counter
-        counter += 1
-
-    event_loop.run_until_complete(just_a_sleep())
-    yield
-    event_loop.run_until_complete(just_a_sleep())
-
-    assert counter == 2
-
-
-@pytest.fixture(scope="session", name="factory_involving_factories")
-def factory_involving_factories_fixture(unused_tcp_port_factory):
-    def factory():
-        return unused_tcp_port_factory()
-
-    return factory

tests/hypothesis/test_base.py

@@ -45,43 +45,6 @@ async def test_mark_and_parametrize(x, y):
     assert y in (1, 2)
 
 
-def test_can_use_explicit_event_loop_fixture(pytester: Pytester):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = module")
-    pytester.makepyfile(
-        dedent(
-            """\
-            import asyncio
-            import pytest
-            from hypothesis import given
-            import hypothesis.strategies as st
-
-            pytest_plugins = 'pytest_asyncio'
-
-            @pytest.fixture(scope="module")
-            def event_loop():
-                loop = asyncio.get_event_loop_policy().new_event_loop()
-                yield loop
-                loop.close()
-
-            @given(st.integers())
-            @pytest.mark.asyncio
-            async def test_explicit_fixture_request(event_loop, n):
-                semaphore = asyncio.Semaphore(value=0)
-                event_loop.call_soon(semaphore.release)
-                await semaphore.acquire()
-            """
-        )
-    )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(passed=1, warnings=2)
-    result.stdout.fnmatch_lines(
-        [
-            '*is asynchronous and explicitly requests the "event_loop" fixture*',
-            "*event_loop fixture provided by pytest-asyncio has been redefined*",
-        ]
-    )
-
-
 def test_async_auto_marked(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(

tests/markers/test_class_scope.py

@@ -82,29 +82,6 @@ async def test_this_runs_in_same_loop(self):
     result.assert_outcomes(passed=2)
 
 
-def test_asyncio_mark_raises_when_class_scoped_is_request_without_class(
-    pytester: pytest.Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        dedent(
-            """\
-            import asyncio
-            import pytest
-
-            @pytest.mark.asyncio(loop_scope="class")
-            async def test_has_no_surrounding_class():
-                pass
-            """
-        )
-    )
-    result = pytester.runpytest("--asyncio-mode=strict")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines(
-        "*is marked to be run in an event loop with scope*",
-    )
-
-
 def test_asyncio_mark_is_inherited_to_subclasses(pytester: pytest.Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(

tests/markers/test_function_scope.py

@@ -87,32 +87,9 @@ async def test_warns():
             """
         )
     )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
-    result.assert_outcomes(passed=1, warnings=2)
-    result.stdout.fnmatch_lines("*DeprecationWarning*")
-
-
-def test_function_scope_supports_explicit_event_loop_fixture_request(
-    pytester: Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        dedent(
-            """\
-            import pytest
-
-            pytestmark = pytest.mark.asyncio
-
-            async def test_remember_loop(event_loop):
-                pass
-            """
-        )
-    )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
+    result = pytester.runpytest("--asyncio-mode=strict", "--assert=plain")
     result.assert_outcomes(passed=1, warnings=1)
-    result.stdout.fnmatch_lines(
-        '*is asynchronous and explicitly requests the "event_loop" fixture*'
-    )
+    result.stdout.fnmatch_lines("*DeprecationWarning*")
 
 
 def test_asyncio_mark_respects_the_loop_policy(
@@ -180,7 +157,7 @@ async def test_parametrized_loop():
             """
         )
     )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=2)
 
 
@@ -211,7 +188,7 @@ async def test_runs_is_same_loop_as_fixture(my_fixture):
             """
         )
     )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=1)
 
 
@@ -265,7 +242,7 @@ async def test_anything():
             """
         )
     )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result = pytester.runpytest("--asyncio-mode=strict", "--assert=plain")
     result.assert_outcomes(warnings=0, passed=1)
 
 
@@ -297,5 +274,5 @@ async def test_markers_not_duplicated(request):
             """
         )
     )
-    result = pytester.runpytest_subprocess("--asyncio-mode=auto")
+    result = pytester.runpytest("--asyncio-mode=auto", "--assert=plain")
     result.assert_outcomes(warnings=0, passed=1)

tests/markers/test_mixed_scope.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from textwrap import dedent
+
+from pytest import Pytester
+
+
+def test_function_scoped_loop_restores_previous_loop_scope(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+
+            module_loop: asyncio.AbstractEventLoop
+
+            @pytest.mark.asyncio(loop_scope="module")
+            async def test_remember_loop():
+                global module_loop
+                module_loop = asyncio.get_running_loop()
+
+            @pytest.mark.asyncio(loop_scope="function")
+            async def test_with_function_scoped_loop():
+                pass
+
+            @pytest.mark.asyncio(loop_scope="module")
+            async def test_runs_in_same_loop():
+                global module_loop
+                assert asyncio.get_running_loop() is module_loop
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-mode=strict")
+    result.assert_outcomes(passed=3)

tests/markers/test_module_scope.py

@@ -5,59 +5,6 @@
 from pytest import Pytester
 
 
-def test_asyncio_mark_works_on_module_level(pytester: Pytester):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        dedent(
-            """\
-            import asyncio
-
-            import pytest
-
-            pytestmark = pytest.mark.asyncio
-
-
-            class TestPyTestMark:
-                async def test_is_asyncio(self, event_loop, sample_fixture):
-                    assert asyncio.get_event_loop()
-
-                    counter = 1
-
-                    async def inc():
-                        nonlocal counter
-                        counter += 1
-                        await asyncio.sleep(0)
-
-                    await asyncio.ensure_future(inc())
-                    assert counter == 2
-
-
-            async def test_is_asyncio(event_loop, sample_fixture):
-                assert asyncio.get_event_loop()
-                counter = 1
-
-                async def inc():
-                    nonlocal counter
-                    counter += 1
-                    await asyncio.sleep(0)
-
-                await asyncio.ensure_future(inc())
-                assert counter == 2
-
-
-            @pytest.fixture
-            def sample_fixture():
-                return None
-            """
-        )
-    )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(passed=2, warnings=2)
-    result.stdout.fnmatch_lines(
-        '*is asynchronous and explicitly requests the "event_loop" fixture*'
-    )
-
-
 def test_asyncio_mark_provides_module_scoped_loop_strict_mode(pytester: Pytester):
     pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
     pytester.makepyfile(
@@ -89,28 +36,6 @@ async def test_this_runs_in_same_loop(self):
     result.assert_outcomes(passed=3)
 
 
-def test_raise_when_event_loop_fixture_is_requested_in_addition_to_scoped_loop(
-    pytester: Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        dedent(
-            """\
-            import asyncio
-            import pytest
-
-            pytestmark = pytest.mark.asyncio(loop_scope="module")
-
-            async def test_remember_loop(event_loop):
-                pass
-            """
-        )
-    )
-    result = pytester.runpytest("--asyncio-mode=strict")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines("*MultipleEventLoopsRequestedError: *")
-
-
 def test_asyncio_mark_respects_the_loop_policy(
     pytester: Pytester,
 ):

tests/markers/test_package_scope.py

@@ -69,28 +69,6 @@ async def test_subpackage_runs_in_different_loop():
     result.assert_outcomes(passed=4)
 
 
-def test_raise_when_event_loop_fixture_is_requested_in_addition_to_scoped_loop(
-    pytester: Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        __init__="",
-        test_raises=dedent(
-            """\
-            import asyncio
-            import pytest
-
-            @pytest.mark.asyncio(loop_scope="package")
-            async def test_remember_loop(event_loop):
-                pass
-            """
-        ),
-    )
-    result = pytester.runpytest("--asyncio-mode=strict")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines("*MultipleEventLoopsRequestedError: *")
-
-
 def test_asyncio_mark_respects_the_loop_policy(
     pytester: Pytester,
 ):
@@ -361,23 +339,3 @@ async def test_does_not_fail(sets_event_loop_to_none, n):
     )
     result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=2)
-
-
-def test_standalone_test_does_not_trigger_warning_about_no_current_event_loop_being_set(
-    pytester: Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        __init__="",
-        test_module=dedent(
-            """\
-            import pytest
-
-            @pytest.mark.asyncio(loop_scope="package")
-            async def test_anything():
-                pass
-            """
-        ),
-    )
-    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
-    result.assert_outcomes(warnings=0, passed=1)

tests/markers/test_session_scope.py

@@ -70,28 +70,6 @@ async def test_subpackage_runs_in_same_loop():
     result.assert_outcomes(passed=4)
 
 
-def test_raise_when_event_loop_fixture_is_requested_in_addition_to_scoped_loop(
-    pytester: Pytester,
-):
-    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
-    pytester.makepyfile(
-        __init__="",
-        test_raises=dedent(
-            """\
-            import asyncio
-            import pytest
-
-            @pytest.mark.asyncio(loop_scope="session")
-            async def test_remember_loop(event_loop):
-                pass
-            """
-        ),
-    )
-    result = pytester.runpytest("--asyncio-mode=strict")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines("*MultipleEventLoopsRequestedError: *")
-
-
 def test_asyncio_mark_respects_the_loop_policy(
     pytester: Pytester,
 ):

tests/modes/test_strict_mode.py

@@ -2,7 +2,7 @@
 
 from textwrap import dedent
 
-from pytest import Pytester
+from pytest import Pytester, version_tuple as pytest_version
 
 
 def test_strict_mode_cmdline(pytester: Pytester):
@@ -95,7 +95,10 @@ async def test_anything():
         )
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(skipped=1, warnings=1)
+    if pytest_version >= (8, 4, 0):
+        result.assert_outcomes(failed=1, skipped=0, warnings=0)
+    else:
+        result.assert_outcomes(skipped=1, warnings=1)
     result.stdout.fnmatch_lines(["*async def functions are not natively supported*"])
 
 
@@ -117,7 +120,11 @@ async def test_anything(any_fixture):
         )
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(skipped=1, warnings=2)
+
+    if pytest_version >= (8, 4, 0):
+        result.assert_outcomes(failed=1, skipped=0, warnings=2)
+    else:
+        result.assert_outcomes(skipped=1, warnings=2)
     result.stdout.fnmatch_lines(
         [
             "*async def functions are not natively supported*",
@@ -149,7 +156,10 @@ async def test_anything(any_fixture):
         )
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(passed=1, failed=0, skipped=0, warnings=1)
+    if pytest_version >= (8, 4, 0):
+        result.assert_outcomes(passed=1, failed=0, skipped=0, warnings=2)
+    else:
+        result.assert_outcomes(passed=1, failed=0, skipped=0, warnings=1)
     result.stdout.fnmatch_lines(
         [
             "*warnings summary*",
@@ -163,7 +173,7 @@ async def test_anything(any_fixture):
                 "@pytest.fixture 'any_fixture' in strict mode. "
                 "You might want to use @pytest_asyncio.fixture or switch to "
                 "auto mode. "
-                "This will become an error in future versions of flake8-asyncio."
+                "This will become an error in future versions of pytest-asyncio."
             ),
         ],
     )
@@ -193,7 +203,10 @@ async def test_anything(any_fixture):
         )
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W default")
-    result.assert_outcomes(passed=1, warnings=1)
+    if pytest_version >= (8, 4, 0):
+        result.assert_outcomes(passed=1, warnings=2)
+    else:
+        result.assert_outcomes(passed=1, warnings=1)
     result.stdout.fnmatch_lines(
         [
             "*warnings summary*",
@@ -207,7 +220,7 @@ async def test_anything(any_fixture):
                 "@pytest.fixture 'any_fixture' in strict mode. "
                 "You might want to use @pytest_asyncio.fixture or switch to "
                 "auto mode. "
-                "This will become an error in future versions of flake8-asyncio."
+                "This will become an error in future versions of pytest-asyncio."
             ),
         ],
     )

tests/test_asyncio_debug.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from textwrap import dedent
+
+import pytest
+from pytest import Pytester
+
+
+def test_asyncio_debug_disabled_by_default(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_disabled():
+                loop = asyncio.get_running_loop()
+                assert not loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_asyncio_debug_enabled_via_cli_option(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_enabled():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-debug")
+    result.assert_outcomes(passed=1)
+
+
+@pytest.mark.parametrize("config_value", ("true", "1"))
+def test_asyncio_debug_enabled_via_config_option(pytester: Pytester, config_value: str):
+    pytester.makeini(
+        dedent(
+            f"""\
+            [pytest]
+            asyncio_default_fixture_loop_scope = function
+            asyncio_debug = {config_value}
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_enabled():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+@pytest.mark.parametrize("config_value", ("false", "0"))
+def test_asyncio_debug_disabled_via_config_option(
+    pytester: Pytester,
+    config_value: str,
+):
+    pytester.makeini(
+        dedent(
+            f"""\
+            [pytest]
+            asyncio_default_fixture_loop_scope = function
+            asyncio_debug = {config_value}
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_disabled():
+                loop = asyncio.get_running_loop()
+                assert not loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_asyncio_debug_cli_option_overrides_config(pytester: Pytester):
+    pytester.makeini(
+        "[pytest]\nasyncio_default_fixture_loop_scope = function\nasyncio_debug = false"
+    )
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_enabled():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-debug")
+    result.assert_outcomes(passed=1)
+
+
+@pytest.mark.parametrize("loop_scope", ("function", "module", "session"))
+def test_asyncio_debug_with_different_loop_scopes(pytester: Pytester, loop_scope: str):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio(loop_scope="{loop_scope}")
+            async def test_debug_mode_with_scope():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-debug")
+    result.assert_outcomes(passed=1)
+
+
+def test_asyncio_debug_with_async_fixtures(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+            import pytest_asyncio
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest_asyncio.fixture
+            async def async_fixture():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+                return "fixture_value"
+
+            @pytest.mark.asyncio
+            async def test_debug_mode_with_fixture(async_fixture):
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+                assert async_fixture == "fixture_value"
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-debug")
+    result.assert_outcomes(passed=1)
+
+
+def test_asyncio_debug_multiple_test_functions(pytester: Pytester):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_debug_first():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+
+            @pytest.mark.asyncio
+            async def test_debug_second():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+
+            @pytest.mark.asyncio
+            async def test_debug_third():
+                loop = asyncio.get_running_loop()
+                assert loop.get_debug()
+            """
+        )
+    )
+    result = pytester.runpytest("--asyncio-debug")
+    result.assert_outcomes(passed=3)

tests/test_asyncio_mark.py

@@ -146,3 +146,80 @@ async def test_a():
     result.stdout.fnmatch_lines(
         ["*Tests based on asynchronous generators are not supported*"]
     )
+
+
+def test_asyncio_marker_fallbacks_to_configured_default_loop_scope_if_not_set(
+    pytester: Pytester,
+):
+    pytester.makeini(
+        dedent(
+            """\
+            [pytest]
+            asyncio_default_fixture_loop_scope = function
+            asyncio_default_test_loop_scope = session
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest_asyncio
+            import pytest
+
+            loop: asyncio.AbstractEventLoop
+
+            @pytest_asyncio.fixture(loop_scope="session", scope="session")
+            async def session_loop_fixture():
+                global loop
+                loop = asyncio.get_running_loop()
+
+            async def test_a(session_loop_fixture):
+                global loop
+                assert asyncio.get_running_loop() is loop
+            """
+        )
+    )
+
+    result = pytester.runpytest("--asyncio-mode=auto")
+    result.assert_outcomes(passed=1)
+
+
+def test_asyncio_marker_uses_marker_loop_scope_even_if_config_is_set(
+    pytester: Pytester,
+):
+    pytester.makeini(
+        dedent(
+            """\
+            [pytest]
+            asyncio_default_fixture_loop_scope = function
+            asyncio_default_test_loop_scope = module
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest_asyncio
+            import pytest
+
+            loop: asyncio.AbstractEventLoop
+
+            @pytest_asyncio.fixture(loop_scope="session", scope="session")
+            async def session_loop_fixture():
+                global loop
+                loop = asyncio.get_running_loop()
+
+            @pytest.mark.asyncio(loop_scope="session")
+            async def test_a(session_loop_fixture):
+                global loop
+                assert asyncio.get_running_loop() is loop
+            """
+        )
+    )
+
+    result = pytester.runpytest("--asyncio-mode=auto")
+    result.assert_outcomes(passed=1)

tests/test_event_loop_fixture.py

@@ -53,3 +53,91 @@ async def test_custom_policy_is_not_overwritten():
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict")
     result.assert_outcomes(passed=2)
+
+
+def test_event_loop_fixture_handles_unclosed_async_gen(
+    pytester: Pytester,
+):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = 'pytest_asyncio'
+
+            @pytest.mark.asyncio
+            async def test_something():
+                async def generator_fn():
+                    yield
+                    yield
+
+                gen = generator_fn()
+                await gen.__anext__()
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W", "default")
+    result.assert_outcomes(passed=1, warnings=0)
+
+
+def test_closing_event_loop_in_sync_fixture_teardown_raises_warning(
+    pytester: Pytester,
+):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+            import pytest_asyncio
+            pytest_plugins = 'pytest_asyncio'
+
+            @pytest_asyncio.fixture
+            async def _event_loop():
+                return asyncio.get_running_loop()
+
+            @pytest.fixture
+            def close_event_loop(_event_loop):
+                yield
+                # fixture has its own cleanup code
+                _event_loop.close()
+
+            @pytest.mark.asyncio
+            async def test_something(close_event_loop):
+                await asyncio.sleep(0.01)
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result.assert_outcomes(passed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*An exception occurred during teardown of an asyncio.Runner*"]
+    )
+
+
+def test_event_loop_fixture_asyncgen_error(
+    pytester: Pytester,
+):
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            pytest_plugins = 'pytest_asyncio'
+
+            @pytest.mark.asyncio
+            async def test_something():
+                # mock shutdown_asyncgen failure
+                loop = asyncio.get_running_loop()
+                async def fail():
+                    raise RuntimeError("mock error cleaning up...")
+                loop.shutdown_asyncgens = fail
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict", "-W", "default")
+    result.assert_outcomes(passed=1, warnings=1)

tests/test_fixture_loop_scopes.py

@@ -136,3 +136,20 @@ async def test_runs_in_fixture_loop(fixture_loop):
     )
     result = pytester.runpytest_subprocess("--asyncio-mode=strict")
     result.assert_outcomes(passed=1)
+
+
+def test_invalid_default_fixture_loop_scope_raises_error(pytester: Pytester):
+    pytester.makeini(
+        """\
+        [pytest]
+        asyncio_default_fixture_loop_scope = invalid_scope
+        """
+    )
+    result = pytester.runpytest()
+    result.stderr.fnmatch_lines(
+        [
+            "ERROR: 'invalid_scope' is not a valid "
+            "asyncio_default_fixture_loop_scope. Valid scopes are: "
+            "function, class, module, package, session."
+        ]
+    )

tests/test_package.py

@@ -0,0 +1,5 @@
+import pytest_asyncio
+
+
+def test_package_exposes_version():
+    assert pytest_asyncio.__version__

tests/test_set_event_loop.py

@@ -0,0 +1,371 @@
+from __future__ import annotations
+
+import sys
+from textwrap import dedent
+
+import pytest
+from pytest import Pytester
+
+
+@pytest.mark.parametrize(
+    "test_loop_scope",
+    ("function", "module", "package", "session"),
+)
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_set_event_loop_none(
+    pytester: Pytester,
+    test_loop_scope: str,
+    loop_breaking_action: str,
+):
+    pytester.makeini(
+        dedent(
+            f"""\
+            [pytest]
+            asyncio_default_test_loop_scope = {test_loop_scope}
+            asyncio_default_fixture_loop_scope = function
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            @pytest.mark.asyncio
+            async def test_before():
+                pass
+
+            def test_set_event_loop_none():
+                {loop_breaking_action}
+
+            @pytest.mark.asyncio
+            async def test_after():
+                pass
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess()
+    result.assert_outcomes(passed=3)
+
+
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_set_event_loop_none_class(pytester: Pytester, loop_breaking_action: str):
+    pytester.makeini(
+        dedent(
+            """\
+            [pytest]
+            asyncio_default_test_loop_scope = class
+            asyncio_default_fixture_loop_scope = function
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+
+            class TestClass:
+                @pytest.mark.asyncio
+                async def test_before(self):
+                    pass
+
+                def test_set_event_loop_none(self):
+                    {loop_breaking_action}
+
+                @pytest.mark.asyncio
+                async def test_after(self):
+                    pass
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess()
+    result.assert_outcomes(passed=3)
+
+
+@pytest.mark.parametrize("test_loop_scope", ("module", "package", "session"))
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_original_shared_loop_is_reinstated_not_fresh_loop(
+    pytester: Pytester,
+    test_loop_scope: str,
+    loop_breaking_action: str,
+):
+    pytester.makeini(
+        dedent(
+            f"""\
+            [pytest]
+            asyncio_default_test_loop_scope = {test_loop_scope}
+            asyncio_default_fixture_loop_scope = function
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+
+            pytest_plugins = "pytest_asyncio"
+
+            original_shared_loop: asyncio.AbstractEventLoop = None
+
+            @pytest.mark.asyncio
+            async def test_store_original_shared_loop():
+                global original_shared_loop
+                original_shared_loop = asyncio.get_running_loop()
+                original_shared_loop._custom_marker = "original_loop_marker"
+
+            def test_unset_event_loop():
+                {loop_breaking_action}
+
+            @pytest.mark.asyncio
+            async def test_verify_original_loop_reinstated():
+                global original_shared_loop
+                current_loop = asyncio.get_running_loop()
+                assert current_loop is original_shared_loop
+                assert hasattr(current_loop, '_custom_marker')
+                assert current_loop._custom_marker == "original_loop_marker"
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result.assert_outcomes(passed=3)
+
+
+@pytest.mark.parametrize("test_loop_scope", ("module", "package", "session"))
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_shared_loop_with_fixture_preservation(
+    pytester: Pytester,
+    test_loop_scope: str,
+    loop_breaking_action: str,
+):
+    pytester.makeini(
+        dedent(
+            f"""\
+            [pytest]
+            asyncio_default_test_loop_scope = {test_loop_scope}
+            asyncio_default_fixture_loop_scope = {test_loop_scope}
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+            import pytest_asyncio
+
+            pytest_plugins = "pytest_asyncio"
+
+            fixture_loop: asyncio.AbstractEventLoop = None
+            long_running_task = None
+
+            @pytest_asyncio.fixture
+            async def webserver():
+                global fixture_loop, long_running_task
+                fixture_loop = asyncio.get_running_loop()
+
+                async def background_task():
+                    while True:
+                        await asyncio.sleep(1)
+
+                long_running_task = asyncio.create_task(background_task())
+                yield
+                long_running_task.cancel()
+
+
+            @pytest.mark.asyncio
+            async def test_before(webserver):
+                global fixture_loop, long_running_task
+                assert asyncio.get_running_loop() is fixture_loop
+                assert not long_running_task.done()
+
+
+            def test_set_event_loop_none():
+                {loop_breaking_action}
+
+
+            @pytest.mark.asyncio
+            async def test_after(webserver):
+                global fixture_loop, long_running_task
+                current_loop = asyncio.get_running_loop()
+                assert current_loop is fixture_loop
+                assert not long_running_task.done()
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result.assert_outcomes(passed=3)
+
+
+@pytest.mark.parametrize(
+    "first_scope,second_scope",
+    [
+        ("module", "session"),
+        ("session", "module"),
+        ("package", "session"),
+        ("session", "package"),
+        ("package", "module"),
+        ("module", "package"),
+    ],
+)
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_shared_loop_with_multiple_fixtures_preservation(
+    pytester: Pytester,
+    first_scope: str,
+    second_scope: str,
+    loop_breaking_action: str,
+):
+    pytester.makeini(
+        dedent(
+            """\
+            [pytest]
+            asyncio_default_test_loop_scope = session
+            asyncio_default_fixture_loop_scope = session
+            """
+        )
+    )
+    pytester.makepyfile(
+        dedent(
+            f"""\
+            import asyncio
+            import pytest
+            import pytest_asyncio
+
+            pytest_plugins = "pytest_asyncio"
+
+            first_fixture_loop: asyncio.AbstractEventLoop = None
+            second_fixture_loop: asyncio.AbstractEventLoop = None
+            first_long_running_task = None
+            second_long_running_task = None
+
+            @pytest_asyncio.fixture(scope="{first_scope}", loop_scope="{first_scope}")
+            async def first_webserver():
+                global first_fixture_loop, first_long_running_task
+                first_fixture_loop = asyncio.get_running_loop()
+
+                async def background_task():
+                    while True:
+                        await asyncio.sleep(0.1)
+
+                first_long_running_task = asyncio.create_task(background_task())
+                yield
+                first_long_running_task.cancel()
+
+            @pytest_asyncio.fixture(scope="{second_scope}", loop_scope="{second_scope}")
+            async def second_webserver():
+                global second_fixture_loop, second_long_running_task
+                second_fixture_loop = asyncio.get_running_loop()
+
+                async def background_task():
+                    while True:
+                        await asyncio.sleep(0.1)
+
+                second_long_running_task = asyncio.create_task(background_task())
+                yield
+                second_long_running_task.cancel()
+
+            @pytest.mark.asyncio(loop_scope="{first_scope}")
+            async def test_before_first(first_webserver):
+                global first_fixture_loop, first_long_running_task
+                assert asyncio.get_running_loop() is first_fixture_loop
+                assert not first_long_running_task.done()
+
+            @pytest.mark.asyncio(loop_scope="{second_scope}")
+            async def test_before_second(second_webserver):
+                global second_fixture_loop, second_long_running_task
+                assert asyncio.get_running_loop() is second_fixture_loop
+                assert not second_long_running_task.done()
+
+            def test_set_event_loop_none():
+                {loop_breaking_action}
+
+            @pytest.mark.asyncio(loop_scope="{first_scope}")
+            async def test_after_first(first_webserver):
+                global first_fixture_loop, first_long_running_task
+                current_loop = asyncio.get_running_loop()
+                assert current_loop is first_fixture_loop
+                assert not first_long_running_task.done()
+
+            @pytest.mark.asyncio(loop_scope="{second_scope}")
+            async def test_after_second(second_webserver):
+                global second_fixture_loop, second_long_running_task
+                current_loop = asyncio.get_running_loop()
+                assert current_loop is second_fixture_loop
+                assert not second_long_running_task.done()
+            """
+        )
+    )
+    result = pytester.runpytest_subprocess("--asyncio-mode=strict")
+    result.assert_outcomes(passed=5)

tests/test_simple.py

@@ -14,13 +14,6 @@ async def async_coro():
     return "ok"
 
 
-def test_event_loop_fixture(event_loop):
-    """Test the injection of the event_loop fixture."""
-    assert event_loop
-    ret = event_loop.run_until_complete(async_coro())
-    assert ret == "ok"
-
-
 @pytest.mark.asyncio
 async def test_asyncio_marker():
     """Test the asyncio pytest marker."""

tests/test_subprocess.py

@@ -7,16 +7,6 @@
 
 import pytest
 
-if sys.platform == "win32":
-    # The default asyncio event loop implementation on Windows does not
-    # support subprocesses. Subprocesses are available for Windows if a
-    # ProactorEventLoop is used.
-    @pytest.fixture()
-    def event_loop():
-        loop = asyncio.ProactorEventLoop()
-        yield loop
-        loop.close()
-
 
 @pytest.mark.asyncio
 async def test_subprocess():