Merging upstream version 125.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

60 files changed, 2911 insertions, 587 deletions

diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/__init__.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/__init__.py
index dbacac8cf8..51b3c64b42 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/__init__.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/__init__.py
@@ -53,6 +53,13 @@ def assert_browsing_context(
     assert info["userContext"] == user_context
 
 
+async def assert_document_status(bidi_session, context, visible, focused):
+    state = "visible" if visible else "hidden"
+
+    assert await get_visibility_state(bidi_session, context) == state
+    assert await get_document_focus(bidi_session, context) is focused
+
+
 def assert_navigation_info(event, expected_navigation_info):
     recursive_compare(
         {
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/__init__.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/__init__.py
index 5d0b52a5ac..86f9ace3ee 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/__init__.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/__init__.py
@@ -3,7 +3,7 @@ from typing import Any, Mapping
 from webdriver.bidi.modules.script import ContextTarget
 
 
-async def is_selector_focused(bidi_session, context: Mapping[str, Any], selector: str) -> bool:
+async def is_element_focused(bidi_session, context: Mapping[str, Any], selector: str) -> bool:
     result = await bidi_session.script.call_function(
         function_declaration="""(selector) => {
         return document.querySelector(selector) === document.activeElement;
@@ -13,4 +13,5 @@ async def is_selector_focused(bidi_session, context: Mapping[str, Any], selector
         ],
         target=ContextTarget(context["context"]),
         await_promise=False)
+
     return result["value"]
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/activate.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/activate.py
index 0abbbbac38..f6e5b9d27a 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/activate.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/activate/activate.py
@@ -1,95 +1,62 @@
 import pytest
 
 from webdriver.bidi.modules.script import ContextTarget
-from . import is_selector_focused
-from .. import get_document_focus, get_visibility_state
+from . import is_element_focused
+from .. import assert_document_status
 
 pytestmark = pytest.mark.asyncio
 
 
-async def test_activate(bidi_session, new_tab, top_context):
-    assert await get_document_focus(bidi_session, top_context) is False
-
-    await bidi_session.browsing_context.activate(context=top_context["context"])
-
-    assert await get_visibility_state(bidi_session, top_context) == 'visible'
-    assert await get_document_focus(bidi_session, top_context) is True
+@pytest.mark.parametrize("type_hint", ["tab", "window"])
+async def test_switch_between_contexts(bidi_session, top_context, type_hint):
+    is_window = type_hint == "window"
 
+    new_context = await bidi_session.browsing_context.create(type_hint=type_hint)
 
-async def test_deactivates_other_contexts(bidi_session, new_tab, top_context):
     await bidi_session.browsing_context.activate(context=top_context["context"])
+    await assert_document_status(bidi_session, top_context, visible=True, focused=True)
+    await assert_document_status(bidi_session, new_context, visible=is_window, focused=False)
 
-    assert await get_visibility_state(bidi_session, top_context) == 'visible'
-    assert await get_document_focus(bidi_session, top_context) is True
+    await bidi_session.browsing_context.activate(context=new_context["context"])
+    await assert_document_status(bidi_session, top_context, visible=is_window, focused=False)
+    await assert_document_status(bidi_session, new_context, visible=True, focused=True)
 
-    assert await get_document_focus(bidi_session, new_tab) is False
-
-    await bidi_session.browsing_context.activate(context=new_tab["context"])
 
-    assert await get_document_focus(bidi_session, top_context) is False
-
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
-
-
-async def test_keeps_focused_area(bidi_session, inline, new_tab, top_context):
-    await bidi_session.browsing_context.activate(context=new_tab["context"])
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
-
-    await bidi_session.browsing_context.navigate(context=new_tab["context"],
-                                                 url=inline("<textarea autofocus></textarea><input>"),
-                                                 wait="complete")
+async def test_keeps_element_focused(bidi_session, inline, new_tab, top_context):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=inline("<textarea autofocus></textarea><input>"),
+        wait="complete")
 
     await bidi_session.script.evaluate(
         expression="""document.querySelector("input").focus()""",
         target=ContextTarget(new_tab["context"]),
         await_promise=False)
 
-    assert await is_selector_focused(bidi_session, new_tab, "input")
+    assert await is_element_focused(bidi_session, new_tab, "input")
 
     await bidi_session.browsing_context.activate(context=top_context["context"])
-    assert await get_document_focus(bidi_session, new_tab) is False
-    assert await is_selector_focused(bidi_session, new_tab, "input")
+    assert await is_element_focused(bidi_session, new_tab, "input")
 
     await bidi_session.browsing_context.activate(context=new_tab["context"])
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
-    assert await is_selector_focused(bidi_session, new_tab, "input")
+    assert await is_element_focused(bidi_session, new_tab, "input")
 
 
-async def test_double_activation(bidi_session, inline, new_tab):
-    await bidi_session.browsing_context.activate(context=new_tab["context"])
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
+async def test_multiple_activation(bidi_session, inline, new_tab):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=inline(
+            "<input><script>document.querySelector('input').focus();</script>"),
+        wait="complete")
 
-    await bidi_session.browsing_context.navigate(context=new_tab["context"],
-                                                 url=inline("<input><script>document.querySelector('input').focus();</script>"),
-                                                 wait="complete")
-    assert await is_selector_focused(bidi_session, new_tab, "input")
+    await assert_document_status(bidi_session, new_tab, visible=True, focused=True)
+    assert await is_element_focused(bidi_session, new_tab, "input")
 
     await bidi_session.browsing_context.activate(context=new_tab["context"])
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
-    assert await is_selector_focused(bidi_session, new_tab, "input")
+    await assert_document_status(bidi_session, new_tab, visible=True, focused=True)
+    assert await is_element_focused(bidi_session, new_tab, "input")
 
     # Activate again.
     await bidi_session.browsing_context.activate(context=new_tab["context"])
-    assert await get_visibility_state(bidi_session, new_tab) == 'visible'
-    assert await get_document_focus(bidi_session, new_tab) is True
-    assert await is_selector_focused(bidi_session, new_tab, "input")
-
-
-async def test_activate_window(bidi_session):
-    new_window_1 = await bidi_session.browsing_context.create(type_hint="window")
-    new_window_2 = await bidi_session.browsing_context.create(type_hint="window")
-
-    assert await get_visibility_state(bidi_session, new_window_2) == 'visible'
-    assert await get_document_focus(bidi_session, new_window_2) is True
-
-    assert await get_document_focus(bidi_session, new_window_1) is False
-
-    await bidi_session.browsing_context.activate(context=new_window_1["context"])
-
-    assert await get_visibility_state(bidi_session, new_window_1) == 'visible'
-    assert await get_document_focus(bidi_session, new_window_1) is True
+    await assert_document_status(bidi_session, new_tab, visible=True, focused=True)
+    assert await is_element_focused(bidi_session, new_tab, "input")
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/context_created/context_created.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/context_created/context_created.py
index 464d83a8aa..b865a891ed 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/context_created/context_created.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/context_created/context_created.py
@@ -92,6 +92,37 @@ async def test_evaluate_window_open_with_url(bidi_session, subscribe_events, wai
     )
 
 
+@pytest.mark.parametrize("type_hint", ["tab", "window"])
+async def test_event_emitted_before_create_returns(
+    bidi_session, subscribe_events, type_hint
+):
+    events = []
+
+    async def on_event(method, data):
+        events.append(data)
+
+    remove_listener = bidi_session.add_event_listener(CONTEXT_CREATED_EVENT, on_event)
+
+    await subscribe_events([CONTEXT_CREATED_EVENT])
+    context = await bidi_session.browsing_context.create(type_hint=type_hint)
+
+    # If the browsingContext.contextCreated event was emitted after the
+    # browsingContext.create command resolved, the array would most likely be
+    # empty at this point.
+    assert len(events) == 1
+
+    assert_browsing_context(
+        events[0],
+        context["context"],
+        children=None,
+        url="about:blank",
+        parent=None,
+        user_context="default",
+    )
+
+    remove_listener()
+
+
 async def test_navigate_creates_iframes(bidi_session, subscribe_events, top_context, test_page_multiple_frames):
     events = []
 
@@ -263,3 +294,22 @@ async def test_new_user_context(
     )
 
     remove_listener()
+
+
+@pytest.mark.parametrize("type_hint", ["tab", "window"])
+async def test_existing_context(bidi_session, wait_for_event, wait_for_future_safe, subscribe_events, type_hint):
+    # See https://w3c.github.io/webdriver-bidi/#ref-for-remote-end-subscribe-steps%E2%91%A1.
+    top_level_context = await bidi_session.browsing_context.create(type_hint=type_hint)
+
+    on_entry = wait_for_event(CONTEXT_CREATED_EVENT)
+    await subscribe_events([CONTEXT_CREATED_EVENT], contexts=[top_level_context["context"]])
+    context_info = await wait_for_future_safe(on_entry)
+
+    assert_browsing_context(
+        context_info,
+        top_level_context["context"],
+        children=None,
+        url="about:blank",
+        parent=None,
+        user_context="default"
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/create/type.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/create/type.py
index 55ce7b4428..cc6d7e51ab 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/create/type.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/create/type.py
@@ -1,19 +1,27 @@
 import pytest
 
-from .. import assert_browsing_context
 from webdriver.bidi.modules.script import ContextTarget
+from .. import assert_browsing_context, assert_document_status
+
 
 pytestmark = pytest.mark.asyncio
 
 
-@pytest.mark.parametrize("value", ["tab", "window"])
-async def test_type(bidi_session, value):
+@pytest.mark.parametrize("type_hint", ["tab", "window"])
+async def test_type(bidi_session, top_context, type_hint):
+    is_window = type_hint == "window"
+
     contexts = await bidi_session.browsing_context.get_tree(max_depth=0)
     assert len(contexts) == 1
 
-    new_context = await bidi_session.browsing_context.create(type_hint=value)
+    await assert_document_status(bidi_session, top_context, visible=True, focused=True)
+
+    new_context = await bidi_session.browsing_context.create(type_hint=type_hint)
     assert contexts[0]["context"] != new_context["context"]
 
+    await assert_document_status(bidi_session, new_context, visible=True, focused=True)
+    await assert_document_status(bidi_session, top_context, visible=is_window, focused=False)
+
     # Check there is an additional browsing context
     contexts = await bidi_session.browsing_context.get_tree(max_depth=0)
     assert len(contexts) == 2
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/fragment_navigated/fragment_navigated.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/fragment_navigated/fragment_navigated.py
index a4bd012588..fb690807f2 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/fragment_navigated/fragment_navigated.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/fragment_navigated/fragment_navigated.py
@@ -57,7 +57,7 @@ async def test_subscribe(bidi_session, subscribe_events, url, new_tab, wait_for_
     assert_navigation_info(event, {"context": new_tab["context"], "url": target_url})
 
 
-async def test_timestamp(bidi_session, current_time, subscribe_events, url, new_tab, wait_for_event):
+async def test_timestamp(bidi_session, current_time, subscribe_events, url, new_tab, wait_for_event, wait_for_future_safe):
     await bidi_session.browsing_context.navigate(
         context=new_tab["context"], url=url(EMPTY_PAGE), wait="complete"
     )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/invalid.py
index ff00de91ed..ecd3173e87 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/invalid.py
@@ -93,41 +93,6 @@ async def test_params_max_node_count_invalid_value(bidi_session, inline, top_con
         )
 
 
-@pytest.mark.parametrize("value", [False, 42, {}, []])
-async def test_params_ownership_invalid_type(bidi_session, inline, top_context, value):
-    await navigate_to_page(bidi_session, inline, top_context)
-
-    with pytest.raises(error.InvalidArgumentException):
-        await bidi_session.browsing_context.locate_nodes(
-            context=top_context["context"],
-            locator={ "type": "css", "value": "div" },
-            ownership=value
-        )
-
-
-async def test_params_ownership_invalid_value(bidi_session, inline, top_context):
-    await navigate_to_page(bidi_session, inline, top_context)
-
-    with pytest.raises(error.InvalidArgumentException):
-        await bidi_session.browsing_context.locate_nodes(
-            context=top_context["context"],
-            locator={ "type": "css", "value": "div" },
-            ownership="foo"
-        )
-
-
-@pytest.mark.parametrize("value", [False, 42, {}, []])
-async def test_params_sandbox_invalid_type(bidi_session, inline, top_context, value):
-    await navigate_to_page(bidi_session, inline, top_context)
-
-    with pytest.raises(error.InvalidArgumentException):
-        await bidi_session.browsing_context.locate_nodes(
-            context=top_context["context"],
-            locator={ "type": "css", "value": "div" },
-            sandbox=value
-        )
-
-
 @pytest.mark.parametrize("value", [False, 42, "foo", []])
 async def test_params_serialization_options_invalid_type(bidi_session, inline, top_context, value):
     await navigate_to_page(bidi_session, inline, top_context)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/ownership.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/ownership.py
deleted file mode 100644
index b1830c740a..0000000000
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/ownership.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import pytest
-
-from ... import assert_handle
-
-
-@pytest.mark.parametrize("ownership,has_handle", [
-    ("root", True),
-    ("none", False)
-])
-@pytest.mark.asyncio
-async def test_root_ownership_of_located_nodes(bidi_session, inline, top_context, ownership, has_handle):
-    url = inline("""<div data-class="one">foobarBARbaz</div><div data-class="two">foobarBARbaz</div>""")
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-
-    result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        ownership=ownership
-    )
-
-    assert len(result["nodes"]) == 1
-    result_node = result["nodes"][0]
-
-    assert_handle(result_node, has_handle)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/sandbox.py b/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/sandbox.py
deleted file mode 100644
index efa431bf19..0000000000
--- a/testing/web-platform/tests/webdriver/tests/bidi/browsing_context/locate_nodes/sandbox.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import pytest
-
-from webdriver.bidi.modules.script import ContextTarget,OwnershipModel
-
-
-@pytest.mark.asyncio
-async def test_locate_nodes_in_sandbox(bidi_session, inline, top_context):
-    url = inline("""<div data-class="one">foobarBARbaz</div><div data-class="two">foobarBARbaz</div>""")
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-
-    result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        sandbox="sandbox"
-    )
-
-    assert len(result["nodes"]) == 1
-    node_id = result["nodes"][0]["sharedId"]
-
-    # Since the node was found in the sandbox, it should be available
-    # to scripts running in the sandbox.
-    result_in_sandbox = await bidi_session.script.call_function(
-        function_declaration="function(){ return arguments[0]; }",
-        target=ContextTarget(top_context["context"], "sandbox"),
-        await_promise=True,
-        arguments=[
-            {
-                "sharedId": node_id
-            }
-        ]
-    )
-    assert result_in_sandbox["type"] == "node"
-    assert result_in_sandbox["sharedId"] == node_id
-
-
-@pytest.mark.asyncio
-async def test_locate_same_node_in_different_sandboxes_returns_same_id(bidi_session, inline, top_context):
-    url = inline("""<div data-class="one">foobarBARbaz</div><div data-class="two">foobarBARbaz</div>""")
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-
-    first_result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        sandbox="first_sandbox"
-    )
-
-    assert len(first_result["nodes"]) == 1
-
-    second_result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        sandbox="second_sandbox"
-    )
-    assert len(second_result["nodes"]) == 1
-    assert first_result["nodes"][0]["sharedId"] == second_result["nodes"][0]["sharedId"]
-
-
-@pytest.mark.asyncio
-async def test_locate_same_node_in_default_sandbox_returns_same_id_as_sandbox(bidi_session, inline, top_context):
-    url = inline("""<div data-class="one">foobarBARbaz</div><div data-class="two">foobarBARbaz</div>""")
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-
-    result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" }
-    )
-
-    assert len(result["nodes"]) == 1
-    node_id = result["nodes"][0]["sharedId"]
-
-    result_in_sandbox = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        sandbox="sandbox"
-    )
-    assert len(result_in_sandbox["nodes"]) == 1
-    assert result_in_sandbox["nodes"][0]["sharedId"] == node_id
-
-
-@pytest.mark.asyncio
-async def test_locate_same_node_in_different_sandboxes_with_root_ownership_returns_different_handles(bidi_session, inline, top_context):
-    url = inline("""<div data-class="one">foobarBARbaz</div><div data-class="two">foobarBARbaz</div>""")
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-
-    first_result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        ownership=OwnershipModel.ROOT.value,
-        sandbox="first_sandbox"
-    )
-
-    assert len(first_result["nodes"]) == 1
-
-    second_result = await bidi_session.browsing_context.locate_nodes(
-        context=top_context["context"],
-        locator={ "type": "css", "value": "div[data-class='one']" },
-        ownership=OwnershipModel.ROOT.value,
-        sandbox="second_sandbox"
-    )
-
-    assert len(second_result["nodes"]) == 1
-    assert first_result["nodes"][0]["sharedId"] == second_result["nodes"][0]["sharedId"]
-    assert first_result["nodes"][0]["handle"] != second_result["nodes"][0]["handle"]
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/invalid.py
index 0ef8c57f41..0ace04e8bc 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/invalid.py
@@ -34,7 +34,7 @@ async def test_params_state_invalid_type(bidi_session, state):
       )
 
 
-@pytest.mark.parametrize("state", ["UNKOWN", "Granted"])
+@pytest.mark.parametrize("state", ["UNKNOWN", "Granted"])
 async def test_params_state_invalid_value(bidi_session, state):
     with pytest.raises(error.InvalidArgumentException):
       await bidi_session.permissions.set_permission(
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/set_permission.py b/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/set_permission.py
index dc6ca14a8d..92ebed1e63 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/set_permission.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/external/permissions/set_permission/set_permission.py
@@ -96,7 +96,22 @@ async def test_set_permission_new_context(bidi_session, new_tab, url):
 
 
 @pytest.mark.parametrize("origin", ['UNKNOWN', ''])
-async def test_set_permission_origin_unknown(bidi_session, new_tab, origin):
+async def test_set_permission_origin_unknown(bidi_session, new_tab, origin, url):
+    test_url = url("/common/blank.html", protocol="https")
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=test_url,
+        wait="complete",
+    )
+
+    # Ensure permission for the tab is prompt.
+    tab_origin = await get_context_origin(bidi_session, new_tab)
+    await bidi_session.permissions.set_permission(
+        descriptor={"name": "geolocation"},
+        state="prompt",
+        origin=tab_origin,
+    )
+
     await bidi_session.permissions.set_permission(
         descriptor={"name": "geolocation"},
         state="granted",
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/perform_actions/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/input/perform_actions/invalid.py
index 4ae3039f47..1c5983159c 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/input/perform_actions/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/perform_actions/invalid.py
@@ -531,7 +531,7 @@ async def test_params_pointer_action_up_down_button_invalid_value(
 
 
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("dimension", ["width", "height"])
 @pytest.mark.parametrize("value", [None, "foo", True, 0.1, [], {}])
 async def test_params_pointer_action_common_properties_dimensions_invalid_type(
@@ -554,7 +554,7 @@ async def test_params_pointer_action_common_properties_dimensions_invalid_type(
 
 @pytest.mark.parametrize("dimension", ["width", "height"])
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("value", [-1, MAX_INT + 1])
 async def test_params_pointer_action_common_properties_dimensions_invalid_value(
         perform_actions, dimension, pointer_action, value):
@@ -575,7 +575,7 @@ async def test_params_pointer_action_common_properties_dimensions_invalid_value(
 
 
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("pressure", ["pressure", "tangentialPressure"])
 @pytest.mark.parametrize("value", [None, "foo", True, [], {}])
 async def test_params_pointer_action_common_properties_pressure_invalid_type(
@@ -599,7 +599,7 @@ async def test_params_pointer_action_common_properties_pressure_invalid_type(
 
 
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("value", [None, "foo", True, 0.1, [], {}])
 async def test_params_pointer_action_common_properties_twist_invalid_type(
         perform_actions, pointer_action, value):
@@ -614,7 +614,7 @@ async def test_params_pointer_action_common_properties_twist_invalid_type(
 
 
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("value", [-1, 360])
 async def test_params_pointer_action_common_properties_twist_invalid_value(
         perform_actions, pointer_action, value):
@@ -629,7 +629,7 @@ async def test_params_pointer_action_common_properties_twist_invalid_value(
 
 
 @pytest.mark.parametrize("pointer_action",
-                         ["pointerDown", "pointerMove", "pointerUp"])
+                         ["pointerDown", "pointerMove"])
 @pytest.mark.parametrize("angle", ["altitudeAngle", "azimuthAngle"])
 @pytest.mark.parametrize("value", [None, "foo", True, [], {}])
 async def test_params_pointer_action_common_properties_angle_invalid_type(
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/__init__.py b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/__init__.py
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/conftest.py b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/conftest.py
new file mode 100644
index 0000000000..f114ca701e
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/conftest.py
@@ -0,0 +1,33 @@
+import os
+import pytest
+
+
+@pytest.fixture
+def create_files(tmpdir_factory):
+    def create_files(paths):
+        """Create files in a temporary folder.
+
+        Note: the fixture doesn't work with absolute paths, since all the files
+        should be created inside the temporary folder.
+
+        :param paths: list of file names which should be used for creating files
+        :return: list of final paths for created files
+        """
+
+        filelist = []
+        tmpdir = tmpdir_factory.mktemp("wdspec-")
+
+        for path in paths:
+            # Make path separators system compatible.
+            path = os.path.join(*path.split("/"))
+            dir_path = os.path.join(tmpdir, os.path.dirname(path))
+            if not os.path.exists(dir_path):
+                os.makedirs(dir_path)
+
+            full_path = os.path.join(tmpdir, path)
+            open(full_path, 'w').close()
+            filelist.append(full_path)
+
+        return filelist
+
+    return create_files
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/context.py b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/context.py
new file mode 100644
index 0000000000..f9a39f2bfb
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/context.py
@@ -0,0 +1,80 @@
+import pytest
+
+from .. import get_events
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_set_files_сontext(
+    bidi_session, top_context, new_tab, load_static_test_page, get_element, create_files
+):
+    await load_static_test_page(page="files.html")
+    await load_static_test_page(page="files.html", context=new_tab)
+
+    element = await get_element("#input", context=new_tab)
+
+    await bidi_session.input.set_files(
+        context=new_tab["context"],
+        element=element,
+        files=create_files(["noop.txt"]),
+    )
+
+    events_in_new_tab = await get_events(bidi_session, new_tab["context"])
+    assert events_in_new_tab == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+    ]
+
+    # Make sure that events are not sent in the other context.
+    events_in_top_context = await get_events(bidi_session, top_context["context"])
+    assert events_in_top_context == []
+
+
+@pytest.mark.parametrize("domain", ["", "alt"], ids=["same_origin", "cross_origin"])
+async def test_set_files_in_iframe(
+    bidi_session, new_tab, get_element, inline, url, create_files, domain
+):
+    iframe_url = url("/webdriver/tests/support/html/files.html")
+    page_url = inline(f"<iframe src='{iframe_url}'></iframe>", domain=domain)
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=page_url,
+        wait="complete",
+    )
+
+    contexts = await bidi_session.browsing_context.get_tree(root=new_tab["context"])
+    iframe_context = contexts[0]["children"][0]
+
+    element = await get_element("#input", context=iframe_context)
+
+    await bidi_session.input.set_files(
+        context=iframe_context["context"],
+        element=element,
+        files=create_files(["noop.txt"]),
+    )
+
+    events_in_new_tab = await get_events(bidi_session, iframe_context["context"])
+    assert events_in_new_tab == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+    ]
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/files.py b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/files.py
new file mode 100644
index 0000000000..7a31f3e14a
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/files.py
@@ -0,0 +1,352 @@
+import pytest
+
+from .. import get_events
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_set_files(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+    ]
+
+
+async def test_set_files_empty(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=[],
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [],
+            "type": "cancel",
+        },
+    ]
+
+
+async def test_set_files_multiple(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input-multiple")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt", "path/to/noop-2.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+                "noop-2.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+                "noop-2.txt",
+            ],
+            "type": "change",
+        },
+    ]
+
+
+async def test_set_files_something_then_empty(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=[],
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+        {
+            "files": [],
+            "type": "input",
+        },
+        {
+            "files": [],
+            "type": "change",
+        },
+    ]
+
+
+async def test_set_files_twice(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop-2.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+        {
+            "files": [
+                "noop-2.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop-2.txt",
+            ],
+            "type": "change",
+        },
+    ]
+
+
+async def test_set_files_twice_intersected(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input-multiple")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["noop.txt"]),
+    )
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["noop.txt", "noop-2.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+        {
+            "files": [
+                "noop.txt",
+                "noop-2.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+                "noop-2.txt",
+            ],
+            "type": "change",
+        },
+    ]
+
+
+async def test_set_files_twice_same(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "cancel",
+        },
+    ]
+
+
+async def test_set_files_twice_same_in_different_folders(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["path/to/noop.txt"]),
+    )
+
+    await bidi_session.input.set_files(
+        context=top_context["context"],
+        element=element,
+        files=create_files(["different/to/noop.txt"]),
+    )
+
+    events = await get_events(bidi_session, top_context["context"])
+    assert events == [
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "input",
+        },
+        {
+            "files": [
+                "noop.txt",
+            ],
+            "type": "change",
+        },
+    ]
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/invalid.py
new file mode 100644
index 0000000000..6527f462c9
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/input/set_files/invalid.py
@@ -0,0 +1,232 @@
+import pytest
+
+from webdriver.bidi.error import (
+    InvalidArgumentException,
+    NoSuchElementException,
+    NoSuchFrameException,
+    NoSuchNodeException,
+    UnableToSetFileInputException,
+)
+from webdriver.bidi.modules.script import ContextTarget
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize("value", [None, True, 42, {}, []])
+async def test_params_context_invalid_type(
+    bidi_session, load_static_test_page, get_element, value
+):
+    await load_static_test_page(page="files.html")
+    element = await get_element("#input")
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.input.set_files(
+            context=value,
+            element=element,
+            files=[],
+        )
+
+
+async def test_params_context_invalid_value(
+    bidi_session, load_static_test_page, get_element
+):
+    await load_static_test_page(page="files.html")
+    element = await get_element("#input")
+    with pytest.raises(NoSuchFrameException):
+        await bidi_session.input.set_files(
+            context="foo",
+            element=element,
+            files=[],
+        )
+
+
+@pytest.mark.parametrize("value", [None, True, 42, []])
+async def test_params_element_invalid_type(bidi_session, top_context, value):
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=value,
+            files=[],
+        )
+
+
+@pytest.mark.parametrize("value", [None, True, 42, {}])
+async def test_params_files_invalid_type(
+    top_context, bidi_session, load_static_test_page, get_element, value
+):
+    await load_static_test_page(page="files.html")
+    element = await get_element("#input")
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=value,
+        )
+
+
+@pytest.mark.parametrize("value", [None, True, 42, {}, []])
+async def test_params_files_file_invalid_type(
+    top_context, bidi_session, load_static_test_page, get_element, value
+):
+    await load_static_test_page(page="files.html")
+    element = await get_element("#input")
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=[value],
+        )
+
+
+async def test_params_element_invalid_shared_reference_value(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    create_files,
+):
+    await load_static_test_page(page="files.html")
+
+    with pytest.raises(NoSuchNodeException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element={"sharedId": "invalid"},
+            files=create_files(["path/to/noop.txt"]),
+        )
+
+
+@pytest.mark.parametrize(
+    "expression",
+    [
+        "document.querySelector('input#button').attributes[0]",
+        "document.querySelector('#with-text-node').childNodes[0]",
+        """document.createProcessingInstruction("xml-stylesheet", "href='foo.css'")""",
+        "document.querySelector('#with-comment').childNodes[0]",
+        "document",
+        "document.doctype",
+        "document.createDocumentFragment()",
+        "document.querySelector('#custom-element').shadowRoot",
+    ],
+    ids=[
+        "attribute",
+        "text node",
+        "processing instruction",
+        "comment",
+        "document",
+        "doctype",
+        "document fragment",
+        "shadow root",
+    ]
+)
+async def test_params_element_invalid_element(
+    bidi_session,
+    top_context,
+    get_test_page,
+    create_files,
+    expression
+):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=get_test_page(),
+        wait="complete",
+    )
+
+    node = await bidi_session.script.evaluate(
+        expression=expression,
+        target=ContextTarget(top_context["context"]),
+        await_promise=False,
+    )
+
+    with pytest.raises(NoSuchElementException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=node,
+            files=create_files(["path/to/noop.txt"]),
+        )
+
+
+async def test_params_element_disabled(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input-disabled")
+
+    with pytest.raises(UnableToSetFileInputException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=create_files(["path/to/noop.txt"]),
+        )
+
+
+@pytest.mark.parametrize(
+    "html",
+    [
+        "<div id='test'>foo</div>",
+        "<a id='test' href='#'>foo</a>",
+        "<span id='test' href='#'>foo</span>",
+    ],
+)
+async def test_params_element_non_input(
+    bidi_session,
+    top_context,
+    inline,
+    get_element,
+    create_files,
+    html,
+):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline(html),
+        wait="complete",
+    )
+
+    element = await get_element("#test")
+
+    with pytest.raises(UnableToSetFileInputException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=create_files(["path/to/noop.txt"]),
+        )
+
+
+async def test_params_element_non_file_input(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files,
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#text-input")
+
+    with pytest.raises(UnableToSetFileInputException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=create_files(["path/to/noop.txt"]),
+        )
+
+
+async def test_params_element_not_multiple(
+    bidi_session,
+    top_context,
+    load_static_test_page,
+    get_element,
+    create_files
+):
+    await load_static_test_page(page="files.html")
+
+    element = await get_element("#input")
+
+    with pytest.raises(UnableToSetFileInputException):
+        await bidi_session.input.set_files(
+            context=top_context["context"],
+            element=element,
+            files=create_files(["path/to/noop.txt", "path/to/noop-2.txt"]),
+        )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/integration/navigation.py b/testing/web-platform/tests/webdriver/tests/bidi/integration/navigation.py
new file mode 100644
index 0000000000..23615040c7
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/integration/navigation.py
@@ -0,0 +1,67 @@
+import pytest
+
+from webdriver.error import TimeoutException
+from webdriver.bidi.error import UnknownErrorException
+from webdriver.bidi.modules.script import ContextTarget
+
+
+pytestmark = pytest.mark.asyncio
+
+NAVIGATION_STARTED_EVENT = "browsingContext.navigationStarted"
+FRAGMENT_NAVIGATED_EVENT = "browsingContext.fragmentNavigated"
+BEFORE_REQUEST_SENT_EVENT = "network.beforeRequestSent"
+
+async def test_navigate_history_replacestate_beforeunload(
+    bidi_session, inline, new_tab, subscribe_events
+):
+    url = inline("""
+        <script>
+          window.addEventListener(
+            'beforeunload',
+            () => {
+              return history.replaceState(null, 'initial', window.location.href);
+            },
+            false
+          );
+        </script>""")
+
+    result = await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=url, wait="complete"
+    )
+
+    events = []
+
+    async def on_event(method, data):
+        events.append(method)
+
+    remove_navigation_started_listener = bidi_session.add_event_listener(
+        NAVIGATION_STARTED_EVENT, on_event
+    )
+
+    remove_fragment_navigated_listener = bidi_session.add_event_listener(
+        FRAGMENT_NAVIGATED_EVENT, on_event
+    )
+
+    remove_before_request_sent_listener = bidi_session.add_event_listener(
+        BEFORE_REQUEST_SENT_EVENT, on_event
+    )
+
+    await subscribe_events([NAVIGATION_STARTED_EVENT, FRAGMENT_NAVIGATED_EVENT, BEFORE_REQUEST_SENT_EVENT])
+
+    result = await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=url, wait="interactive"
+    )
+
+    # Navigation caused by browsing_context.navigate call should happen first:
+    # https://html.spec.whatwg.org/#beginning-navigation
+    # network.beforeRequestSent should arrive before the page becomes
+    # interactive.
+    assert events == [
+        NAVIGATION_STARTED_EVENT,
+        FRAGMENT_NAVIGATED_EVENT,
+        BEFORE_REQUEST_SENT_EVENT
+    ]
+
+    remove_navigation_started_listener()
+    remove_fragment_navigated_listener()
+    remove_before_request_sent_listener()
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/add_intercept.py b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/add_intercept.py
index 7648eb1934..c073e1cc32 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/add_intercept.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/add_intercept.py
@@ -17,49 +17,6 @@ from .. import (
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("phase", ["beforeRequestSent", "responseStarted"])
-async def test_other_context(
-    bidi_session,
-    url,
-    top_context,
-    add_intercept,
-    fetch,
-    setup_network_test,
-    phase,
-):
-    # Subscribe to network events only in top_context
-    await setup_network_test(
-        events=[
-            BEFORE_REQUEST_SENT_EVENT,
-            RESPONSE_STARTED_EVENT,
-            RESPONSE_COMPLETED_EVENT,
-        ],
-        contexts=[top_context["context"]],
-    )
-
-    # Create another tab, where network events are not monitored.
-    other_context = await bidi_session.browsing_context.create(type_hint="tab")
-    await bidi_session.browsing_context.navigate(
-        context=other_context["context"], url=url(PAGE_EMPTY_HTML), wait="complete"
-    )
-
-    # Add an intercept.
-    text_url = url(PAGE_EMPTY_TEXT)
-    await add_intercept(
-        phases=[phase],
-        url_patterns=[{"type": "string", "pattern": text_url}],
-    )
-
-    # Request to top_context should be blocked and throw a ScriptEvaluateResultException
-    # from the AbortController.
-    with pytest.raises(ScriptEvaluateResultException):
-        await fetch(text_url, context=top_context)
-
-    # Request to other_context should not be blocked.
-    await fetch(text_url, context=other_context)
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("phase", ["beforeRequestSent", "responseStarted"])
 async def test_other_url(
     url,
     add_intercept,
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/contexts.py b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/contexts.py
new file mode 100644
index 0000000000..83dfa5560f
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/contexts.py
@@ -0,0 +1,210 @@
+import asyncio
+
+import pytest
+from webdriver.bidi.modules.script import ScriptEvaluateResultException
+
+from .. import (
+    assert_before_request_sent_event,
+    PAGE_EMPTY_HTML,
+    PAGE_EMPTY_TEXT,
+    BEFORE_REQUEST_SENT_EVENT,
+    RESPONSE_COMPLETED_EVENT,
+    RESPONSE_STARTED_EVENT,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("phase", ["beforeRequestSent", "responseStarted"])
+async def test_other_context(
+    bidi_session,
+    url,
+    top_context,
+    add_intercept,
+    fetch,
+    setup_network_test,
+    phase,
+):
+    # Subscribe to network events only in top_context
+    await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+            RESPONSE_STARTED_EVENT,
+            RESPONSE_COMPLETED_EVENT,
+        ],
+        contexts=[top_context["context"]],
+    )
+
+    # Create another tab, where network events are not monitored.
+    other_context = await bidi_session.browsing_context.create(type_hint="tab")
+    await bidi_session.browsing_context.navigate(
+        context=other_context["context"], url=url(PAGE_EMPTY_HTML), wait="complete"
+    )
+
+    # Add an intercept.
+    text_url = url(PAGE_EMPTY_TEXT)
+    await add_intercept(
+        phases=[phase],
+        url_patterns=[{"type": "string", "pattern": text_url}],
+    )
+
+    # Request to top_context should be blocked and throw a ScriptEvaluateResultException
+    # from the AbortController.
+    with pytest.raises(ScriptEvaluateResultException):
+        await fetch(text_url, context=top_context)
+
+    # Request to other_context should not be blocked.
+    await fetch(text_url, context=other_context)
+
+
+@pytest.mark.asyncio
+async def test_other_context_with_event_subscription(
+    bidi_session,
+    url,
+    top_context,
+    add_intercept,
+    fetch,
+    setup_network_test,
+    wait_for_event,
+    wait_for_future_safe
+):
+    # Create another tab that will listen to network events without interception.
+    other_context = await bidi_session.browsing_context.create(type_hint="tab")
+    await bidi_session.browsing_context.navigate(
+        context=other_context["context"], url=url(PAGE_EMPTY_HTML), wait="complete"
+    )
+
+    # Subscribe to network events in both contexts.
+    await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+            RESPONSE_STARTED_EVENT,
+            RESPONSE_COMPLETED_EVENT,
+        ],
+        contexts=[top_context["context"], other_context["context"]],
+    )
+
+    # Add an intercept to top_context only.
+    text_url = url(PAGE_EMPTY_TEXT)
+    await add_intercept(
+        phases=["beforeRequestSent"],
+        url_patterns=[{"type": "string", "pattern": text_url}],
+        contexts=[top_context["context"]]
+    )
+
+    # Request to the top_context should be blocked.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=top_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=True
+    )
+
+    # Request to other_context should not be blocked.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=other_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=False
+    )
+
+
+@pytest.mark.asyncio
+async def test_two_contexts_same_intercept(
+    bidi_session,
+    url,
+    top_context,
+    add_intercept,
+    fetch,
+    setup_network_test,
+    wait_for_event,
+    wait_for_future_safe
+):
+    other_context = await bidi_session.browsing_context.create(type_hint="tab")
+    await bidi_session.browsing_context.navigate(
+        context=other_context["context"], url=url(PAGE_EMPTY_HTML), wait="complete"
+    )
+
+    # Subscribe to network events in both contexts.
+    await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+        ],
+        contexts=[top_context["context"], other_context["context"]],
+    )
+
+    # Add an intercept to both contexts
+    text_url = url(PAGE_EMPTY_TEXT)
+    intercept = await add_intercept(
+        phases=["beforeRequestSent"],
+        url_patterns=[{"type": "string", "pattern": text_url}],
+        contexts=[top_context["context"], other_context["context"]],
+    )
+
+    # Request on the top_context should be blocked.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=top_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=True, intercepts=[intercept]
+    )
+
+    # Request on the other_context should be blocked.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=other_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=True, intercepts=[intercept]
+    )
+
+
+@pytest.mark.asyncio
+async def test_two_contexts_global_intercept(
+    bidi_session,
+    url,
+    top_context,
+    add_intercept,
+    fetch,
+    setup_network_test,
+    wait_for_event,
+    wait_for_future_safe
+):
+    other_context = await bidi_session.browsing_context.create(type_hint="tab")
+    await bidi_session.browsing_context.navigate(
+        context=other_context["context"], url=url(PAGE_EMPTY_HTML), wait="complete"
+    )
+
+    # Subscribe to network events in both contexts.
+    await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+        ],
+        contexts=[top_context["context"], other_context["context"]],
+    )
+
+    # Add an intercept for top_context and a global intercept.
+    text_url = url(PAGE_EMPTY_TEXT)
+    context_intercept = await add_intercept(
+        phases=["beforeRequestSent"],
+        url_patterns=[{"type": "string", "pattern": text_url}],
+        contexts=[top_context["context"]],
+    )
+    global_intercept = await add_intercept(
+        phases=["beforeRequestSent"],
+        url_patterns=[{"type": "string", "pattern": text_url}],
+    )
+
+    # Request on the top_context should be blocked and list both intercepts.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=top_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=True, intercepts=[context_intercept, global_intercept]
+    )
+
+    # Request on the other_context should be blocked by the global intercept.
+    on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    asyncio.ensure_future(fetch(text_url, context=other_context))
+    event = await wait_for_future_safe(on_network_event)
+    assert_before_request_sent_event(
+        event, is_blocked=True, intercepts=[global_intercept]
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/invalid.py
index ac7b273854..0821ba7782 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/invalid.py
@@ -147,7 +147,8 @@ async def test_params_url_patterns_pattern_protocol_file_invalid_value(bidi_sess
     with pytest.raises(error.InvalidArgumentException):
         await bidi_session.network.add_intercept(
             phases=["beforeRequestSent"],
-            url_patterns=[{"type": "pattern", "protocol": value, "hostname": "example.com"}],
+            url_patterns=[
+                {"type": "pattern", "protocol": value, "hostname": "example.com"}],
         )
 
 
@@ -185,3 +186,36 @@ async def test_params_url_patterns_pattern_search_invalid_value(bidi_session, va
             phases=["beforeRequestSent"],
             url_patterns=[{"type": "pattern", "search": value}],
         )
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, ""])
+async def test_params_contexts_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.network.add_intercept(phases=["beforeRequestSent"], contexts=value)
+
+
+async def test_params_contexts_empty_list(bidi_session):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.network.add_intercept(phases=["beforeRequestSent"], contexts=[])
+
+
+async def test_params_contexts_context_invalid_value(bidi_session):
+    with pytest.raises(error.NoSuchFrameException):
+        await bidi_session.network.add_intercept(phases=["beforeRequestSent"], contexts=["does not exist"])
+
+
+async def test_params_contexts_context_non_top_level(bidi_session, new_tab, test_page_same_origin_frame):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=test_page_same_origin_frame,
+        wait="complete",
+    )
+
+    contexts = await bidi_session.browsing_context.get_tree(root=new_tab["context"])
+
+    assert len(contexts) == 1
+    assert len(contexts[0]["children"]) == 1
+    child_info = contexts[0]["children"][0]
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.network.add_intercept(phases=["beforeRequestSent"], contexts=[child_info['context']])
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/phase_auth_required.py b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/phase_auth_required.py
index dd322a2340..0df3e9e86a 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/phase_auth_required.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/phase_auth_required.py
@@ -1,9 +1,6 @@
 import pytest
 
-from .. import (
-    assert_before_request_sent_event,
-    assert_response_event,
-)
+import asyncio
 
 from .. import (
     assert_before_request_sent_event,
@@ -26,7 +23,14 @@ async def test_basic_authentication(
     url,
     setup_network_test,
     add_intercept,
+    fetch,
 ):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=url(PAGE_EMPTY_TEXT),
+        wait="complete",
+    )
+
     network_events = await setup_network_test(
         events=[
             BEFORE_REQUEST_SENT_EVENT,
@@ -49,11 +53,8 @@ async def test_basic_authentication(
     assert isinstance(intercept, str)
 
     on_auth_required = wait_for_event(AUTH_REQUIRED_EVENT)
-    await bidi_session.browsing_context.navigate(
-        context=new_tab["context"],
-        url=auth_url,
-        wait="none",
-    )
+    # The fetch should fails as there is no authentication
+    asyncio.ensure_future(fetch(url=auth_url, context=new_tab))
 
     await wait_for_future_safe(on_auth_required)
     expected_request = {"method": "GET", "url": auth_url}
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/url_patterns.py b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/url_patterns.py
index 517a94ffc4..cee5f5d822 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/url_patterns.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/add_intercept/url_patterns.py
@@ -59,7 +59,7 @@ def substitute_host(server_config):
 async def test_pattern_patterns_matching(
     wait_for_event,
     subscribe_events,
-    top_context,
+    new_tab,
     add_intercept,
     fetch,
     substitute_host,
@@ -67,7 +67,7 @@ async def test_pattern_patterns_matching(
     patterns,
     url_template,
 ):
-    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[top_context["context"]])
+    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[new_tab["context"]])
 
     for pattern in patterns:
         for key in pattern:
@@ -78,7 +78,7 @@ async def test_pattern_patterns_matching(
     intercept = await add_intercept(phases=["beforeRequestSent"], url_patterns=patterns)
 
     on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
-    asyncio.ensure_future(fetch(substitute_host(url_template)))
+    asyncio.ensure_future(fetch(substitute_host(url_template), context=new_tab))
     event = await wait_for_future_safe(on_network_event)
 
     assert_before_request_sent_event(event, is_blocked=True, intercepts=[intercept])
@@ -106,7 +106,7 @@ async def test_pattern_patterns_matching(
 async def test_pattern_patterns_not_matching(
     wait_for_event,
     subscribe_events,
-    top_context,
+    new_tab,
     add_intercept,
     fetch,
     substitute_host,
@@ -114,7 +114,7 @@ async def test_pattern_patterns_not_matching(
     pattern,
     url_template,
 ):
-    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[top_context["context"]])
+    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[new_tab["context"]])
 
     for key in pattern:
         pattern[key] = substitute_host(pattern[key])
@@ -124,7 +124,7 @@ async def test_pattern_patterns_not_matching(
     await add_intercept(phases=["beforeRequestSent"], url_patterns=[pattern])
 
     on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
-    asyncio.ensure_future(fetch(substitute_host(url_template)))
+    asyncio.ensure_future(fetch(substitute_host(url_template), context=new_tab))
     event = await wait_for_future_safe(on_network_event)
 
     assert_before_request_sent_event(event, is_blocked=False)
@@ -156,7 +156,7 @@ async def test_pattern_patterns_not_matching(
 async def test_string_patterns_matching(
     wait_for_event,
     subscribe_events,
-    top_context,
+    new_tab,
     add_intercept,
     fetch,
     substitute_host,
@@ -164,7 +164,7 @@ async def test_string_patterns_matching(
     pattern,
     url_template,
 ):
-    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[top_context["context"]])
+    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[new_tab["context"]])
 
     intercept = await add_intercept(
         phases=["beforeRequestSent"],
@@ -172,7 +172,7 @@ async def test_string_patterns_matching(
     )
 
     on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
-    asyncio.ensure_future(fetch(substitute_host(url_template)))
+    asyncio.ensure_future(fetch(substitute_host(url_template), context=new_tab))
     event = await wait_for_future_safe(on_network_event)
 
     assert_before_request_sent_event(event, is_blocked=True, intercepts=[intercept])
@@ -198,7 +198,7 @@ async def test_string_patterns_matching(
 async def test_string_patterns_not_matching(
     wait_for_event,
     subscribe_events,
-    top_context,
+    new_tab,
     add_intercept,
     fetch,
     substitute_host,
@@ -206,7 +206,7 @@ async def test_string_patterns_not_matching(
     pattern,
     url_template,
 ):
-    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[top_context["context"]])
+    await subscribe_events(events=[BEFORE_REQUEST_SENT_EVENT], contexts=[new_tab["context"]])
 
     await add_intercept(
         phases=["beforeRequestSent"],
@@ -214,7 +214,7 @@ async def test_string_patterns_not_matching(
     )
 
     on_network_event = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
-    asyncio.ensure_future(fetch(substitute_host(url_template)))
+    asyncio.ensure_future(fetch(substitute_host(url_template), context=new_tab))
     event = await wait_for_future_safe(on_network_event)
 
     assert_before_request_sent_event(event, is_blocked=False)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/auth_required.py b/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/auth_required.py
index 9a24946cde..4f5c836280 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/auth_required.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/auth_required.py
@@ -1,12 +1,20 @@
 import pytest
 
+import asyncio
+
 from .. import assert_response_event, AUTH_REQUIRED_EVENT, PAGE_EMPTY_HTML
 
 
 @pytest.mark.asyncio
 async def test_subscribe_status(
-    bidi_session, new_tab, subscribe_events, wait_for_event, wait_for_future_safe, url
+    bidi_session, new_tab, subscribe_events, wait_for_event, wait_for_future_safe, url, fetch
 ):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=url(PAGE_EMPTY_HTML),
+        wait="complete",
+    )
+
     await subscribe_events(events=[AUTH_REQUIRED_EVENT])
 
     # Track all received network.authRequired events in the events array.
@@ -15,7 +23,8 @@ async def test_subscribe_status(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener(AUTH_REQUIRED_EVENT, on_event)
+    remove_listener = bidi_session.add_event_listener(
+        AUTH_REQUIRED_EVENT, on_event)
 
     auth_url = url(
         "/webdriver/tests/support/http_handlers/authentication.py?realm=testrealm"
@@ -23,13 +32,7 @@ async def test_subscribe_status(
 
     on_auth_required = wait_for_event(AUTH_REQUIRED_EVENT)
 
-    # navigate using wait="none" as other wait conditions would hang because of
-    # the authentication prompt.
-    await bidi_session.browsing_context.navigate(
-        context=new_tab["context"],
-        url=auth_url,
-        wait="none",
-    )
+    asyncio.ensure_future(fetch(url=auth_url, context=new_tab))
 
     await wait_for_future_safe(on_auth_required)
 
@@ -63,7 +66,8 @@ async def test_no_authentication(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener(AUTH_REQUIRED_EVENT, on_event)
+    remove_listener = bidi_session.add_event_listener(
+        AUTH_REQUIRED_EVENT, on_event)
 
     # Navigate to a page which should not trigger any authentication.
     await bidi_session.browsing_context.navigate(
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/unsubscribe.py b/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/unsubscribe.py
index cf818fee6f..0bbf8df266 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/unsubscribe.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/auth_required/unsubscribe.py
@@ -1,15 +1,22 @@
-import asyncio
-
 import pytest
 
-pytestmark = pytest.mark.asyncio
+import asyncio
+
+from webdriver.bidi.modules.script import ScriptEvaluateResultException
 
 from .. import AUTH_REQUIRED_EVENT, PAGE_EMPTY_HTML
 
+pytestmark = pytest.mark.asyncio
 
 # This test can be moved back to `auth_required.py` when all implementations
 # support handing of HTTP auth prompt.
-async def test_unsubscribe(bidi_session, new_tab, url):
+async def test_unsubscribe(bidi_session, new_tab, url, fetch):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=url(PAGE_EMPTY_HTML),
+        wait="complete",
+    )
+
     await bidi_session.session.subscribe(events=[AUTH_REQUIRED_EVENT])
     await bidi_session.session.unsubscribe(events=[AUTH_REQUIRED_EVENT])
 
@@ -19,17 +26,13 @@ async def test_unsubscribe(bidi_session, new_tab, url):
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener(AUTH_REQUIRED_EVENT, on_event)
+    remove_listener = bidi_session.add_event_listener(
+        AUTH_REQUIRED_EVENT, on_event)
+
+    asyncio.ensure_future(fetch(url=url(
+        "/webdriver/tests/support/http_handlers/authentication.py?realm=testrealm"
+    ), context=new_tab))
 
-    # Navigate to authentication.py again and check no event is received.
-    await bidi_session.browsing_context.navigate(
-        context=new_tab["context"],
-        url=url(
-            "/webdriver/tests/support/http_handlers/authentication.py?realm=testrealm"
-        ),
-        wait="none",
-    )
-    await asyncio.sleep(0.5)
     assert len(events) == 0
 
     remove_listener()
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/before_request_sent/before_request_sent_cached.py b/testing/web-platform/tests/webdriver/tests/bidi/network/before_request_sent/before_request_sent_cached.py
new file mode 100644
index 0000000000..2de71362ae
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/before_request_sent/before_request_sent_cached.py
@@ -0,0 +1,123 @@
+import pytest
+import random
+
+from tests.support.sync import AsyncPoll
+
+from .. import (
+    assert_before_request_sent_event,
+    PAGE_EMPTY_TEXT,
+    BEFORE_REQUEST_SENT_EVENT,
+)
+
+# Note: The cached status cannot be checked in the beforeRequestSent event, but
+# the goal is to verify that the events are still emitted for cached requests.
+
+
+@pytest.mark.asyncio
+async def test_cached_document(
+    wait_for_event,
+    wait_for_future_safe,
+    url,
+    fetch,
+    setup_network_test,
+):
+    network_events = await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+        ]
+    )
+    events = network_events[BEFORE_REQUEST_SENT_EVENT]
+
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
+    cached_url = url(
+        f"/webdriver/tests/support/http_handlers/cached.py?status=200&nocache={random.random()}"
+    )
+    on_before_request_sent = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    await fetch(cached_url)
+    await wait_for_future_safe(on_before_request_sent)
+
+    assert len(events) == 1
+    expected_request = {"method": "GET", "url": cached_url}
+
+    assert_before_request_sent_event(
+        events[0],
+        expected_request=expected_request,
+    )
+
+    on_before_request_sent = wait_for_event(BEFORE_REQUEST_SENT_EVENT)
+    await fetch(cached_url)
+    await wait_for_future_safe(on_before_request_sent)
+
+    assert len(events) == 2
+
+    assert_before_request_sent_event(
+        events[1],
+        expected_request=expected_request,
+    )
+
+
+@pytest.mark.asyncio
+async def test_page_with_cached_resource(
+    bidi_session,
+    url,
+    inline,
+    setup_network_test,
+    top_context,
+):
+    network_events = await setup_network_test(
+        events=[
+            BEFORE_REQUEST_SENT_EVENT,
+        ]
+    )
+    events = network_events[BEFORE_REQUEST_SENT_EVENT]
+
+    # Build a page with a stylesheet resource which will be read from http cache
+    # on the next reload.
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
+    cached_css_url = url(
+        f"/webdriver/tests/support/http_handlers/cached.py?status=200&contenttype=text/css&nocache={random.random()}"
+    )
+    page_with_cached_css = inline(
+        f"""
+        <head><link rel="stylesheet" type="text/css" href="{cached_css_url}"></head>
+        <body>test page with cached stylesheet</body>
+        """,
+    )
+
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=page_with_cached_css,
+        wait="complete",
+    )
+
+    # Expect two events, one for the document, one for the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 2)
+    assert len(events) == 2
+
+    assert_before_request_sent_event(
+        events[0],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+    )
+    assert_before_request_sent_event(
+        events[1],
+        expected_request={"method": "GET", "url": cached_css_url},
+    )
+
+    # Reload the page.
+    await bidi_session.browsing_context.reload(context=top_context["context"])
+
+    # Expect two events after reload, for the document and the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 4)
+    assert len(events) == 4
+
+    assert_before_request_sent_event(
+        events[2],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+    )
+
+    assert_before_request_sent_event(
+        events[3],
+        expected_request={"method": "GET", "url": cached_css_url},
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/conftest.py b/testing/web-platform/tests/webdriver/tests/bidi/network/conftest.py
index 934b649c91..7813530c4c 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/conftest.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/conftest.py
@@ -17,11 +17,12 @@ async def add_intercept(bidi_session):
 
     intercepts = []
 
-    async def add_intercept(phases, url_patterns):
+    async def add_intercept(phases, url_patterns, contexts = None):
         nonlocal intercepts
         intercept = await bidi_session.network.add_intercept(
             phases=phases,
             url_patterns=url_patterns,
+            contexts=contexts,
         )
         intercepts.append(intercept)
 
@@ -143,6 +144,7 @@ async def setup_blocked_request(
     add_intercept,
     fetch,
     wait_for_event,
+    wait_for_future_safe,
     top_context,
 ):
     """Creates an intercept for the provided phase, sends a fetch request that
@@ -189,16 +191,17 @@ async def setup_blocked_request(
             ],
         )
 
+        network_event = wait_for_event(f"network.{phase}")
         if navigate:
             asyncio.ensure_future(
                 bidi_session.browsing_context.navigate(
-                    context=top_context["context"], url=blocked_url, wait="complete"
+                    context=context["context"], url=blocked_url, wait="complete"
                 )
             )
         else:
-            asyncio.ensure_future(fetch(blocked_url))
+            asyncio.ensure_future(fetch(blocked_url, context=context))
 
-        event = await wait_for_event(f"network.{phase}")
+        event = await wait_for_future_safe(network_event)
         request = event["request"]["request"]
 
         return request
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/credentials.py b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/credentials.py
index 3e595722cc..499c8a28c1 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/credentials.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/credentials.py
@@ -11,7 +11,7 @@ pytestmark = pytest.mark.asyncio
 
 @pytest.mark.parametrize("navigate", [False, True], ids=["fetch", "navigate"])
 async def test_wrong_credentials(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate
+    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate, wait_for_future_safe
 ):
     username = f"test_missing_credentials_{navigate}"
     password = f"test_missing_credentials_password_{navigate}"
@@ -27,12 +27,12 @@ async def test_wrong_credentials(
     await bidi_session.network.continue_response(
         request=request, credentials=wrong_credentials
     )
-    await on_auth_required
+    await wait_for_future_safe(on_auth_required)
 
 
 @pytest.mark.parametrize("navigate", [False, True], ids=["fetch", "navigate"])
 async def test_correct_credentials(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate
+    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate, wait_for_future_safe
 ):
     # Setup unique username / password because browsers cache credentials.
     username = f"test_wrong_credentials_{navigate}"
@@ -64,15 +64,17 @@ async def test_correct_credentials(
     await bidi_session.network.continue_response(
         request=request, credentials=correct_credentials
     )
-    await on_response_completed
+    await wait_for_future_safe(on_response_completed)
     if navigate:
-        await on_load
-
-    # Wait until 2 responseCompleted events have been emitted:
-    # - one for the initial request
-    # - one for the continue with correct credentials
-    wait = AsyncPoll(bidi_session, timeout=2)
-    await wait.until(lambda _: len(response_completed_events) >= 2)
-    assert len(response_completed_events) == 2
+        await wait_for_future_safe(on_load)
+
+    # TODO: At the moment, the specification does not expect to receive a
+    # responseCompleted event for each authentication attempt, so only assert
+    # the last event. See https://github.com/w3c/webdriver-bidi/issues/627
+
+    # Wait until a a responseCompleted event with status 200 OK is received.
+    wait = AsyncPoll(
+        bidi_session, message="Didn't receive response completed events")
+    await wait.until(lambda _: len(response_completed_events) > 0 and response_completed_events[-1]["response"]["status"] == 200)
 
     remove_listener()
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/request.py b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/request.py
index 579f1da288..ae9c94d955 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/request.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_response/request.py
@@ -1,17 +1,13 @@
 import pytest
 
-from webdriver.bidi.modules.network import AuthCredentials
-
-from tests.support.sync import AsyncPoll
-
-from .. import AUTH_REQUIRED_EVENT, RESPONSE_COMPLETED_EVENT, RESPONSE_STARTED_EVENT
+from .. import AUTH_REQUIRED_EVENT, RESPONSE_COMPLETED_EVENT
 
 pytestmark = pytest.mark.asyncio
 
 
 @pytest.mark.parametrize("navigate", [False, True], ids=["fetch", "navigate"])
 async def test_continue_auth_required(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate
+    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate, wait_for_future_safe
 ):
     # Setup unique username / password because browsers cache credentials.
     username = f"test_continue_auth_required_{navigate}"
@@ -30,12 +26,12 @@ async def test_continue_auth_required(
     # network.authRequired should be emitted.
     on_auth_required = wait_for_event(AUTH_REQUIRED_EVENT)
     await bidi_session.network.continue_response(request=request)
-    await on_auth_required
+    await wait_for_future_safe(on_auth_required)
 
 
 @pytest.mark.parametrize("navigate", [False, True], ids=["fetch", "navigate"])
 async def test_continue_response_started(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate
+    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, navigate, wait_for_future_safe
 ):
     request = await setup_blocked_request("responseStarted", navigate=navigate)
 
@@ -52,6 +48,6 @@ async def test_continue_response_started(
 
     await bidi_session.network.continue_response(request=request)
 
-    await on_response_completed
+    await wait_for_future_safe(on_response_completed)
     if navigate:
-        await on_load
+        await wait_for_future_safe(on_load)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_with_auth/action.py b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_with_auth/action.py
index a122ce0e49..e4cf6da08f 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/continue_with_auth/action.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/continue_with_auth/action.py
@@ -7,7 +7,6 @@ from tests.support.sync import AsyncPoll
 from .. import (
     assert_response_event,
     AUTH_REQUIRED_EVENT,
-    PAGE_EMPTY_TEXT,
     RESPONSE_COMPLETED_EVENT,
 )
 
@@ -15,7 +14,7 @@ pytestmark = pytest.mark.asyncio
 
 
 async def test_cancel(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, url
+    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, wait_for_future_safe
 ):
     request = await setup_blocked_request("authRequired")
     await subscribe_events(events=[RESPONSE_COMPLETED_EVENT])
@@ -24,7 +23,7 @@ async def test_cancel(
     await bidi_session.network.continue_with_auth(request=request, action="cancel")
     await on_response_completed
 
-    response_event = await on_response_completed
+    response_event = await wait_for_future_safe(on_response_completed)
     assert_response_event(
         response_event,
         expected_response={
@@ -35,7 +34,7 @@ async def test_cancel(
 
 
 async def test_default(
-    setup_blocked_request, subscribe_events, wait_for_event, bidi_session, url
+    setup_blocked_request, subscribe_events, bidi_session
 ):
     request = await setup_blocked_request("authRequired")
 
@@ -64,7 +63,7 @@ async def test_default(
 
 
 async def test_provideCredentials(
-    setup_blocked_request, subscribe_events, bidi_session, url
+    setup_blocked_request, subscribe_events, bidi_session
 ):
     # Setup unique username / password because browsers cache credentials.
     username = "test_provideCredentials"
@@ -101,7 +100,7 @@ async def test_provideCredentials(
 
 
 async def test_provideCredentials_wrong_credentials(
-    setup_blocked_request, subscribe_events, bidi_session, wait_for_event, url
+    setup_blocked_request, subscribe_events, bidi_session, wait_for_event, wait_for_future_safe
 ):
     # Setup unique username / password because browsers cache credentials.
     username = "test_provideCredentials_wrong_credentials"
@@ -129,7 +128,7 @@ async def test_provideCredentials_wrong_credentials(
     )
 
     # We expect to get another authRequired event after providing wrong credentials
-    await on_auth_required
+    await wait_for_future_safe(on_auth_required)
 
     # Continue with the correct credentials
     correct_credentials = AuthCredentials(username=username, password=password)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/response_completed/response_completed_cached.py b/testing/web-platform/tests/webdriver/tests/bidi/network/response_completed/response_completed_cached.py
index 6457e7d412..25503c971d 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/response_completed/response_completed_cached.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/response_completed/response_completed_cached.py
@@ -148,6 +148,7 @@ async def test_cached_revalidate(
     )
     events = network_events[RESPONSE_COMPLETED_EVENT]
 
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
     revalidate_url = url(
         f"/webdriver/tests/support/http_handlers/must-revalidate.py?nocache={random.random()}"
     )
@@ -189,3 +190,74 @@ async def test_cached_revalidate(
         expected_request=expected_request,
         expected_response=expected_response,
     )
+
+
+@pytest.mark.asyncio
+async def test_page_with_cached_resource(
+    bidi_session,
+    url,
+    inline,
+    setup_network_test,
+    top_context,
+):
+    network_events = await setup_network_test(
+        events=[
+            RESPONSE_COMPLETED_EVENT,
+        ]
+    )
+    events = network_events[RESPONSE_COMPLETED_EVENT]
+
+    # Build a page with a stylesheet resource which will be read from http cache
+    # on the next reload.
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
+    cached_css_url = url(
+        f"/webdriver/tests/support/http_handlers/cached.py?status=200&contenttype=text/css&nocache={random.random()}"
+    )
+    page_with_cached_css = inline(
+        f"""
+        <head><link rel="stylesheet" type="text/css" href="{cached_css_url}"></head>
+        <body>test page with cached stylesheet</body>
+        """,
+    )
+
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=page_with_cached_css,
+        wait="complete",
+    )
+
+    # Expect two events, one for the page, one for the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 2)
+    assert len(events) == 2
+
+    assert_response_event(
+        events[0],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+        expected_response={"url": page_with_cached_css, "fromCache": False},
+    )
+    assert_response_event(
+        events[1],
+        expected_request={"method": "GET", "url": cached_css_url},
+        expected_response={"url": cached_css_url, "fromCache": False},
+    )
+
+    # Reload the page.
+    await bidi_session.browsing_context.reload(context=top_context["context"])
+
+    # Expect two additional events after reload, for the page and the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 4)
+    assert len(events) == 4
+
+    assert_response_event(
+        events[2],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+        expected_response={"url": page_with_cached_css, "fromCache": False},
+    )
+
+    assert_response_event(
+        events[3],
+        expected_request={"method": "GET", "url": cached_css_url},
+        expected_response={"url": cached_css_url, "fromCache": True},
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started.py b/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started.py
index dec743e175..fb99073fb3 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started.py
@@ -245,6 +245,11 @@ async def test_response_mime_type_file(
 async def test_www_authenticate(
     bidi_session, url, fetch, new_tab, wait_for_event, wait_for_future_safe, setup_network_test
 ):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"],
+        url=url(PAGE_EMPTY_HTML),
+        wait="complete",
+    )
     auth_url = url(
         "/webdriver/tests/support/http_handlers/authentication.py?realm=testrealm"
     )
@@ -253,11 +258,8 @@ async def test_www_authenticate(
     events = network_events[RESPONSE_STARTED_EVENT]
 
     on_response_started = wait_for_event(RESPONSE_STARTED_EVENT)
-    await bidi_session.browsing_context.navigate(
-        context=new_tab["context"],
-        url=auth_url,
-        wait="none",
-    )
+
+    asyncio.ensure_future(fetch(url=auth_url, context=new_tab))
 
     await wait_for_future_safe(on_response_started)
 
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started_cached.py b/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started_cached.py
index 2776950b0e..2c747f135a 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started_cached.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/network/response_started/response_started_cached.py
@@ -21,6 +21,7 @@ async def test_cached(
     )
     events = network_events[RESPONSE_STARTED_EVENT]
 
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
     cached_url = url(
         f"/webdriver/tests/support/http_handlers/cached.py?status=200&nocache={random.random()}"
     )
@@ -78,6 +79,7 @@ async def test_cached_redirect(
     events = network_events[RESPONSE_STARTED_EVENT]
 
     text_url = url(PAGE_EMPTY_TEXT)
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
     cached_url = url(
         f"/webdriver/tests/support/http_handlers/cached.py?status=301&location={text_url}&nocache={random.random()}"
     )
@@ -156,6 +158,7 @@ async def test_cached_revalidate(
     )
     events = network_events[RESPONSE_STARTED_EVENT]
 
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
     revalidate_url = url(
         f"/webdriver/tests/support/http_handlers/must-revalidate.py?nocache={random.random()}"
     )
@@ -197,3 +200,74 @@ async def test_cached_revalidate(
         expected_request=expected_request,
         expected_response=expected_response,
     )
+
+
+@pytest.mark.asyncio
+async def test_page_with_cached_resource(
+    bidi_session,
+    url,
+    inline,
+    setup_network_test,
+    top_context,
+):
+    network_events = await setup_network_test(
+        events=[
+            RESPONSE_STARTED_EVENT,
+        ]
+    )
+    events = network_events[RESPONSE_STARTED_EVENT]
+
+    # Build a page with a stylesheet resource which will be read from http cache
+    # on the next reload.
+    # `nocache` is not used in cached.py, it is here to avoid the browser cache.
+    cached_css_url = url(
+        f"/webdriver/tests/support/http_handlers/cached.py?status=200&contenttype=text/css&nocache={random.random()}"
+    )
+    page_with_cached_css = inline(
+        f"""
+        <head><link rel="stylesheet" type="text/css" href="{cached_css_url}"></head>
+        <body>test page with cached stylesheet</body>
+        """,
+    )
+
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=page_with_cached_css,
+        wait="complete",
+    )
+
+    # Expect two events, one for the page, one for the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 2)
+    assert len(events) == 2
+
+    assert_response_event(
+        events[0],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+        expected_response={"url": page_with_cached_css, "fromCache": False},
+    )
+    assert_response_event(
+        events[1],
+        expected_request={"method": "GET", "url": cached_css_url},
+        expected_response={"url": cached_css_url, "fromCache": False},
+    )
+
+    # Reload the page.
+    await bidi_session.browsing_context.reload(context=top_context["context"])
+
+    # Expect two additional events after reload, for the page and the stylesheet.
+    wait = AsyncPoll(bidi_session, timeout=2)
+    await wait.until(lambda _: len(events) >= 4)
+    assert len(events) == 4
+
+    assert_response_event(
+        events[2],
+        expected_request={"method": "GET", "url": page_with_cached_css},
+        expected_response={"url": page_with_cached_css, "fromCache": False},
+    )
+
+    assert_response_event(
+        events[3],
+        expected_request={"method": "GET", "url": cached_css_url},
+        expected_response={"url": cached_css_url, "fromCache": True},
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/script/call_function/serialization_options.py b/testing/web-platform/tests/webdriver/tests/bidi/script/call_function/serialization_options.py
index 4084ec4820..68c8cf9c1c 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/script/call_function/serialization_options.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/script/call_function/serialization_options.py
@@ -1,5 +1,6 @@
 import pytest
 from webdriver.bidi.modules.script import ContextTarget, SerializationOptions
+from webdriver.bidi.undefined import UNDEFINED
 
 from ... import any_string, recursive_compare
 
@@ -10,7 +11,7 @@ pytestmark = pytest.mark.asyncio
     "include_shadow_tree, shadow_root_mode, contains_children, expected",
     [
         (
-            None,
+            UNDEFINED,
             "open",
             False,
             {
@@ -20,7 +21,7 @@ pytestmark = pytest.mark.asyncio
             },
         ),
         (
-            None,
+            UNDEFINED,
             "closed",
             False,
             {
@@ -189,7 +190,7 @@ async def test_include_shadow_tree_for_custom_element(
     "include_shadow_tree, contains_children, expected",
     [
         (
-            None,
+            UNDEFINED,
             False,
             {
                 "type": "node",
@@ -438,7 +439,8 @@ async def test_max_dom_depth(
         function_declaration="""() => document.querySelector("div#with-children")""",
         target=ContextTarget(top_context["context"]),
         await_promise=True,
-        serialization_options=SerializationOptions(max_dom_depth=max_dom_depth),
+        serialization_options=SerializationOptions(
+            max_dom_depth=max_dom_depth),
     )
 
     recursive_compare(expected, result)
@@ -446,21 +448,17 @@ async def test_max_dom_depth(
 
 async def test_max_dom_depth_null(
     bidi_session,
-    send_blocking_command,
     top_context,
     get_test_page,
 ):
     await bidi_session.browsing_context.navigate(
         context=top_context["context"], url=get_test_page(), wait="complete"
     )
-    result = await send_blocking_command(
-        "script.callFunction",
-        {
-            "functionDeclaration": """() => document.querySelector("div#with-children")""",
-            "target": ContextTarget(top_context["context"]),
-            "awaitPromise": True,
-            "serializationOptions": {"maxDomDepth": None},
-        },
+    result = await bidi_session.script.call_function(
+        function_declaration="""() => document.querySelector("div#with-children")""",
+        target=ContextTarget(top_context["context"]),
+        await_promise=True,
+        serialization_options=SerializationOptions(max_dom_depth=None),
     )
 
     recursive_compare(
@@ -518,7 +516,7 @@ async def test_max_dom_depth_null(
                 "shadowRoot": None,
             },
         },
-        result["result"],
+        result,
     )
 
 
@@ -526,7 +524,7 @@ async def test_max_dom_depth_null(
     "max_object_depth, expected",
     [
         (
-            None,
+            UNDEFINED,
             {
                 "type": "array",
                 "value": [
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/session/new/connect.py b/testing/web-platform/tests/webdriver/tests/bidi/session/new/connect.py
index d5872cd3ba..523899c336 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/session/new/connect.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/session/new/connect.py
@@ -16,17 +16,16 @@ async def test_websocket_url_connect(session):
 
 # test bidi_session send
 @pytest.mark.asyncio
-async def test_bidi_session_send(bidi_session, send_blocking_command):
-    await send_blocking_command("session.status", {})
+async def test_bidi_session_send(bidi_session):
+    await bidi_session.session.status()
 
 
 # bidi session following a bidi session with a different capabilities
 # to test session recreation
 @pytest.mark.asyncio
 @pytest.mark.capabilities({"acceptInsecureCerts": True})
-async def test_bidi_session_with_different_capability(bidi_session,
-                                                      send_blocking_command):
-    await send_blocking_command("session.status", {})
+async def test_bidi_session_with_different_capability(bidi_session):
+    await bidi_session.session.status()
 
 
 # classic session following a bidi session to test session
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/session/status/status.py b/testing/web-platform/tests/webdriver/tests/bidi/session/status/status.py
index 13d131bfec..f62ad4c562 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/session/status/status.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/session/status/status.py
@@ -4,7 +4,7 @@ import pytest
 # Check that session.status can be used. The actual values for the "ready" and
 # "message" properties are implementation specific.
 @pytest.mark.asyncio
-async def test_bidi_session_status(send_blocking_command):
-    response = await send_blocking_command("session.status", {})
+async def test_bidi_session_status(bidi_session):
+    response = await bidi_session.session.status()
     assert isinstance(response["ready"], bool)
     assert isinstance(response["message"], str)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/session/subscribe/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/session/subscribe/invalid.py
index 81c38316f9..b1b4d28016 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/session/subscribe/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/session/subscribe/invalid.py
@@ -14,39 +14,38 @@ async def test_params_empty(send_blocking_command):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, "foo", 42, {}])
-async def test_params_events_invalid_type(send_blocking_command, value):
+async def test_params_events_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.subscribe", {"events": value})
+        await bidi_session.session.subscribe(events=value)
 
 
 @pytest.mark.asyncio
 async def test_params_events_empty(bidi_session):
-    response = await bidi_session.session.subscribe(events=[])
-    assert response == {}
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.session.subscribe(events=[])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, 42, [], {}])
-async def test_params_events_value_invalid_type(send_blocking_command, value):
+async def test_params_events_value_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.subscribe", {"events": [value]})
+        await bidi_session.session.subscribe(events=[value])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", ["", "foo", "foo.bar", "log.invalidEvent"])
-async def test_params_events_value_invalid_event_name(send_blocking_command, value):
+async def test_params_events_value_invalid_event_name(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.subscribe", {"events": [value]})
+        await bidi_session.session.subscribe(events=[value])
 
 
 @pytest.mark.asyncio
 async def test_params_events_value_valid_and_invalid_event_names(
-    bidi_session, send_blocking_command, top_context
+    bidi_session, top_context
 ):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.subscribe", {"events": ["log.entryAdded", "some.invalidEvent"]}
-        )
+        await bidi_session.session.subscribe(events=[
+            "log.entryAdded", "some.invalidEvent"])
 
     # Make sure that we didn't subscribe to log.entryAdded because of the error
 
@@ -56,7 +55,8 @@ async def test_params_events_value_valid_and_invalid_event_names(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener("log.entryAdded", on_event)
+    remove_listener = bidi_session.add_event_listener(
+        "log.entryAdded", on_event)
 
     await create_console_api_message(bidi_session, top_context, "text1")
 
@@ -69,57 +69,37 @@ async def test_params_events_value_valid_and_invalid_event_names(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [True, "foo", 42, {}])
-async def test_params_contexts_invalid_type(send_blocking_command, value):
+async def test_params_contexts_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.subscribe",
-            {
-                "events": [],
-                "contexts": value,
-            }
-        )
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=value)
 
 
 @pytest.mark.asyncio
 async def test_params_contexts_empty(bidi_session):
-    response = await bidi_session.session.subscribe(events=[], contexts=[])
-    assert response == {}
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=[])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, 42, [], {}])
-async def test_params_contexts_value_invalid_type(send_blocking_command, value):
+async def test_params_contexts_value_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.subscribe",
-            {
-                "events": [],
-                "contexts": [value],
-            }
-        )
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=[value])
 
 
 @pytest.mark.asyncio
-async def test_params_contexts_value_invalid_value(send_blocking_command):
+async def test_params_contexts_value_invalid_value(bidi_session):
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.subscribe",
-            {
-                "events": [],
-                "contexts": ["foo"],
-            }
-        )
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=["foo"])
 
 
 @pytest.mark.asyncio
 async def test_params_contexts_valid_and_invalid_value(
-    bidi_session, send_blocking_command, top_context
+    bidi_session, top_context
 ):
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.subscribe",
-            {"events": ["log.entryAdded"], "contexts": [top_context["context"], "foo"]},
-        )
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=[
+            top_context["context"], "foo"])
 
     # Make sure that we didn't subscribe to log.entryAdded because of error
 
@@ -129,7 +109,8 @@ async def test_params_contexts_valid_and_invalid_value(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener("log.entryAdded", on_event)
+    remove_listener = bidi_session.add_event_listener(
+        "log.entryAdded", on_event)
 
     await create_console_api_message(bidi_session, top_context, "text1")
 
@@ -141,16 +122,10 @@ async def test_params_contexts_valid_and_invalid_value(
 
 
 @pytest.mark.asyncio
-async def test_subscribe_to_closed_tab(bidi_session, send_blocking_command):
+async def test_subscribe_to_closed_tab(bidi_session):
     new_tab = await bidi_session.browsing_context.create(type_hint="tab")
     await bidi_session.browsing_context.close(context=new_tab["context"])
 
     # Try to subscribe to the closed context
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.subscribe",
-            {
-                "events": ["log.entryAdded"],
-                "contexts": [new_tab["context"]]
-            },
-        )
+        await bidi_session.session.subscribe(events=["log.entryAdded"], contexts=[new_tab["context"]])
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/session/unsubscribe/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/session/unsubscribe/invalid.py
index 5b55556413..78470afa65 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/session/unsubscribe/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/session/unsubscribe/invalid.py
@@ -5,50 +5,49 @@ from ... import create_console_api_message
 
 
 @pytest.mark.asyncio
-async def test_params_empty(bidi_session, send_blocking_command):
+async def test_params_empty(send_blocking_command):
     with pytest.raises(InvalidArgumentException):
         await send_blocking_command("session.unsubscribe", {})
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, "foo", 42, {}])
-async def test_params_events_invalid_type(bidi_session, send_blocking_command, value):
+async def test_params_events_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.unsubscribe", {"events": value})
+        await bidi_session.session.unsubscribe(events=value)
 
 
 @pytest.mark.asyncio
 async def test_params_events_empty(bidi_session):
-    response = await bidi_session.session.unsubscribe(events=[])
-    assert response == {}
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.session.unsubscribe(events=[])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, 42, [], {}])
-async def test_params_events_value_invalid_type(send_blocking_command, value):
+async def test_params_events_value_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.unsubscribe", {"events": [value]})
+        await bidi_session.session.unsubscribe(events=[value])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", ["", "foo", "foo.bar"])
-async def test_params_events_value_invalid_event_name(send_blocking_command, value):
+async def test_params_events_value_invalid_event_name(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command("session.unsubscribe", {"events": [value]})
+        await bidi_session.session.unsubscribe(events=[value])
 
 
 @pytest.mark.asyncio
 async def test_params_events_value_valid_and_invalid_event_name(
-    bidi_session, subscribe_events, send_blocking_command, wait_for_event, wait_for_future_safe, top_context
+    bidi_session, subscribe_events, wait_for_event, wait_for_future_safe, top_context
 ):
     # Subscribe to a valid event
     await subscribe_events(events=["log.entryAdded"])
 
     # Try to unsubscribe from the valid and an invalid event
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe", {"events": ["log.entryAdded", "some.invalidEvent"]}
-        )
+        await bidi_session.session.unsubscribe(events=[
+            "log.entryAdded", "some.invalidEvent"])
 
     # Make sure that we didn't unsubscribe from log.entryAdded because of the error
     # and events are still coming
@@ -59,7 +58,8 @@ async def test_params_events_value_valid_and_invalid_event_name(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener("log.entryAdded", on_event)
+    remove_listener = bidi_session.add_event_listener(
+        "log.entryAdded", on_event)
 
     on_entry_added = wait_for_event("log.entryAdded")
     await create_console_api_message(bidi_session, top_context, "text1")
@@ -72,7 +72,7 @@ async def test_params_events_value_valid_and_invalid_event_name(
 
 @pytest.mark.asyncio
 async def test_unsubscribe_from_one_event_and_then_from_module(
-    bidi_session, subscribe_events, send_blocking_command
+    bidi_session, subscribe_events
 ):
     await subscribe_events(events=["browsingContext"])
 
@@ -81,9 +81,7 @@ async def test_unsubscribe_from_one_event_and_then_from_module(
 
     # Try to unsubscribe from all events
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe", {"events": ["browsingContext"]}
-        )
+        await bidi_session.session.unsubscribe(events=["browsingContext"])
 
     # Unsubscribe from the rest of the events
     await bidi_session.session.unsubscribe(events=["browsingContext.contextCreated"])
@@ -92,61 +90,40 @@ async def test_unsubscribe_from_one_event_and_then_from_module(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [True, "foo", 42, {}])
-async def test_params_contexts_invalid_type(bidi_session, send_blocking_command, value):
+async def test_params_contexts_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {
-                "events": [],
-                "contexts": value,
-            }
-        )
+        await bidi_session.session.unsubscribe(events=["browsingContext.load"], contexts=value)
 
 
 @pytest.mark.asyncio
 async def test_params_contexts_empty(bidi_session):
-    response = await bidi_session.session.unsubscribe(events=[], contexts=[])
-    assert response == {}
+    with pytest.raises(InvalidArgumentException):
+        await bidi_session.session.unsubscribe(events=["browsingContext.load"], contexts=[])
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("value", [None, True, 42, [], {}])
-async def test_params_contexts_value_invalid_type(send_blocking_command, value):
+async def test_params_contexts_value_invalid_type(bidi_session, value):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {
-                "events": [],
-                "contexts": [value],
-            }
-        )
+        await bidi_session.session.unsubscribe(events=["browsingContext.load"], contexts=[value])
 
 
 @pytest.mark.asyncio
-async def test_params_contexts_value_invalid_value(send_blocking_command):
+async def test_params_contexts_value_invalid_value(bidi_session):
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {
-                "events": [],
-                "contexts": ["foo"],
-            },
-        )
+        await bidi_session.session.unsubscribe(events=["browsingContext.load"], contexts=["foo"])
 
 
 @pytest.mark.asyncio
 async def test_params_contexts_value_valid_and_invalid_value(
-    bidi_session, subscribe_events, send_blocking_command, wait_for_event, wait_for_future_safe, top_context
+    bidi_session, subscribe_events, wait_for_event, wait_for_future_safe, top_context
 ):
     # Subscribe to a valid context
     await subscribe_events(events=["log.entryAdded"], contexts=[top_context["context"]])
 
     # Try to unsubscribe from the valid and an invalid context
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {"events": ["log.entryAdded"], "contexts": [top_context["context"], "foo"]},
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"], contexts=[top_context["context"], "foo"])
 
     # Make sure that we didn't unsubscribe from the valid context because of the error
     # and events are still coming
@@ -157,7 +134,8 @@ async def test_params_contexts_value_valid_and_invalid_value(
     async def on_event(method, data):
         events.append(data)
 
-    remove_listener = bidi_session.add_event_listener("log.entryAdded", on_event)
+    remove_listener = bidi_session.add_event_listener(
+        "log.entryAdded", on_event)
 
     on_entry_added = wait_for_event("log.entryAdded")
     await create_console_api_message(bidi_session, top_context, "text1")
@@ -170,7 +148,7 @@ async def test_params_contexts_value_valid_and_invalid_value(
 
 @pytest.mark.asyncio
 async def test_unsubscribe_from_closed_tab(
-    bidi_session, subscribe_events, send_blocking_command
+    bidi_session, subscribe_events
 ):
     new_tab = await bidi_session.browsing_context.create(type_hint="tab")
     # Subscribe to a new context
@@ -180,55 +158,42 @@ async def test_unsubscribe_from_closed_tab(
 
     # Try to unsubscribe from the closed context
     with pytest.raises(NoSuchFrameException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {"events": ["log.entryAdded"], "contexts": [new_tab["context"]]},
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"], contexts=[new_tab["context"]])
 
 
 @pytest.mark.asyncio
-async def test_params_unsubscribe_globally_without_subscription(send_blocking_command):
+async def test_params_unsubscribe_globally_without_subscription(bidi_session):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe", {"events": ["log.entryAdded"]}
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"])
 
 
 @pytest.mark.asyncio
 async def test_params_unsubscribe_globally_with_individual_subscription(
-    subscribe_events, send_blocking_command, top_context
+    subscribe_events, bidi_session, top_context
 ):
     # Subscribe to one context
     await subscribe_events(events=["log.entryAdded"], contexts=[top_context["context"]])
 
     # Try to unsubscribe globally
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe", {"events": ["log.entryAdded"]}
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"])
 
 
 @pytest.mark.asyncio
 async def test_params_unsubscribe_from_one_context_without_subscription(
-    send_blocking_command, top_context
+    bidi_session, top_context
 ):
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {"events": ["log.entryAdded"], "contexts": [top_context["context"]]},
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"], contexts=[top_context["context"]])
 
 
 @pytest.mark.asyncio
 async def test_params_unsubscribe_from_one_context_with_global_subscription(
-    subscribe_events, send_blocking_command, top_context
+    subscribe_events, bidi_session, top_context
 ):
     # Subscribe to all contexts
     await subscribe_events(events=["log.entryAdded"])
 
     # Try to unsubscribe from one context
     with pytest.raises(InvalidArgumentException):
-        await send_blocking_command(
-            "session.unsubscribe",
-            {"events": ["log.entryAdded"], "contexts": [top_context["context"]]},
-        )
+        await bidi_session.session.unsubscribe(events=["log.entryAdded"], contexts=[top_context["context"]])
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/__init__.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/__init__.py
index 0d7cea96bc..4ca0f7bdd7 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/__init__.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/__init__.py
@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta, timezone
 from typing import Optional
 from webdriver.bidi.modules.network import NetworkBytesValue, NetworkStringValue
-from webdriver.bidi.modules.storage import PartialCookie, PartitionDescriptor
+from webdriver.bidi.modules.storage import PartialCookie, PartitionDescriptor, BrowsingContextPartitionDescriptor
 from .. import any_int, recursive_compare
 
 COOKIE_NAME = 'SOME_COOKIE_NAME'
@@ -88,3 +88,11 @@ def format_expiry_string(date):
     # same formatting as Date.toUTCString() in javascript
     utc_string_format = "%a, %d %b %Y %H:%M:%S GMT"
     return date.strftime(utc_string_format)
+
+
+async def get_default_partition_key(bidi_session, context=None):
+    if context is None:
+        result = await bidi_session.storage.get_cookies()
+    else:
+        result = await bidi_session.storage.get_cookies(partition=BrowsingContextPartitionDescriptor(context))
+    return result['partitionKey']
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/__init__.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/__init__.py
new file mode 100644
index 0000000000..4b73b0bced
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/__init__.py
@@ -0,0 +1,3 @@
+async def assert_cookies_are_not_present(bidi_session, filter=None, partition=None):
+    result = await bidi_session.storage.get_cookies(filter=filter, partition=partition)
+    assert result["cookies"] == []
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/filter.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/filter.py
new file mode 100644
index 0000000000..7bfb743cfc
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/filter.py
@@ -0,0 +1,514 @@
+import pytest
+from webdriver.bidi.modules.network import NetworkBase64Value, NetworkStringValue
+from webdriver.bidi.modules.storage import CookieFilter
+
+from . import assert_cookies_are_not_present
+from .. import (
+    assert_cookie_is_set,
+    create_cookie,
+    format_expiry_string,
+    get_default_partition_key,
+    generate_expiry_date,
+)
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize(
+    "filter",
+    [
+        ({"size": 6}),
+        ({"value": NetworkStringValue("bar")}),
+        ({"value": NetworkBase64Value("YmFy")}),
+    ],
+)
+async def test_filter(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    add_cookie,
+    filter,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+    # This value is going to be used to match specified filter options:
+    # 1. size == 6, both matching cookies have name length 3, the value has length 3;
+    # 2. value == "bar";
+    # 3. value == base64 value "YmFy", it will be decoded to a string "bar".
+    cookie_value_matching_filter = "bar"
+
+    cookie1_name = "baz"
+    await add_cookie(new_tab["context"], cookie1_name, cookie_value_matching_filter)
+
+    cookie2_name = "foo"
+    await add_cookie(new_tab["context"], cookie2_name, cookie_value_matching_filter)
+
+    cookie3_name = "foo_3"
+    cookie3_value = "not_bar"
+    await add_cookie(new_tab["context"], cookie3_name, cookie3_value)
+
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support",
+        secure=False,
+    )
+
+
+async def test_filter_domain(
+    bidi_session,
+    top_context,
+    new_tab,
+    test_page,
+    test_page_cross_origin,
+    domain_value,
+    add_cookie,
+):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"], url=test_page, wait="complete"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page_cross_origin, wait="complete"
+    )
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await add_cookie(top_context["context"], cookie1_name, cookie1_value)
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await add_cookie(top_context["context"], cookie2_name, cookie2_value)
+
+    cookie3_name = "foo_2"
+    cookie3_value = "bar_2"
+    cookie3_domain = domain_value(domain="alt")
+    await add_cookie(new_tab["context"], cookie3_name, cookie3_value)
+
+    filter = CookieFilter(domain=domain_value())
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=cookie3_domain,
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support",
+        secure=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "expiry_diff_to_delete, expiry_diff_to_remain",
+    [
+        (1, 2),
+        (1, None),
+    ],
+)
+async def test_filter_expiry(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    add_cookie,
+    expiry_diff_to_delete,
+    expiry_diff_to_remain,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    expiry_date_to_delete = generate_expiry_date(expiry_diff_to_delete)
+    expiry_to_delete = int(expiry_date_to_delete.timestamp())
+    date_string_to_delete = format_expiry_string(expiry_date_to_delete)
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await add_cookie(
+        context=new_tab["context"],
+        name=cookie1_name,
+        value=cookie1_value,
+        expiry=date_string_to_delete,
+    )
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await add_cookie(
+        context=new_tab["context"],
+        name=cookie2_name,
+        value=cookie2_value,
+        expiry=date_string_to_delete,
+    )
+
+    cookie3_name = "foo_3"
+    cookie3_value = "bar_3"
+    if expiry_diff_to_remain is None:
+        date_string_to_remain = None
+    else:
+        expiry_date_to_remain = generate_expiry_date(expiry_diff_to_remain)
+        date_string_to_remain = format_expiry_string(expiry_date_to_remain)
+
+    await add_cookie(
+        new_tab["context"], cookie3_name, cookie3_value, expiry=date_string_to_remain
+    )
+
+    filter = CookieFilter(expiry=expiry_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=CookieFilter(expiry=expiry_to_delete),
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support",
+        secure=False,
+    )
+
+
+async def test_filter_name(bidi_session, new_tab, test_page, add_cookie, domain_value):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    name_to_delete = "foo"
+
+    cookie1_value = "bar"
+    cookie1_path = "/"
+    await add_cookie(
+        new_tab["context"], name_to_delete, cookie1_value, path=cookie1_path
+    )
+
+    cookie2_value = "baz"
+    cookie2_path = "/webdriver/"
+    await add_cookie(
+        new_tab["context"], name_to_delete, cookie2_value, path=cookie2_path
+    )
+
+    name_to_remain = "foo_2"
+    cookie3_value = "bar_2"
+    cookie3_path = "/"
+    await add_cookie(new_tab["context"], name_to_remain, cookie3_value, path=cookie3_path)
+
+    filter = CookieFilter(name=name_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=name_to_remain,
+        value={"type": "string", "value": cookie3_value},
+        path=cookie3_path,
+        secure=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "same_site_to_delete, same_site_to_remain",
+    [
+        ("none", "strict"),
+        ("lax", "none"),
+        ("strict", "none"),
+        ("lax", "strict"),
+        ("strict", "lax"),
+    ],
+)
+async def test_filter_same_site(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    same_site_to_delete,
+    same_site_to_remain,
+    add_cookie,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await add_cookie(
+        new_tab["context"],
+        cookie1_name,
+        cookie1_value,
+        same_site=same_site_to_delete,
+    )
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await add_cookie(
+        new_tab["context"],
+        cookie2_name,
+        cookie2_value,
+        same_site=same_site_to_delete,
+    )
+
+    cookie3_name = "foo_3"
+    cookie3_value = "bar_3"
+    await add_cookie(
+        new_tab["context"], cookie3_name, cookie3_value, same_site=same_site_to_remain
+    )
+
+    filter = CookieFilter(same_site=same_site_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support",
+        same_site=same_site_to_remain,
+        secure=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "secure_to_delete, secure_to_remain",
+    [(True, False), (False, True)],
+)
+async def test_filter_secure(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    add_cookie,
+    secure_to_delete,
+    secure_to_remain,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await add_cookie(
+        new_tab["context"],
+        cookie1_name,
+        cookie1_value,
+        secure=secure_to_delete,
+    )
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await add_cookie(
+        new_tab["context"],
+        cookie2_name,
+        cookie2_value,
+        secure=secure_to_delete,
+    )
+
+    cookie3_name = "foo_3"
+    cookie3_value = "bar_3"
+    await add_cookie(
+        new_tab["context"], cookie3_name, cookie3_value, secure=secure_to_remain
+    )
+
+    filter = CookieFilter(secure=secure_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support",
+        secure=secure_to_remain,
+    )
+
+
+@pytest.mark.parametrize(
+    "path_to_delete, path_to_remain",
+    [
+        ("/webdriver/tests/support", "/"),
+        ("/", None),
+        ("/webdriver", "/webdriver/tests"),
+    ],
+)
+async def test_filter_path(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    add_cookie,
+    path_to_delete,
+    path_to_remain,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await add_cookie(
+        new_tab["context"],
+        cookie1_name,
+        cookie1_value,
+        path=path_to_delete,
+    )
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await add_cookie(
+        new_tab["context"],
+        cookie2_name,
+        cookie2_value,
+        path=path_to_delete,
+    )
+
+    cookie3_name = "foo_3"
+    cookie3_value = "bar_3"
+    await add_cookie(
+        new_tab["context"], cookie3_name, cookie3_value, path=path_to_remain
+    )
+
+    filter = CookieFilter(path=path_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present.
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        path="/webdriver/tests/support" if path_to_remain is None else path_to_remain,
+        secure=False,
+    )
+
+
+@pytest.mark.parametrize(
+    "http_only_to_delete, http_only_to_remain",
+    [(True, False), (False, True)],
+)
+async def test_filter_http_only(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    set_cookie,
+    http_only_to_delete,
+    http_only_to_remain,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_name = "bar"
+    cookie1_value = "foo"
+    await set_cookie(
+        cookie=create_cookie(
+            domain=domain_value(),
+            name=cookie1_name,
+            value=NetworkStringValue(cookie1_value),
+            http_only=http_only_to_delete,
+        )
+    )
+
+    cookie2_name = "foo"
+    cookie2_value = "bar"
+    await set_cookie(
+        cookie=create_cookie(
+            domain=domain_value(),
+            name=cookie2_name,
+            value=NetworkStringValue(cookie2_value),
+            http_only=http_only_to_delete,
+        )
+    )
+
+    cookie3_name = "foo_2"
+    cookie3_value = "bar_2"
+    await set_cookie(
+        cookie=create_cookie(
+            domain=domain_value(),
+            name=cookie3_name,
+            value=NetworkStringValue(cookie3_value),
+            http_only=http_only_to_remain,
+        )
+    )
+
+    filter = CookieFilter(http_only=http_only_to_delete)
+    result = await bidi_session.storage.delete_cookies(
+        filter=filter,
+    )
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, filter)
+
+    # Make sure that non-deleted cookies are present
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie3_name,
+        value={"type": "string", "value": cookie3_value},
+        http_only=http_only_to_remain,
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/invalid.py
new file mode 100644
index 0000000000..ba9c5a5da0
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/invalid.py
@@ -0,0 +1,163 @@
+import pytest
+import webdriver.bidi.error as error
+
+from webdriver.bidi.modules.network import NetworkBase64Value, NetworkStringValue
+from webdriver.bidi.modules.storage import (
+    BrowsingContextPartitionDescriptor,
+    CookieFilter,
+    StorageKeyPartitionDescriptor,
+)
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize("value", [False, 42, "foo", []])
+async def test_params_filter_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=value)
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_filter_domain_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(domain=value))
+
+
+@pytest.mark.parametrize("value", [False, "foo", {}, [], -1, 0.5])
+async def test_params_filter_expiry_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(expiry=value))
+
+
+@pytest.mark.parametrize("value", ["foo", {}, [], 42])
+async def test_params_filter_http_only_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(http_only=value))
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_filter_name_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(name=value))
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_filter_path_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(path=value))
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_filter_same_site_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(same_site=value))
+
+
+@pytest.mark.parametrize("value", ["", "INVALID_SAME_SITE_STATE"])
+async def test_params_filter_same_site_invalid_value(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(same_site=value))
+
+
+@pytest.mark.parametrize("value", ["foo", {}, [], 42])
+async def test_params_filter_secure_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(secure=value))
+
+
+@pytest.mark.parametrize("value", [False, "foo", {}, [], -1, 0.5])
+async def test_params_filter_size_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(size=value))
+
+
+@pytest.mark.parametrize("value", [False, 42, "foo", []])
+async def test_params_filter_value_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(filter=CookieFilter(value=value))
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_filter_value_type_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            filter=CookieFilter(value={"type": value})
+        )
+
+
+async def test_params_filter_value_type_invalid_value(bidi_session):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            filter=CookieFilter(value={"type": "foo"})
+        )
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_filter_value_base64_type_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            filter=CookieFilter(value=NetworkBase64Value(value))
+        )
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_filter_value_string_type_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            filter=CookieFilter(value=NetworkStringValue(value))
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, "foo", []])
+async def test_params_partition_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(partition=value)
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_partition_type_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(partition={"type": value})
+
+
+async def test_params_partition_type_invalid_value(bidi_session):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(partition={"type": "foo"})
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_partition_context_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            partition=BrowsingContextPartitionDescriptor(context=value)
+        )
+
+
+async def test_partition_invalid_context(bidi_session):
+    with pytest.raises(error.NoSuchFrameException):
+        await bidi_session.storage.delete_cookies(
+            partition=BrowsingContextPartitionDescriptor("foo")
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_partition_source_origin_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            partition=StorageKeyPartitionDescriptor(source_origin=value)
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_partition_user_context_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.storage.delete_cookies(
+            partition=StorageKeyPartitionDescriptor(user_context=value)
+        )
+
+
+async def test_params_partition_user_context_invalid_value(bidi_session):
+    with pytest.raises(error.NoSuchUserContextException):
+        await bidi_session.storage.delete_cookies(
+            partition=StorageKeyPartitionDescriptor(user_context="foo")
+        )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/partition.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/partition.py
new file mode 100644
index 0000000000..bf23abb720
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/delete_cookies/partition.py
@@ -0,0 +1,308 @@
+import pytest
+
+from webdriver.bidi.modules.network import NetworkStringValue
+from webdriver.bidi.modules.storage import (
+    BrowsingContextPartitionDescriptor,
+    PartialCookie,
+    StorageKeyPartitionDescriptor,
+)
+
+from . import assert_cookies_are_not_present
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
+from ... import recursive_compare
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize(
+    "with_document_cookie",
+    [True, False],
+    ids=["with document cookie", "with set cookie"],
+)
+async def test_default_partition(
+    bidi_session,
+    top_context,
+    new_tab,
+    test_page,
+    test_page_cross_origin,
+    domain_value,
+    add_cookie,
+    set_cookie,
+    with_document_cookie,
+):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"], url=test_page_cross_origin, wait="complete"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_name = "foo"
+    cookie1_value = "bar"
+
+    cookie2_name = "foo_2"
+    cookie2_value = "bar_2"
+
+    if with_document_cookie:
+        await add_cookie(new_tab["context"], cookie1_name, cookie1_value)
+        await add_cookie(top_context["context"], cookie2_name, cookie2_value)
+    else:
+        await set_cookie(
+            cookie=create_cookie(
+                domain=domain_value("alt"),
+                name=cookie1_name,
+                value=NetworkStringValue(cookie1_value),
+            )
+        )
+        await set_cookie(
+            cookie=create_cookie(
+                domain=domain_value(),
+                name=cookie2_name,
+                value=NetworkStringValue(cookie2_value),
+            )
+        )
+
+    result = await bidi_session.storage.delete_cookies()
+    assert result == {
+        "partitionKey": (await get_default_partition_key(bidi_session))
+    }
+
+    await assert_cookies_are_not_present(bidi_session)
+
+
+@pytest.mark.parametrize(
+    "with_document_cookie",
+    [True, False],
+    ids=["with document cookie", "with set cookie"],
+)
+async def test_partition_context(
+    bidi_session,
+    new_tab,
+    test_page,
+    domain_value,
+    add_cookie,
+    set_cookie,
+    with_document_cookie,
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie_name = "foo"
+    cookie_value = "bar"
+    partition = BrowsingContextPartitionDescriptor(new_tab["context"])
+    if with_document_cookie:
+        await add_cookie(new_tab["context"], cookie_name, cookie_value)
+    else:
+        await set_cookie(
+            cookie=create_cookie(
+                domain=domain_value(),
+                name=cookie_name,
+                value=NetworkStringValue(cookie_value),
+            ),
+            partition=partition,
+        )
+
+    result = await bidi_session.storage.delete_cookies(partition=partition)
+    assert result == {"partitionKey": (await get_default_partition_key(bidi_session, new_tab["context"]))}
+
+    await assert_cookies_are_not_present(bidi_session, partition)
+
+
+@pytest.mark.parametrize("domain", ["", "alt"], ids=["same_origin", "cross_origin"])
+async def test_partition_context_iframe(
+    bidi_session, new_tab, inline, domain_value, domain, set_cookie
+):
+    iframe_url = inline("<div id='in-iframe'>foo</div>", domain=domain)
+    page_url = inline(f"<iframe src='{iframe_url}'></iframe>")
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=page_url, wait="complete"
+    )
+
+    contexts = await bidi_session.browsing_context.get_tree(root=new_tab["context"])
+    iframe_context = contexts[0]["children"][0]
+
+    cookie_name = "foo"
+    cookie_value = "bar"
+    frame_partition = BrowsingContextPartitionDescriptor(iframe_context["context"])
+    await set_cookie(
+        cookie=create_cookie(
+            domain=domain_value(domain),
+            name=cookie_name,
+            value=NetworkStringValue(cookie_value),
+        ),
+        partition=frame_partition,
+    )
+
+    result = await bidi_session.storage.delete_cookies(partition=frame_partition)
+    assert result == {"partitionKey": (await get_default_partition_key(bidi_session, new_tab["context"]))}
+
+    await assert_cookies_are_not_present(bidi_session, frame_partition)
+
+
+@pytest.mark.parametrize(
+    "protocol",
+    [
+        "http",
+        "https",
+    ],
+)
+async def test_partition_source_origin(
+    bidi_session,
+    new_tab,
+    top_context,
+    test_page,
+    inline,
+    domain_value,
+    origin,
+    set_cookie,
+    protocol,
+):
+    url = inline("<div>bar</div>", protocol=protocol, domain="alt")
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"], url=url, wait="complete"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    cookie1_domain = domain_value(domain="alt")
+    cookie1_name = "foo"
+    cookie1_value = "bar"
+    cookie1_source_origin = origin(domain="alt", protocol=protocol)
+    cookie1_partition = StorageKeyPartitionDescriptor(
+        source_origin=cookie1_source_origin
+    )
+    await set_cookie(
+        cookie=create_cookie(
+            domain=cookie1_domain,
+            name=cookie1_name,
+            value=NetworkStringValue(cookie1_value),
+        ),
+        partition=cookie1_partition,
+    )
+
+    cookie2_domain = domain_value()
+    cookie2_name = "bar"
+    cookie2_value = "foo"
+    cookie2_source_origin = origin()
+    cookie2_partition = StorageKeyPartitionDescriptor(
+        source_origin=cookie2_source_origin
+    )
+    await set_cookie(
+        cookie=create_cookie(
+            domain=cookie2_domain,
+            name=cookie2_name,
+            value=NetworkStringValue(cookie2_value),
+        ),
+        partition=cookie2_partition,
+    )
+
+    result = await bidi_session.storage.delete_cookies(partition=cookie1_partition)
+    assert result == {
+        "partitionKey": {
+            **(await get_default_partition_key(bidi_session)),
+            "sourceOrigin": cookie1_source_origin
+        }
+    }
+
+    await assert_cookies_are_not_present(bidi_session, partition=cookie1_partition)
+
+    # Check that the second cookie is still present on another origin.
+    await assert_cookie_is_set(
+        bidi_session=bidi_session,
+        domain=domain_value(),
+        name=cookie2_name,
+        value={"type": "string", "value": cookie2_value},
+        partition=cookie2_partition,
+    )
+
+
+@pytest.mark.parametrize(
+    "with_document_cookie",
+    [True, False],
+    ids=["with document cookie", "with set cookie"],
+)
+async def test_partition_user_context(
+    bidi_session,
+    test_page,
+    create_user_context,
+    test_page_cross_origin,
+    domain_value,
+    add_cookie,
+    set_cookie,
+    with_document_cookie,
+):
+    user_context_1 = await create_user_context()
+    new_context_1 = await bidi_session.browsing_context.create(
+        user_context=user_context_1, type_hint="tab"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_context_1["context"], url=test_page, wait="complete"
+    )
+
+    user_context_2 = await create_user_context()
+    new_context_2 = await bidi_session.browsing_context.create(
+        user_context=user_context_2, type_hint="tab"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_context_2["context"], url=test_page_cross_origin, wait="complete"
+    )
+
+    cookie1_domain = domain_value()
+    cookie1_name = "foo_1"
+    cookie1_value = "bar_1"
+    cookie1_partition = StorageKeyPartitionDescriptor(user_context=user_context_1)
+
+    cookie2_domain = domain_value(domain="alt")
+    cookie2_name = "foo_2"
+    cookie2_value = "bar_2"
+    cookie2_partition = StorageKeyPartitionDescriptor(user_context=user_context_2)
+
+    if with_document_cookie:
+        await add_cookie(
+            new_context_1["context"], cookie1_name, cookie1_value, path="/"
+        )
+        await add_cookie(
+            new_context_2["context"], cookie2_name, cookie2_value, path="/"
+        )
+    else:
+        await set_cookie(
+            cookie=PartialCookie(
+                domain=cookie1_domain,
+                name=cookie1_name,
+                value=NetworkStringValue(cookie1_value),
+            ),
+            partition=cookie1_partition,
+        )
+        await set_cookie(
+            cookie=PartialCookie(
+                domain=cookie2_domain,
+                name=cookie2_name,
+                value=NetworkStringValue(cookie2_value),
+            ),
+            partition=cookie2_partition,
+        )
+
+    result = await bidi_session.storage.delete_cookies(
+        partition=StorageKeyPartitionDescriptor(user_context=user_context_1)
+    )
+    assert result == {
+        "partitionKey": {
+            **(await get_default_partition_key(bidi_session)),
+            "userContext": user_context_1
+        }
+    }
+
+    # Make sure that deleted cookies are not present.
+    await assert_cookies_are_not_present(bidi_session, partition=cookie1_partition)
+
+    # Check that the second cookie is still present on another origin.
+    await assert_cookie_is_set(
+        bidi_session=bidi_session,
+        domain=cookie2_domain,
+        name=cookie2_name,
+        value={"type": "string", "value": cookie2_value},
+        partition=cookie2_partition,
+        secure=False
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/filter.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/filter.py
index b244ef86ac..efa22f7dc9 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/filter.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/filter.py
@@ -2,7 +2,7 @@ import pytest
 from webdriver.bidi.modules.network import NetworkBase64Value, NetworkStringValue
 from webdriver.bidi.modules.storage import CookieFilter
 
-from .. import create_cookie, format_expiry_string, generate_expiry_date
+from .. import create_cookie, format_expiry_string, get_default_partition_key, generate_expiry_date
 from ... import recursive_compare
 
 pytestmark = pytest.mark.asyncio
@@ -37,7 +37,9 @@ async def test_filter(
         filter=filter,
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
@@ -102,7 +104,9 @@ async def test_filter_domain(
         filter=CookieFilter(domain=domain),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
@@ -191,7 +195,9 @@ async def test_filter_expiry(
         filter=CookieFilter(expiry=cookie1_expiry),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
@@ -303,7 +309,9 @@ async def test_filter_same_site(
         filter=CookieFilter(same_site=same_site_1),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
@@ -371,7 +379,9 @@ async def test_filter_secure(
         filter=CookieFilter(secure=secure_1),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
@@ -449,7 +459,9 @@ async def test_filter_path(
         filter=CookieFilter(path=path_1),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
     recursive_compare(
@@ -528,7 +540,9 @@ async def test_filter_http_only(
         filter=CookieFilter(http_only=http_only_1),
     )
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["name"])
     recursive_compare(
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/invalid.py
index fbd5647f30..93d0da2ac4 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/invalid.py
@@ -153,3 +153,10 @@ async def test_params_partition_user_context_invalid_type(bidi_session, value):
         await bidi_session.storage.get_cookies(
             partition=StorageKeyPartitionDescriptor(user_context=value)
         )
+
+
+async def test_params_partition_user_context_invalid_value(bidi_session):
+    with pytest.raises(error.NoSuchUserContextException):
+        await bidi_session.storage.get_cookies(
+            partition=StorageKeyPartitionDescriptor(user_context="foo")
+        )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/partition.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/partition.py
index a1c2650352..632e7ffa26 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/partition.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/get_cookies/partition.py
@@ -6,7 +6,7 @@ from webdriver.bidi.modules.storage import (
     StorageKeyPartitionDescriptor,
 )
 
-from .. import create_cookie
+from .. import create_cookie, get_default_partition_key
 from ... import recursive_compare
 
 pytestmark = pytest.mark.asyncio
@@ -38,7 +38,9 @@ async def test_default_partition(
 
     cookies = await bidi_session.storage.get_cookies()
 
-    assert cookies["partitionKey"] == {}
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session)),
+    }
     assert len(cookies["cookies"]) == 2
     # Provide consistent cookies order.
     (cookie_1, cookie_2) = sorted(cookies["cookies"], key=lambda c: c["domain"])
@@ -101,10 +103,10 @@ async def test_partition_context(
         partition=BrowsingContextPartitionDescriptor(new_tab["context"])
     )
 
-    # `partitionKey` here might contain `sourceOrigin` for certain browser implementation,
-    # so use `recursive_compare` to allow additional fields to be present.
-    recursive_compare({"partitionKey": {}}, cookies)
-
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session, new_tab["context"])),
+        "userContext": "default"
+    }
     assert len(cookies["cookies"]) == 1
     recursive_compare(
         {
@@ -125,12 +127,52 @@ async def test_partition_context(
         partition=BrowsingContextPartitionDescriptor(new_context["context"])
     )
 
-    # `partitionKey` here might contain `sourceOrigin` for certain browser implementation,
-    # so use `recursive_compare` to allow additional fields to be present.
-    recursive_compare({"partitionKey": {}}, cookies)
+    assert cookies["partitionKey"] == {
+        **(await get_default_partition_key(bidi_session, new_context["context"])),
+        "userContext": user_context
+    }
     assert len(cookies["cookies"]) == 0
 
 
+async def test_partition_context_with_different_domain(
+    bidi_session, set_cookie, new_tab, test_page, domain_value
+):
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=test_page, wait="complete"
+    )
+
+    # Set cookie on a different domain.
+    cookie_domain = domain_value(domain="alt")
+    cookie_name = "foo"
+    cookie_value = "bar"
+    partition = BrowsingContextPartitionDescriptor(new_tab["context"])
+    await set_cookie(
+        cookie=create_cookie(
+            domain=cookie_domain,
+            name=cookie_name,
+            value=NetworkStringValue(cookie_value),
+        ),
+        partition=partition,
+    )
+
+    result = await bidi_session.storage.get_cookies(
+        partition=BrowsingContextPartitionDescriptor(new_tab["context"])
+    )
+
+    assert result["cookies"] == [
+        {
+            "domain": cookie_domain,
+            "httpOnly": False,
+            "name": cookie_name,
+            "path": "/",
+            "sameSite": "none",
+            "secure": True,
+            "size": 6,
+            "value": {"type": "string", "value": cookie_value},
+        }
+    ]
+
+
 @pytest.mark.parametrize("domain", ["", "alt"], ids=["same_origin", "cross_origin"])
 async def test_partition_context_iframe(
     bidi_session, new_tab, inline, domain_value, domain, set_cookie
@@ -174,7 +216,7 @@ async def test_partition_context_iframe(
                     "value": {"type": "string", "value": cookie_value},
                 }
             ],
-            "partitionKey": {},
+            "partitionKey": {"userContext": "default"},
         },
         cookies,
     )
@@ -256,3 +298,109 @@ async def test_partition_source_origin(
         },
         cookies,
     )
+
+
+async def test_partition_default_user_context(
+    bidi_session,
+    test_page,
+    domain_value,
+    add_cookie,
+):
+    new_context = await bidi_session.browsing_context.create(type_hint="tab")
+    await bidi_session.browsing_context.navigate(
+        context=new_context["context"], url=test_page, wait="complete"
+    )
+
+    cookie_name = "foo"
+    cookie_value = "bar"
+    await add_cookie(new_context["context"], cookie_name, cookie_value)
+
+    # Check that added cookies are present on the right user context.
+    result = await bidi_session.storage.get_cookies(
+        partition=StorageKeyPartitionDescriptor(user_context="default")
+    )
+    expected_cookies = [
+        {
+            "domain": domain_value(),
+            "httpOnly": False,
+            "name": cookie_name,
+            "path": "/webdriver/tests/support",
+            "sameSite": "none",
+            "secure": False,
+            "size": 6,
+            "value": {"type": "string", "value": cookie_value},
+        }
+    ]
+    recursive_compare(
+        {
+            "cookies": expected_cookies,
+            "partitionKey": {"userContext": "default"},
+        },
+        result,
+    )
+
+
+async def test_partition_user_context(
+    bidi_session,
+    test_page,
+    domain_value,
+    create_user_context,
+    test_page_cross_origin,
+    add_cookie,
+):
+    user_context_1 = await create_user_context()
+    new_context_1 = await bidi_session.browsing_context.create(
+        user_context=user_context_1, type_hint="tab"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_context_1["context"], url=test_page, wait="complete"
+    )
+
+    user_context_2 = await create_user_context()
+    new_context_2 = await bidi_session.browsing_context.create(
+        user_context=user_context_2, type_hint="tab"
+    )
+    await bidi_session.browsing_context.navigate(
+        context=new_context_2["context"], url=test_page_cross_origin, wait="complete"
+    )
+
+    cookie_name = "foo_1"
+    cookie_value = "bar_1"
+    await add_cookie(new_context_1["context"], cookie_name, cookie_value)
+
+    # Check that added cookies are present on the right user context.
+    result = await bidi_session.storage.get_cookies(
+        partition=StorageKeyPartitionDescriptor(user_context=user_context_1)
+    )
+    expected_cookies = [
+        {
+            "domain": domain_value(),
+            "httpOnly": False,
+            "name": cookie_name,
+            "path": "/webdriver/tests/support",
+            "sameSite": "none",
+            "secure": False,
+            "size": 10,
+            "value": {"type": "string", "value": cookie_value},
+        }
+    ]
+    recursive_compare(
+        {
+            "cookies": expected_cookies,
+            "partitionKey": {"userContext": user_context_1},
+        },
+        result,
+    )
+
+    # Check that added cookies are not present on the other user context.
+    result = await bidi_session.storage.get_cookies(
+        partition=StorageKeyPartitionDescriptor(user_context=user_context_2)
+    )
+
+    recursive_compare(
+        {
+            "cookies": [],
+            "partitionKey": {"userContext": user_context_2},
+        },
+        result,
+    )
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_expiry.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_expiry.py
index 4e49479a87..7aac38da69 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_expiry.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_expiry.py
@@ -1,5 +1,5 @@
 import pytest
-from .. import assert_cookie_is_not_set, assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_not_set, assert_cookie_is_set, create_cookie, get_default_partition_key
 from datetime import datetime, timedelta
 import time
 
@@ -13,7 +13,7 @@ async def test_cookie_expiry_unset(bidi_session, set_cookie, test_page, domain_v
             expiry=None))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     await assert_cookie_is_set(bidi_session, expiry=None, domain=domain_value())
@@ -29,7 +29,7 @@ async def test_cookie_expiry_future(bidi_session, set_cookie, test_page, domain_
             expiry=tomorrow_timestamp))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     await assert_cookie_is_set(bidi_session, expiry=tomorrow_timestamp, domain=domain_value())
@@ -45,7 +45,7 @@ async def test_cookie_expiry_past(bidi_session, set_cookie, test_page, domain_va
             expiry=yesterday_timestamp))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     await assert_cookie_is_not_set(bidi_session)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_http_only.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_http_only.py
