Tests: Send Ladybird stderr to a file, not a pipe, in the a11y harnesses

Ladybird debug builds with ENABLE_ALL_THE_DEBUG_MACROS=ON (the All_Debug
preset that runs the AT-SPI2 tests on CI) emit huge stderr volumes —
PROMISE_DEBUG alone produces multiple lines per JS Promise step. The
harness was running with stderr=subprocess.PIPE and not draining it
until the timeout-failure path; once the kernel pipe buffer fills
(~64 KB on Linux), every dbgln in WebContent blocks on write, which can
wedge the engine before AT-SPI2 / NSAccessibility registration.

Send stderr to a tempfile instead. The kernel never backpressures a
regular file, the write path no longer wedges, and we still get the
bytes to include in the failure RuntimeError. Read the file before
stop() and unlink it on stop() so we don't leak debug logs in /tmp.

Author: sideshowbarker

Tests/LibWeb/AccessibilityBridge/harness/ladybird.py

@@ -5,6 +5,7 @@
 import os
 import pathlib
 import subprocess
+import tempfile
 import time
 
 from contextlib import contextmanager
@@ -60,6 +61,7 @@ def __init__(self, url: str, binary: Optional[pathlib.Path] = None):
             self._binary = DEFAULT_BINARY
         self._process: Optional[subprocess.Popen] = None
         self._app: Optional[Atspi.Accessible] = None
+        self._stderr_file: Optional[tempfile.NamedTemporaryFile] = None
 
     def __enter__(self) -> "LadybirdContext":
         self.start()
@@ -81,11 +83,17 @@ def start(self) -> None:
         # Silence Qt's a11y logging noise — so failures are readable.
         env.setdefault("QT_LOGGING_RULES", "qt.accessibility.atspi=false")
 
+        # Send stderr to a regular file rather than subprocess.PIPE: Ladybird debug builds (ENABLE_ALL_THE_DEBUG_MACROS)
+        # produce huge stderr volumes (PROMISE_DEBUG, etc.). A pipe's kernel buffer is ~64 KB; once it fills, every
+        # dbgln in WebContent blocks on write — which can wedge the engine before AT-SPI2 registration completes. A
+        # regular file never backpressures the writer, and we still get the bytes for diagnostics on failure.
+        self._stderr_file = tempfile.NamedTemporaryFile(prefix="ladybird-a11y-stderr-", suffix=".log", delete=False)
+
         self._process = subprocess.Popen(
             [str(self._binary), self._url],
             env=env,
             stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE,
+            stderr=self._stderr_file,
         )
 
         # Start a fresh Atspi connection for this context. Atspi.init() is idempotent — subsequent tests share the
@@ -115,24 +123,14 @@ def _app_appeared() -> bool:
 
         startup_timeout = float(os.environ.get("LADYBIRD_AT_SPI2_STARTUP_TIMEOUT", "60"))
         if not wait_for(_app_appeared, timeout=startup_timeout, description="Ladybird AT-SPI2 app to appear"):
-            # Capture stderr *before* stop() — because stop() nulls out self._process. Use communicate() with a hard
-            # timeout — so a wedged Ladybird that ignores SIGTERM can't hang the harness here; kill() + communicate()
-            # are guaranteed to return.
+            # Read the stderr file *before* stop() — stop() unlinks it.
             stderr = ""
-            if self._process is not None:
+            if self._stderr_file is not None:
                 try:
-                    self._process.terminate()
-                    _, stderr_bytes = self._process.communicate(timeout=5)
-                except subprocess.TimeoutExpired:
-                    self._process.kill()
-                    try:
-                        _, stderr_bytes = self._process.communicate(timeout=5)
-                    except Exception:
-                        stderr_bytes = b""
+                    with open(self._stderr_file.name, "rb") as f:
+                        stderr = f.read().decode(errors="replace")
                 except Exception:
