@@ -497,6 +497,51 @@ When the tests are run with ``-vv`` then it will show both errors::
       <RequestMatcher uri='/bar' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
 
 
+Server-side errors in the test report
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Calling ``check()`` (or any other similar method) raises the server-side
+errors in the test but this must be done explicitly. If the test fails before
+these errors would be raised (for example an assertion about the response
+fails), the errors collected by the server remain unseen, although they could
+explain the failure of the test.
+
+To make the debugging of such tests easier, the plugin automatically attaches
+these errors to the report of the failed test. When a test fails, the pending
+server-side assertions (such as the one added when the server received a
+request which was not matching any of the registered handlers) and the errors
+raised in the request handlers are shown as an extra section of the failure
+output::
+
+  --------------------------- pytest-httpserver report ---------------------------
+  Server-side errors collected by pytest-httpserver (not raised during the test):
+  --- <HTTPServer host=localhost port=37425>
+  Pending server-side assertions:
+
+  1. No handler found for request <Request 'http://localhost:37425/foobar' [GET]> with data b''.Ordered matchers:
+      none
+
+  Oneshot matchers:
+      none
+
+  Persistent matchers:
+      <RequestMatcher uri='/foo' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
+
+  Note: these errors were not raised because the test did not call the check methods of the server (for example HTTPServer.check()).
+
+Errors which were already raised during the test (by calling the ``check()``
+methods) are not added to the report again, and the errors collected during a
+test are not leaked into the report of the other tests.
+
+This works for every test which uses the ``httpserver``, ``httpserver_ipv4``
+or ``httpserver_ipv6`` fixture, no configuration is needed. If you use your
+own server object in a custom fixture (for example a
+:py:class:`pytest_httpserver.BlockingHTTPServer`), you can call the
+``register_server()`` function of the ``pytest_httpserver.pytest_plugin``
+module (with the ``request`` fixture and the server object as parameters) to
+get the same behavior.
+
+
 Logs
 ~~~~
 
 
@@ -6,11 +6,16 @@
 import pytest
 
 from .httpserver import HTTPServer
+from .httpserver import HTTPServerBase
 
 if TYPE_CHECKING:
     from collections.abc import Generator
     from ssl import SSLContext
 
+REPORT_SECTION_TITLE = "pytest-httpserver report"
+
+SERVERS_STASH_KEY = pytest.StashKey[list[HTTPServerBase]]()
+
 
 class Plugin:
     SERVER: PluginHTTPServer | None = None
@@ -26,6 +31,33 @@ def stop(self) -> None:
         Plugin.SERVER = None
 
 
+def register_server(request: pytest.FixtureRequest, server: HTTPServerBase) -> None:
+    """
+    Registers the server for the test currently being set up.
+
+    Registered servers are inspected when the test fails: pending server-side
+    assertions (such as the one added when the server received a request which
+    was not matching any of the registered handlers) and the errors collected
+    from the request handlers are attached to the test report to make the
+    debugging of the failed test easier.
+
+    The fixtures provided by this plugin call this method automatically but it
+    can be also called from a custom fixture (with the ``request`` fixture as
+    the first parameter) to get the same report behavior for other server
+    objects, such as a :py:class:`pytest_httpserver.BlockingHTTPServer`.
+
+    :param request: the ``request`` fixture (or a :py:class:`pytest.FixtureRequest` object)
+    :param server: the server object to register
+    """
+    node = request.node
+    servers = node.stash.get(SERVERS_STASH_KEY, None)
+    if servers is None:
+        servers = []
+        node.stash[SERVERS_STASH_KEY] = servers
+    if server not in servers:
+        servers.append(server)
+
+
 def get_httpserver_listen_address() -> tuple[str | None, int | None]:
     listen_host = os.environ.get("PYTEST_HTTPSERVER_HOST")
     listen_port_str = os.environ.get("PYTEST_HTTPSERVER_PORT")
@@ -71,9 +103,10 @@ def pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:  # n
 
 
 @pytest.fixture
