@@ -15,7 +15,7 @@
 """Python only: the v2 class of each class in the generated API.
 
 playwright/_impl/_api_classes.py takes these when PW_IMPL=v2 is set. The expect()
-matchers are not part of the client; they stay in playwright/_impl/_assertions.py.
+matchers are not part of the JS client; the Python ones are in assertions.py.
 """
 
 from playwright._impl_v2.assertions import (
 
@@ -151,7 +151,9 @@ def func(api_zone: ApiZone) -> Awaitable[Any]:
             )
 
         # Python: a channel call never raises at the call; the awaitable raises, as a
-        # rejected promise does.
+        # rejected promise does. A validation error is raised as it is, without the
+        # API name in front of it (upstream adds it): the message names the Python
+        # option, which is enough.
         try:
             result = owner._wrap_api_call(func, ApiCallOptions(internal=is_internal))
         except Exception as e:
@@ -334,6 +336,9 @@ def _wrap_api_call(
             internal=options.internal if options else False,
         )
         zone = current_zone().with_("apiZone", api_zone)
+        # Python: func runs now, up to its first await. An error that it raises here
+        # is raised as it is, without the API name and the logging below; upstream
+        # has it as a rejected promise, which the catch below decorates.
         awaitable = zone.run(lambda: func(api_zone))
 
         async def finish() -> R:
 
@@ -53,13 +53,13 @@ def remove_all_listeners(self) -> None:
         self._listeners.clear()
 
     def _on(self, name: str, *params: Any) -> None:
-        for listener in list(self._listeners):
+        for listener in self._listeners:
             method = getattr(listener, name, None)
             if method:
                 method(*params)
 
     async def _run(self, name: str, *params: Any) -> None:
-        for listener in list(self._listeners):
+        for listener in self._listeners:
             method = getattr(listener, name, None)
             if method:
                 await method(*params)
 
@@ -247,8 +247,12 @@ def remove_all_listeners(
             errors: List[BaseException] = []
             self._rejection_handler = lambda error: errors.append(error)
 
+            # Python: the pending handlers are taken now, as _waitFor() takes them
+            # before its first await.
+            pending = self._wait_for(type)
+
             async def wait() -> None:
-                await self._wait_for(type)
+                await pending
                 if errors:
                     raise errors[0]
 
 
@@ -149,7 +149,10 @@ def t_binary(arg: Any, path: str, context: ValidatorContext) -> Any:
             raise ValidationError(f"{path}: expected Buffer, got {_typeof(arg)}")
         return base64.b64encode(arg).decode()
     if context.binary == "buffer":
-        if not isinstance(arg, (bytes, bytearray)) and not isinstance(arg, object):
+        # Python: `arg instanceof Object` is false for a primitive.
+        if not isinstance(arg, (bytes, bytearray)) and isinstance(
+            arg, (str, int, float, type(None))
+        ):
             raise ValidationError(f"{path}: expected Buffer, got {_typeof(arg)}")
         return arg
     raise ValidationError(f'Unsupported binary behavior "{context.binary}"')
 
@@ -19,28 +19,44 @@
 """
 
 import os
+import re
 import sys
-from typing import Set
+from typing import List, Pattern
 
 LogName = str
 
 
 class DebugLogger:
     def __init__(self) -> None:
-        self._enabled: Set[str] = set()
-        for name in (os.environ.get("DEBUG") or "").split(","):
-            name = name.strip()
-            if name == "pw:*":
-                self._enabled.update({"api", "channel"})
-            elif name.startswith("pw:"):
-                self._enabled.add(name[3:])
+        # Python: the names of the `debug` npm package, which debugLogger.ts uses:
+        # DEBUG is a list of names, split on commas and spaces; `*` in a name
+        # matches anything; a name that starts with `-` turns its matches off.
+        self._names: List[Pattern[str]] = []
+        self._skips: List[Pattern[str]] = []
+        for name in re.split(r"[\s,]+", (os.environ.get("DEBUG") or "").strip()):
+            if not name:
+                continue
+            if name.startswith("-"):
+                self._skips.append(_template(name[1:]))
+            else:
+                self._names.append(_template(name))
 
     def log(self, name: LogName, message: object) -> None:
         if self.is_enabled(name):
             print(f"pw:{name} {message}", file=sys.stderr)
 
     def is_enabled(self, name: LogName) -> bool:
-        return name in self._enabled
+        full_name = "pw:" + name
+        if any(skip.match(full_name) for skip in self._skips):
+            return False
+        return any(enabled.match(full_name) for enabled in self._names)
+
+
+def _template(name: str) -> Pattern[str]:
+    # matchesTemplate() of the `debug` package: `*` matches any text.
+    return re.compile(
+        "^" + ".*".join(re.escape(part) for part in name.split("*")) + "$"
+    )
 
 
 debug_logger = DebugLogger()
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Runs the tests of playwright/_impl_v2 (PW_IMPL=v2) under xvfb, with one worker for
+# every two cores: all of tests/async (the older tests, the ports of the upstream
+# tests and the Python-only tests of v2). On a terminal, the progress is one status
+# line (scripts/pytest_line_reporter.py), and the summary lists only failures and
+# errors, without the warnings.
+# Usage: ./test-v2.sh [chromium|firefox|webkit] [extra pytest args]
+set -u
+cd "$(dirname "$0")"
+browser=chromium
+case "${1:-}" in chromium|firefox|webkit) browser=$1; shift ;; esac
+workers=$(( $(nproc) / 2 ))
+(( workers < 1 )) && workers=1
+python=python
+[ -x env/bin/python ] && python=env/bin/python
+export PYTHONPATH="scripts${PYTHONPATH:+:$PYTHONPATH}"
+PW_IMPL=v2 exec xvfb-run -a "$python" -m pytest tests/async --browser "$browser" -n "$workers" --timeout 120 --timeout-method thread -p pytest_line_reporter -rfE --disable-warnings "$@"
@@ -239,6 +239,8 @@ async def test_BT_034_should_connect_over_wss(
 
     # https://stackoverflow.com/a/21961005/552185
     monkeypatch.setenv("NODE_TLS_REJECT_UNAUTHORIZED", "0")
+    # suppressCertificateWarning()
+    monkeypatch.setenv("NODE_NO_WARNINGS", "1")
 
     https_server.once_web_socket_connection(
         lambda ws: forward_web_socket(ws, remote_server.ws_endpoint)
 
@@ -100,6 +100,14 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         kwargs["parsePOSTFormSubmission"] = False
         super().__init__(*args, **kwargs)
 
+    def finish(self) -> None:
+        # Like res.end() in Node.js, which does nothing after the client went away;
+        # Twisted raises "Request.finish called on a request after its connection
+        # was lost".
+        if self._disconnected or self.channel is None or not self.channel.transport:
+            return
+        super().finish()
+
     def _parse_form(self) -> None:
         """Adds the fields of a POSTed form to self.args, ignoring a malformed body."""
         if self.method != b"POST" or not self.post_body or self.args is None:
 
@@ -256,6 +256,8 @@ def test_BT_034_should_connect_over_wss(
 
     # https://stackoverflow.com/a/21961005/552185
     monkeypatch.setenv("NODE_TLS_REJECT_UNAUTHORIZED", "0")
+    # suppressCertificateWarning()
+    monkeypatch.setenv("NODE_NO_WARNINGS", "1")
 
     https_server.once_web_socket_connection(
         lambda ws: forward_web_socket(ws, remote_server.ws_endpoint)