-                    stderr_bytes = b""
-                if stderr_bytes:
-                    stderr = stderr_bytes.decode(errors="replace")
+                    pass
             self.stop()
             raise RuntimeError(
                 f"Ladybird did not register on AT-SPI2 within {startup_timeout:g}s.\n"
@@ -141,6 +139,7 @@ def _app_appeared() -> bool:
 
     def stop(self) -> None:
         if self._process is None:
+            self._cleanup_stderr_file()
             return
         try:
             self._process.terminate()
@@ -152,6 +151,20 @@ def stop(self) -> None:
         finally:
             self._process = None
             self._app = None
+            self._cleanup_stderr_file()
+
+    def _cleanup_stderr_file(self) -> None:
+        if self._stderr_file is None:
+            return
+        try:
+            self._stderr_file.close()
+        except Exception:
+            pass
+        try:
+            os.unlink(self._stderr_file.name)
+        except Exception:
+            pass
+        self._stderr_file = None
 
     def _find_app_on_desktop(self) -> Optional[Atspi.Accessible]:
         expected_pid = self._process.pid if self._process is not None else None

Tests/LibWeb/AccessibilityBridgeMac/harness/ladybird.py

@@ -5,6 +5,7 @@
 import os
 import pathlib
 import subprocess
+import tempfile
 import time
 
 from contextlib import contextmanager
@@ -77,6 +78,7 @@ def __init__(self, url: str, binary: Optional[pathlib.Path] = None):
         self._process: Optional[subprocess.Popen] = None
         self._app = None
         self._web = None
+        self._stderr_file: Optional[tempfile.NamedTemporaryFile] = None
 
     def __enter__(self) -> "LadybirdContext":
         self.start()
@@ -103,11 +105,17 @@ def start(self) -> None:
 
         env = os.environ.copy()
 
+        # Send stderr to a regular file rather than subprocess.PIPE: Ladybird debug builds (ENABLE_ALL_THE_DEBUG_MACROS)
+        # produce huge stderr volumes (PROMISE_DEBUG, etc.). A pipe's kernel buffer is ~64 KB; once it fills, every
+        # dbgln in WebContent blocks on write — which can wedge the engine before AX registration completes. A regular
+        # file never backpressures the writer, and we still get the bytes for diagnostics on failure.
+        self._stderr_file = tempfile.NamedTemporaryFile(prefix="ladybird-ax-stderr-", suffix=".log", delete=False)
+
         self._process = subprocess.Popen(
             [str(self._binary), self._url],
             env=env,
             stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE,
+            stderr=self._stderr_file,
         )
 
         self._app = AXUIElementCreateApplication(self._process.pid)
@@ -127,24 +135,14 @@ def _web_appeared() -> bool:
 
         startup_timeout = float(os.environ.get("LADYBIRD_AX_STARTUP_TIMEOUT", "60"))
         if not wait_for(_web_appeared, timeout=startup_timeout, description="Ladybird AXWebArea to populate"):
-            # Capture stderr *before* stop() — because stop() nulls out self._process. Use communicate() with a hard
-            # timeout — so a wedged Ladybird that ignores SIGTERM can't hang the harness here; kill() + communicate()
-            # are guaranteed to return.
+            # Read the stderr file *before* stop() — stop() unlinks it.
             stderr = ""
-            if self._process is not None:
+            if self._stderr_file is not None:
                 try:
-                    self._process.terminate()
-                    _, stderr_bytes = self._process.communicate(timeout=5)
-                except subprocess.TimeoutExpired:
-                    self._process.kill()
-                    try:
-                        _, stderr_bytes = self._process.communicate(timeout=5)
-                    except Exception:
-                        stderr_bytes = b""
+                    with open(self._stderr_file.name, "rb") as f:
+                        stderr = f.read().decode(errors="replace")
                 except Exception:
-                    stderr_bytes = b""
-                if stderr_bytes:
-                    stderr = stderr_bytes.decode(errors="replace")
+                    pass
             self.stop()
             raise RuntimeError(
                 f"Ladybird did not register an AXWebArea on NSAccessibility within {startup_timeout:g}s.\n"
@@ -153,6 +151,7 @@ def _web_appeared() -> bool:
 
     def stop(self) -> None:
         if self._process is None:
+            self._cleanup_stderr_file()
             return
         try:
             self._process.terminate()
@@ -162,16 +161,23 @@ def stop(self) -> None:
                 self._process.kill()
                 self._process.wait(timeout=5)
         finally:
-            # Close the stderr pipe explicitly. Otherwise Python's GC complains with ResourceWarning — which makes
-            # unittest output noisy.
-            if self._process and self._process.stderr is not None:
-                try:
-                    self._process.stderr.close()
-                except Exception:
-                    pass
             self._process = None
             self._app = None
             self._web = None
+            self._cleanup_stderr_file()
+
+    def _cleanup_stderr_file(self) -> None:
+        if self._stderr_file is None:
+            return
+        try:
+            self._stderr_file.close()
+        except Exception:
+            pass
+        try:
+            os.unlink(self._stderr_file.name)
+        except Exception:
+            pass
+        self._stderr_file = None
 
     def _find_web_area(self):
         """Walk from the application's focused/main window down to the first AXWebArea descendant."""