-def httpserver(make_httpserver: HTTPServer) -> HTTPServer:
+def httpserver(make_httpserver: HTTPServer, request: pytest.FixtureRequest) -> HTTPServer:
     server = make_httpserver
     server.clear()
+    register_server(request, server)
     return server
 
 
@@ -90,9 +123,10 @@ def make_httpserver_ipv4(
 
 
 @pytest.fixture
-def httpserver_ipv4(make_httpserver_ipv4: HTTPServer) -> HTTPServer:
+def httpserver_ipv4(make_httpserver_ipv4: HTTPServer, request: pytest.FixtureRequest) -> HTTPServer:
     server = make_httpserver_ipv4
     server.clear()
+    register_server(request, server)
     return server
 
 
@@ -109,7 +143,78 @@ def make_httpserver_ipv6(
 
 
 @pytest.fixture
-def httpserver_ipv6(make_httpserver_ipv6: HTTPServer) -> HTTPServer:
+def httpserver_ipv6(make_httpserver_ipv6: HTTPServer, request: pytest.FixtureRequest) -> HTTPServer:
     server = make_httpserver_ipv6
     server.clear()
+    register_server(request, server)
     return server
+
+
+def _format_server_findings(server: HTTPServerBase) -> list[str]:
+    """
+    Formats the pending (not yet raised) errors of the specified server.
+
+    :param server: the server object
+    :return: list of the report lines, empty list if there's nothing to report
+    """
+
+    lines: list[str] = []
+
+    assertions = list(server.assertions)
+    if assertions:
+        lines.append("Pending server-side assertions:")
+        lines.append("")
+        for index, assertion in enumerate(assertions, start=1):
+            lines.append("{}. {}".format(index, assertion))
+            lines.append("")
+
+    handler_errors = list(server.handler_errors)
+    if handler_errors:
+        lines.append("Errors raised by request handlers:")
+        lines.append("")
+        for index, error in enumerate(handler_errors, start=1):
+            lines.append("{}. {!r}".format(index, error))
+            lines.append("")
+
+    return lines
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_makereport(
+    item: pytest.Item,
+    call: pytest.CallInfo[None],  # noqa: ARG001
+) -> Generator[None, object, object]:
+    """
+    Adds the pending server-side errors to the report of the failed test.
+
+    When a test fails, there can be errors collected by the httpserver(s) used
+    by the test which were not raised during the test run. This typically
+    happens when the server receives a request which does not match any of the
+    registered handlers (so the server has no clue how to serve it), and the
+    test does not call :py:meth:`pytest_httpserver.HTTPServer.check` (or
+    similar methods) to raise them.
+
+    To make the debugging easier in these cases, the errors are attached to
+    the report of the failed test (as a report section), as they may explain
+    why the test failed.
+    """
+    report = yield
+    if isinstance(report, pytest.TestReport) and report.failed:
+        servers = item.stash.get(SERVERS_STASH_KEY, None)
+        if servers:
+            section_lines: list[str] = []
+            for server in servers:
+                server_lines = _format_server_findings(server)
+                if server_lines:
+                    section_lines.append("--- {}".format(server))
+                    section_lines.extend(server_lines)
+            if section_lines:
+                section_lines.insert(
+                    0, "Server-side errors collected by pytest-httpserver (not raised during the test):"
+                )
+                section_lines.append(
+                    "Note: these errors were not raised because the test did not call the check "
+                    "methods of the server (for example HTTPServer.check())."
+                )
+                report.sections.append((REPORT_SECTION_TITLE, "\n".join(section_lines)))
+    return report
@@ -0,0 +1,9 @@
+---
+features:
+  - |
+    The plugin now implements the ``pytest_runtest_makereport`` hook: when a
+    test fails, the server-side errors which were collected but not raised
+    during the test (such as the assertion added when the server received a
+    request which was not matching any of the registered handlers) are
+    attached to the test report as a new report section, making the debugging
+    of the failed test easier.
@@ -1,5 +1,7 @@
 import pytest
 
+pytest_plugins = ["pytester"]
+
 
 def pytest_addoption(parser):
     parser.addoption("--ssl", action="store_true", default=False, help="run ssl tests")