index 4473fbf576..b2155d1ac2 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_http_only.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_http_only.py
@@ -1,5 +1,5 @@
 import pytest
-from .. import assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
 
 pytestmark = pytest.mark.asyncio
 
@@ -16,7 +16,7 @@ async def test_cookie_http_only(bidi_session, set_cookie, test_page, domain_valu
         cookie=create_cookie(domain=domain_value(), http_only=http_only))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     # `httpOnly` defaults to `false`.
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_path.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_path.py
index 727d24348a..70084dee6e 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_path.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_path.py
@@ -1,5 +1,5 @@
 import pytest
-from .. import assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
 
 pytestmark = pytest.mark.asyncio
 
@@ -17,7 +17,7 @@ async def test_cookie_path(bidi_session, test_page, set_cookie, domain_value, pa
     set_cookie_result = await set_cookie(cookie=create_cookie(domain=domain_value(), path=path))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     # `path` defaults to "/".
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_same_site.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_same_site.py
index dfc94c5727..27640bb9a6 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_same_site.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_same_site.py
@@ -1,5 +1,5 @@
 import pytest
-from .. import assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
 
 pytestmark = pytest.mark.asyncio
 
@@ -18,7 +18,7 @@ async def test_cookie_secure(bidi_session, set_cookie, test_page, domain_value,
         cookie=create_cookie(domain=domain_value(), same_site=same_site))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     # `same_site` defaults to "none".
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_secure.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_secure.py
index ef1060cb46..81e462c87c 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_secure.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/cookie_secure.py
@@ -1,5 +1,5 @@
 import pytest
-from .. import assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
 
 pytestmark = pytest.mark.asyncio
 
@@ -17,7 +17,7 @@ async def test_cookie_secure(bidi_session, set_cookie, test_page, domain_value,
         cookie=create_cookie(domain=domain_value(), secure=secure))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     # `secure` defaults to `false`.
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/invalid.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/invalid.py
index 53d2573575..9962d303a1 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/invalid.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/invalid.py
@@ -122,5 +122,9 @@ async def test_partition_storage_key_user_context_invalid_type(set_cookie, test_
     with pytest.raises(error.InvalidArgumentException):
         await set_cookie(cookie=create_cookie(domain=domain_value()), partition=partition)
 
-# TODO: test `test_partition_storage_key_user_context_unknown`.
-# TODO: test `test_partition_storage_key_user_context_invalid_type`.
+
+async def test_partition_storage_key_user_context_invalid_value(set_cookie, domain_value):
+    partition = StorageKeyPartitionDescriptor(user_context="foo")
+
+    with pytest.raises(error.NoSuchUserContextException):
+        await set_cookie(cookie=create_cookie(domain=domain_value()), partition=partition)
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/page_protocols.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/page_protocols.py
index 4cb712b372..295b09c10e 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/page_protocols.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/page_protocols.py
@@ -1,6 +1,6 @@
 import pytest
 from urllib.parse import urlparse
-from .. import assert_cookie_is_set, create_cookie
+from .. import assert_cookie_is_set, create_cookie, get_default_partition_key
 
 pytestmark = pytest.mark.asyncio
 
@@ -18,7 +18,7 @@ async def test_page_protocols(bidi_session, set_cookie, get_test_page, protocol)
     set_cookie_result = await set_cookie(cookie=create_cookie(domain=domain))
 
     assert set_cookie_result == {
-        'partitionKey': {},
+        'partitionKey': (await get_default_partition_key(bidi_session)),
     }
 
     # Assert the cookie is actually set.
diff --git a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/partition.py b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/partition.py
index cb0ace1f40..bb171c6141 100644
--- a/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/partition.py
+++ b/testing/web-platform/tests/webdriver/tests/bidi/storage/set_cookie/partition.py
@@ -1,5 +1,10 @@
 import pytest
-from webdriver.bidi.modules.storage import BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor
+from webdriver.bidi.modules.network import NetworkStringValue
+from webdriver.bidi.modules.script import ContextTarget
+from webdriver.bidi.modules.storage import (
+    BrowsingContextPartitionDescriptor,
+    StorageKeyPartitionDescriptor,
+)
 from .. import assert_cookie_is_set, create_cookie
 from ... import recursive_compare
 
@@ -14,7 +19,7 @@ def assert_set_cookie_result(set_cookie_result, partition):
         # Browsing context does not require a `sourceOrigin` partition key, but it can be present depending on the
         # browser implementation.
         # `recursive_compare` allows the actual result to be any extension of the expected one.
-        recursive_compare({'partitionKey': {}, }, set_cookie_result)
+        recursive_compare({'partitionKey': {"userContext": "default"}, }, set_cookie_result)
         return
     if isinstance(partition, StorageKeyPartitionDescriptor):
         expected_partition_key = {}
@@ -31,13 +36,33 @@ def assert_set_cookie_result(set_cookie_result, partition):
 async def test_partition_context(bidi_session, set_cookie, top_context, test_page, domain_value):
     await bidi_session.browsing_context.navigate(context=top_context["context"], url=test_page, wait="complete")
 
+    cookie_name = "foo"
+    cookie_value = "bar"
     partition = BrowsingContextPartitionDescriptor(top_context["context"])
     set_cookie_result = await set_cookie(
-        cookie=create_cookie(domain=domain_value()),
-        partition=partition)
+        cookie=create_cookie(
+            domain=domain_value(),
+            name=cookie_name,
+            value=NetworkStringValue(cookie_value),
+        ),
+        partition=partition,
+    )
     assert_set_cookie_result(set_cookie_result, partition)
 
-    await assert_cookie_is_set(bidi_session, domain=domain_value())
+    await assert_cookie_is_set(
+        bidi_session,
+        domain=domain_value(),
+        name=cookie_name,
+        value=NetworkStringValue(cookie_value)
+    )
+
+    result = await bidi_session.script.evaluate(
+        expression="document.cookie",
+        target=ContextTarget(top_context["context"]),
+        await_promise=True,
+    )
+
+    assert result == {"type": "string", "value": f"{cookie_name}={cookie_value}"}
 
 
 async def test_partition_context_frame(bidi_session, set_cookie, top_context, test_page, domain_value, inline):
@@ -75,4 +100,19 @@ async def test_partition_storage_key_source_origin(bidi_session, set_cookie, tes
 
     await assert_cookie_is_set(bidi_session, domain=domain_value(), partition=partition)
 
-# TODO: test `test_partition_storage_key_user_context`.
+
+async def test_partition_user_context(
+    bidi_session,
+    domain_value,
+    create_user_context,
+    set_cookie
+):
+    user_context_1 = await create_user_context()
+
+    partition = StorageKeyPartitionDescriptor(user_context=user_context_1)
+    set_cookie_result = await set_cookie(
+        cookie=create_cookie(domain=domain_value()),
+        partition=partition)
+    assert_set_cookie_result(set_cookie_result, partition)
+
+    await assert_cookie_is_set(bidi_session, domain=domain_value(), partition=partition)
diff --git a/testing/web-platform/tests/webdriver/tests/classic/new_session/response.py b/testing/web-platform/tests/webdriver/tests/classic/new_session/response.py
index 43a8d57931..fa8d56c449 100644
--- a/testing/web-platform/tests/webdriver/tests/classic/new_session/response.py
+++ b/testing/web-platform/tests/webdriver/tests/classic/new_session/response.py
@@ -42,3 +42,10 @@ def test_capability_default_value(session, capability, default_value):
     assert isinstance(session.capabilities, dict)
     assert capability in session.capabilities
     assert session.capabilities[capability] == default_value
+
+
+def test_capability_user_agent(session):
+    assert isinstance(session.capabilities, dict)
+    assert "userAgent" in session.capabilities
+    assert type(session.capabilities["userAgent"]) == str
+    assert len(session.capabilities["userAgent"]) > 0
diff --git a/testing/web-platform/tests/webdriver/tests/classic/new_window/new_tab.py b/testing/web-platform/tests/webdriver/tests/classic/new_window/new_tab.py
index f6cacf3c35..53810e7fb6 100644
--- a/testing/web-platform/tests/webdriver/tests/classic/new_window/new_tab.py
+++ b/testing/web-platform/tests/webdriver/tests/classic/new_window/new_tab.py
@@ -1,4 +1,5 @@
 from tests.support.asserts import assert_success
+from tests.support.sync import Poll
 
 from . import opener, window_name
 
@@ -63,7 +64,7 @@ def test_sets_no_opener(session):
     assert opener(session) is None
 
 
-def test_focus_content(session, inline):
+def test_initial_selection_for_contenteditable(session, inline):
     response = new_window(session, type_hint="tab")
     value = assert_success(response)
     assert value["type"] == "tab"
@@ -71,19 +72,26 @@ def test_focus_content(session, inline):
     session.window_handle = value["handle"]
 
     session.url = inline("""
-        <span contenteditable="true"> abc </span>
+        <div contenteditable>abc</div>
         <script>
-            const selection = getSelection();
-            window.onload = async() => {
-                const initial = document.querySelector("span");
-                initial.focus();
+            const initial = document.querySelector("div");
+
+            document.onselectionchange = () => {
+                const selection = document.getSelection();
                 initial.setAttribute(
                     "_focused",
                     selection.anchorNode == initial.firstChild
                 );
-            }
+            };
+
+            initial.focus();
         </script>
     """)
 
-    elem = session.find.css("span", all=False)
-    assert elem.attribute("_focused") == "true"
+    elem = session.find.css("div", all=False)
+
+    wait = Poll(
+        session,
+        timeout=5,
+        message="Initial selection for contenteditable not set")
+    wait.until(lambda _: elem.attribute("_focused") == "true")
diff --git a/testing/web-platform/tests/webdriver/tests/classic/new_window/new_window.py b/testing/web-platform/tests/webdriver/tests/classic/new_window/new_window.py
index d47dacdc08..cc10d2fb86 100644
--- a/testing/web-platform/tests/webdriver/tests/classic/new_window/new_window.py
+++ b/testing/web-platform/tests/webdriver/tests/classic/new_window/new_window.py
@@ -1,4 +1,5 @@
 from tests.support.asserts import assert_success
+from tests.support.sync import Poll
 
 from . import opener, window_name
 
@@ -65,26 +66,33 @@ def test_sets_no_opener(session):
     assert opener(session) is None
 
 
-def test_focus_content(session, inline):
+def test_initial_selection_for_contenteditable(session, inline):
     response = new_window(session, type_hint="window")
     value = assert_success(response)
 
     session.window_handle = value["handle"]
 
     session.url = inline("""
-        <span contenteditable="true"> abc </span>
+        <div contenteditable>abc</div>
         <script>
-            const selection = getSelection();
-            window.onload = async() => {
-                const initial = document.querySelector("span");
-                initial.focus();
+            const initial = document.querySelector("div");
+
+            document.onselectionchange = () => {
+                const selection = document.getSelection();
                 initial.setAttribute(
                     "_focused",
                     selection.anchorNode == initial.firstChild
                 );
-            }
+            };
+
+            initial.focus();
         </script>
     """)
 
-    elem = session.find.css("span", all=False)
-    assert elem.attribute("_focused") == "true"
+    elem = session.find.css("div", all=False)
+
+    wait = Poll(
+        session,
+        timeout=5,
+        message="Initial selection for contenteditable not set")
+    wait.until(lambda _: elem.attribute("_focused") == "true")
diff --git a/testing/web-platform/tests/webdriver/tests/support/fixtures_bidi.py b/testing/web-platform/tests/webdriver/tests/support/fixtures_bidi.py
index 9566e6ebd1..7f3e4f9a9a 100644
--- a/testing/web-platform/tests/webdriver/tests/support/fixtures_bidi.py
+++ b/testing/web-platform/tests/webdriver/tests/support/fixtures_bidi.py
@@ -198,7 +198,7 @@ def add_and_remove_iframe(bidi_session):
                 document.documentElement.lastElementChild.append(iframe);
                 return new Promise(resolve => iframe.onload = () => resolve(id));
             }""",
-            target={"context": context["context"]},
+            target=ContextTarget(context["context"]),
             await_promise=True)
         iframe_dom_id = resp["value"]
 
@@ -210,7 +210,7 @@ def add_and_remove_iframe(bidi_session):
 
         await bidi_session.script.evaluate(
             expression=f"document.getElementById('{iframe_dom_id}').remove()",
-            target={"context": context["context"]},
+            target=ContextTarget(context["context"]),
             await_promise=False)
 
         return frame_id
diff --git a/testing/web-platform/tests/webdriver/tests/support/html/files.html b/testing/web-platform/tests/webdriver/tests/support/html/files.html
new file mode 100644
index 0000000000..be24791844
--- /dev/null
+++ b/testing/web-platform/tests/webdriver/tests/support/html/files.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html>
+  <body>
+    <input id="input" type="file" />
+    <input id="input-multiple" multiple type="file" />
+    <input id="input-disabled" disabled type="file" />
+    <input id="text-input" type="text" />
+    <script>
+      const allEvents = {events: []};
+      const onEvent = (event) => {
+        allEvents.events.push({
+          type: event.type,
+          files: [...event.target.files].map((file) => file.name),
+        });
+      };
+
+      const input = document.getElementById('input');
+      input.addEventListener('input', onEvent);
+      input.addEventListener('change', onEvent);
+      input.addEventListener('cancel', onEvent);
+
+      const multipleInput = document.getElementById('input-multiple');
+      multipleInput.addEventListener('input', onEvent);
+      multipleInput.addEventListener('change', onEvent);
+      multipleInput.addEventListener('cancel', onEvent);
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webdriver/tests/support/http_handlers/cached.py b/testing/web-platform/tests/webdriver/tests/support/http_handlers/cached.py
index a43410f885..ce1dadefa1 100644
--- a/testing/web-platform/tests/webdriver/tests/support/http_handlers/cached.py
+++ b/testing/web-platform/tests/webdriver/tests/support/http_handlers/cached.py
@@ -8,7 +8,14 @@ def main(request, response):
         response.headers.set(b"Location", request.GET.first(b"location"))
 
     response.status = status
-    response.headers.set(b"Content-Type", "text/plain")
+
+
+    if b"contenttype" in request.GET:
+        content_type = request.GET.first(b"contenttype")
+        response.headers.set(b"Content-Type", content_type)
+    else:
+        response.headers.set(b"Content-Type", "text/plain")
+
     response.headers.set(b"Expires", "Thu, 01 Dec 2100 20:00:00 GMT")
     response.headers.set(b"Cache-Control", "max-age=3600")
     return "Cached HTTP Response"