Re: [service-workers-tests] Add tests for service worker inheritance (#4610)

# Firefox (nightly channel) #
Testing web-platform-tests at revision 17682fa67451d68c781c7f4de6520b78ba6c5dba
Using browser at version BuildID 20170123125947; SourceStamp 36486fdc3813ef7943ae5b07b4128866d1938a6c
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/claim-using-registration.https.html">/service-workers/service-worker/claim-using-registration.https.html</a></summary>


|                                        Subtest                                         | Results |
|----------------------------------------------------------------------------------------|---------|
|                                                                                        | OK      |
| `Test for the waiting worker claims a client which is using the the same registration` | PASS    |
| `Test worker claims client which is using another registration`                        | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/claim-not-using-registration.https.html">/service-workers/service-worker/claim-not-using-registration.https.html</a></summary>


|                                           Subtest                                           | Results |
|---------------------------------------------------------------------------------------------|---------|
|                                                                                             | OK      |
| `Test claim client which is not using registration`                                         | PASS    |
| `Test claim client when there's a longer-matched registration not already used by the page` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-byte-streams/general.serviceworker.https.html">/streams/readable-byte-streams/general.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream with byte source: Multiple read(view), close() and respond()`                                                | FAIL    |
| `ReadableStream with byte source: Throwing in pull function must error the stream`                                           | FAIL    |
| `ReadableStream with byte source: Automatic pull() after start()`                                                            | FAIL    |
| `ReadableStream with byte source: Multiple enqueue(), getReader(), then read(view)`                                          | FAIL    |
| `ReadableStream with byte source: read(view), then respond() and close() in pull()`                                          | FAIL    |
| `ReadableStream with byte source: Test that closing a stream does not release a reader automatically`                        | FAIL    |
| `ReadableStream with byte source: A stream must be errored if close()-d before fulfilling read(view) with Uint16Array`       | FAIL    |
| `ReadableStream with byte source: read(view), then respond() with a transferred ArrayBuffer`                                 | FAIL    |
| `ReadableStream with byte source: enqueue() with Uint16Array, getReader(), then read()`                                      | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a smaller views`                              | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view)`                                                   | FAIL    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream with byte source: Test that erroring a stream does not release a reader automatically`                       | FAIL    |
| `ReadableStream with byte source: Respond to pull() by enqueue()`                                                            | FAIL    |
| `ReadableStream with byte source: read() twice, then enqueue() twice`                                                        | FAIL    |
| `ReadableStreamBYOBReader constructor requires a ReadableStream with type "bytes"`                                           | FAIL    |
| `ReadableStream with byte source: releaseLock() on ReadableStreamReader with pending read() must throw`                      | FAIL    |
| `ReadableStreamBYOBReader constructor requires a ReadableStream argument`                                                    | FAIL    |
| `ReadableStream with byte source: Mix of auto allocate and BYOB`                                                             | FAIL    |
| `ReadableStream with byte source: read(view) with Uint16Array on close()-d stream with 1 byte enqueue()-d must fail`         | FAIL    |
| `ReadableStream with byte source: read(view), then respond() with too big value`                                             | FAIL    |
| `ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple respond() calls`                     | FAIL    |
| `ReadableStream with byte source: autoAllocateChunkSize`                                                                     | FAIL    |
| `ReadableStream with byte source: cancel() with partially filled pending pull() request`                                     | FAIL    |
| `ReadableStream with byte source: Construct and expect start and pull being called`                                          | FAIL    |
| `ReadableStream with byte source: read(view), then respond()`                                                                | FAIL    |
| `ReadableStream with byte source: read(view), then error()`                                                                  | FAIL    |
| `ReadableStream with byte source: read(view), but pull() function is not callable`                                           | FAIL    |
| `ReadableStream with byte source: Automatic pull() after start() and read(view)`                                             | FAIL    |
| `ReadableStreamBYOBReader can be constructed directly`                                                                       | FAIL    |
| `ReadableStream with byte source: Throwing in pull in response to read() must be ignored if the stream is errored in it`     | FAIL    |
| `ReadableStream with byte source: read(view) with zero-length view must fail`                                                | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = not BYOB)`                                   | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = BYOB)`                                       | FAIL    |
| `ReadableStream with byte source can be constructed with no errors`                                                          | FAIL    |
| `ReadableStream with byte source: Test that closing a stream does not release a BYOB reader automatically`                   | FAIL    |
| `ReadableStream with byte source: read(), then error()`                                                                      | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read()`                                                       | FAIL    |
| `ReadableStream with byte source: read(), but pull() function is not callable`                                               | FAIL    |
| `getReader({mode: "byob"}) throws on non-bytes streams`                                                                      | FAIL    |
| `ReadableStream with byte source: respond(3) to read(view) with 2 element Uint16Array enqueues the 1 byte remainder`         | FAIL    |
| `ReadableStream with byte source: enqueue() 1 byte, getReader(), then read(view) with Uint16Array`                           | FAIL    |
| `ReadableStream with byte source: enqueue() 3 byte, getReader(), then read(view) with 2-element Uint16Array`                 | FAIL    |
| `ReadableStream with byte source: Automatic pull() after start() and read()`                                                 | FAIL    |
| `ReadableStream with byte source: Throw if close()-ed more than once`                                                        | FAIL    |
| `ReadableStream with byte source: getReader(), read(view), then cancel()`                                                    | FAIL    |
| `ReadableStream with byte source: Throwing in pull in response to read(view) must be ignored if the stream is errored in it` | FAIL    |
| `ReadableStream with byte source: getReader() with mode set to byob, then releaseLock()`                                     | FAIL    |
| `ReadableStream with byte source: getReader(), enqueue(), close(), then read()`                                              | FAIL    |
| `ReadableStream with byte source: Throwing in pull in response to read(view) function must error the stream`                 | FAIL    |
| `ReadableStream with byte source: getReader(), then releaseLock()`                                                           | FAIL    |
| `ReadableStreamBYOBReader constructor requires an unlocked ReadableStream`                                                   | FAIL    |
| `ReadableStream with byte source: Even read(view) with passing ArrayBufferView like object as view must fail`                | FAIL    |
| `ReadableStream with byte source: enqueue(), close(), getReader(), then read()`                                              | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a bigger view`                                | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) where view.buffer is not fully covered by view`    | FAIL    |
| `ReadableStream with byte source: read() on an errored stream`                                                               | FAIL    |
| `ReadableStream with byte source: Push source that doesn't understand pull signal`                                           | FAIL    |
| `ReadableStream with byte source: Throw on enqueue() after close()`                                                          | FAIL    |
| `ReadableStream with byte source: read(view) with passing an empty object as view must fail`                                 | FAIL    |
| `ReadableStream with byte source: Multiple read(view), big enqueue()`                                                        | FAIL    |
| `ReadableStream with byte source: Construct with highWaterMark of 0`                                                         | FAIL    |
| `ReadableStream with byte source: Respond to pull() by enqueue() asynchronously`                                             | FAIL    |
| `ReadableStream with byte source: Multiple read(view) and multiple enqueue()`                                                | FAIL    |
| `ReadableStream with byte source: Test that erroring a stream does not release a BYOB reader automatically`                  | FAIL    |
| `ReadableStream with byte source: read(view) with passing undefined as view must fail`                                       | FAIL    |
| `ReadableStream with byte source: read(view) on an errored stream`                                                           | FAIL    |
| `ReadableStream with byte source: enqueue(), read(view) partially, then read()`                                              | FAIL    |
| `ReadableStream with byte source: No automatic pull call if start doesn't finish`                                            | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/multiple-propagation.serviceworker.https.html">/streams/piping/multiple-propagation.serviceworker.https.html</a></summary>


|                                           Subtest                                           | Results |
|---------------------------------------------------------------------------------------------|---------|
|                                                                                             | OK      |
| `Piping from an errored readable stream to a closed writable stream`                        | FAIL    |
| `Piping from a closed readable stream to a closed writable stream`                          | FAIL    |
| `Piping from a closed readable stream to an errored writable stream`                        | FAIL    |
| `Piping from an errored readable stream to an errored writable stream`                      | FAIL    |
| `Service worker test setup`                                                                 | PASS    |
| `Piping from an errored readable stream to an errored writable stream; preventAbort = true` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration-service-worker-attributes.https.html">/service-workers/service-worker/registration-service-worker-attributes.https.html</a></summary>


|                    Subtest                     | Results |
|------------------------------------------------|---------|
|                                                | OK      |
| `installing/waiting/active after registration` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-closed-window.https.html">/service-workers/service-worker/register-closed-window.https.html</a></summary>


|                               Subtest                               | Results |
|---------------------------------------------------------------------|---------|
|                                                                     | OK      |
| `Call register() on ServiceWorkerContainer owned by closed window.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/aborting.serviceworker.https.html">/streams/writable-streams/aborting.serviceworker.https.html</a></summary>


|                                                                     Subtest                                                                     | Results |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                 | OK      |
| `underlying abort() should not be called until underlying write() completes`                                                                    | FAIL    |
| `.closed should not resolve before fulfilled write()`                                                                                           | FAIL    |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects`                                                             | FAIL    |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)`                                                   | FAIL    |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects`                      | FAIL    |
| `close() should use error from underlying write() on abort`                                                                                     | FAIL    |
| `underlying abort() should not be called if underlying close() has started`                                                                     | FAIL    |
| `Aborting a WritableStream passes through the given reason`                                                                                     | FAIL    |
| `underlying abort() should be called while closing if underlying close() has not started yet`                                                   | FAIL    |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one`                                        | FAIL    |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error`                                                   | FAIL    |
| `writer.ready should reject on controller error without waiting for underlying write`                                                           | FAIL    |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError`                                             | FAIL    |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL    |
| `writer.abort(), controller.error() while there is a pending write, and then finish the write`                                                  | FAIL    |
| `Aborting a WritableStream prevents further writes after any that are in progress`                                                              | FAIL    |
| `writes should be satisfied in order when aborting`                                                                                             | FAIL    |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error`                                              | FAIL    |
| `Aborting a WritableStream immediately prevents future writes`                                                                                  | FAIL    |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject`                                        | FAIL    |
| `controller.error(), writer.abort() while there is a pending write, and then finish the write`                                                  | FAIL    |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value`                              | FAIL    |
| `writes should be satisfied in order after rejected write when aborting`                                                                        | FAIL    |
| `releaseLock() while aborting should reject the original closed promise`                                                                        | FAIL    |
| `releaseLock() during delayed async abort() should create a new rejected closed promise`                                                        | FAIL    |
| `writer.abort() while there is a pending write, and then finish the write with rejection`                                                       | FAIL    |
| `returning a thenable from abort() should work`                                                                                                 | FAIL    |
| `abort() on a released writer rejects`                                                                                                          | FAIL    |
| `Closing a WritableStream and aborting it while it closes causes the stream to error`                                                           | FAIL    |
| `Aborting a WritableStream after it is closed is a no-op`                                                                                       | FAIL    |
| `writer close() promise should resolve before abort() promise`                                                                                  | FAIL    |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects`                                                         | FAIL    |
| `Closing but then immediately aborting a WritableStream causes the stream to error`                                                             | FAIL    |
| `Service worker test setup`                                                                                                                     | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/flow-control.serviceworker.https.html">/streams/piping/flow-control.serviceworker.https.html</a></summary>


|                                                                                        Subtest                                                                                         | Results |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                                        | OK      |
| `Piping to a WritableStream that does not consume the writes fast enough exerts backpressure on the ReadableStream`                                                                    | FAIL    |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks, but then does`                                                                              | FAIL    |
| `Service worker test setup`                                                                                                                                                            | PASS    |
| `Piping from an empty ReadableStream into a WritableStream that does not desire chunks, but then the readable stream becomes non-empty and the writable stream starts desiring chunks` | FAIL    |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks`                                                                                             | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-default-scope.https.html">/service-workers/service-worker/register-default-scope.https.html</a></summary>


|      Subtest      | Results |
|-------------------|---------|
|                   | OK      |
| `default scope`   | PASS    |
| `null scope`      | PASS    |
| `undefined scope` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/service-worker-csp-default.https.html">/service-workers/service-worker/service-worker-csp-default.https.html</a></summary>


|                        Subtest                         | Results |
|--------------------------------------------------------|---------|
|                                                        | OK      |
| `CSP test for default-src in ServiceWorkerGlobalScope` | PASS    |
| `Fetch test for default-src`                           | FAIL    |
| `Redirected fetch test for default-src`                | FAIL    |
| `importScripts test for default-src`                   | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-put.https.html">/service-workers/cache-storage/serviceworker/cache-put.https.html</a></summary>


|                                  Subtest                                  | Results |
|---------------------------------------------------------------------------|---------|
|                                                                           | OK      |
| `Cache.put with a non-GET request`                                        | PASS    |
| `Cache.put should store Response.redirect() correctly`                    | PASS    |
| `Cache.put with Response without a body`                                  | PASS    |
| `Cache.put with Request without a body`                                   | PASS    |
| `Cache.put called twice with matching Requests and different Responses`   | PASS    |
| `Cache.put with a VARY:* Response`                                        | PASS    |
| `Cache.put called with Request and Response from fetch()`                 | PASS    |
| `getReader() after Cache.put`                                             | PASS    |
| `Cache.put called with simple Request and Response`                       | PASS    |
| `Cache.put`                                                               | PASS    |
| `Cache.put with 206 response`                                             | FAIL    |
| `Cache.put with a non-HTTP/HTTPS request`                                 | PASS    |
| `Cache.put with a POST request`                                           | PASS    |
| `Cache.put with HTTP 500 response`                                        | PASS    |
| `Cache.put called twice with request URLs that differ only by a fragment` | PASS    |
| `Cache.put with an invalid response`                                      | PASS    |
| `Cache.put with an embedded VARY:* Response`                              | PASS    |
| `Cache.put with a string request`                                         | PASS    |
| `Cache.put with a used response body`                                     | PASS    |
| `Cache.put with a Response containing an empty URL`                       | PASS    |
| `Cache.put with a relative URL`                                           | PASS    |
| `Cache.put with a null response`                                          | PASS    |
| `Cache.put with an empty response body`                                   | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/skip-waiting-without-client.https.html">/service-workers/service-worker/skip-waiting-without-client.https.html</a></summary>


|                       Subtest                       | Results |
|-----------------------------------------------------|---------|
|                                                     | OK      |
| `Test single skipWaiting() when no client attached` | PASS    |
| `skipWaiting`                                       | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/xhr.https.html">/service-workers/service-worker/xhr.https.html</a></summary>


|           Subtest           | Results |
|-----------------------------|---------|
|                             | OK      |
| `Verify XHR does not exist` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event.https.html">/service-workers/service-worker/fetch-event.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `Service Worker responds to fetch event with the referrer URL`               | PASS    |
| `Service Worker responds to fetch event with null response body`             | PASS    |
| `Service Worker responds to fetch event with the referrer policy`            | PASS    |
| `Service Worker fetches other file in fetch event`                           | PASS    |
| `Multiple calls of respondWith must throw InvalidStateErrors`                | PASS    |
| `Service Worker responds to fetch event with the correct integrity_metadata` | PASS    |
| `Service Worker event.respondWith must set the used flag`                    | PASS    |
| `Service Worker responds to fetch event with POST form`                      | PASS    |
| `Service Worker responds to fetch event with string`                         | PASS    |
| `Service Worker must not expose FetchEvent URL fragments.`                   | PASS    |
| `Service Worker responds to fetch event with an existing client id`          | PASS    |
| `Service Worker responds to fetch event with blob body`                      | PASS    |
| `Service Worker responds to fetch event with the correct cache types`        | PASS    |
| `Service Worker should intercept EventSource`                                | PASS    |
| `Service Worker does not respond to fetch event`                             | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-redirect.https.html">/service-workers/service-worker/fetch-request-redirect.https.html</a></summary>


|                                       Subtest                                       | Results |
|-------------------------------------------------------------------------------------|---------|
|                                                                                     | OK      |
| `Verify redirect mode of Fetch API and ServiceWorker FetchEvent.`                   | PASS    |
| `Verify redirected of Response(Fetch API), Cache API and ServiceWorker FetchEvent.` | PASS    |
| `Verify redirected of Response(Fetch API) and ServiceWorker FetchEvent.`            | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-wait-forever-in-install-worker.https.html">/service-workers/service-worker/register-wait-forever-in-install-worker.https.html</a></summary>


|                                        Subtest                                         | Results |
|----------------------------------------------------------------------------------------|---------|
|                                                                                        | OK      |
| `register worker that calls waitUntil with a promise that never resolves in oninstall` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/invalid-blobtype.https.html">/service-workers/service-worker/invalid-blobtype.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Verify the response of FetchEvent using XMLHttpRequest` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/referer.https.html">/service-workers/service-worker/referer.https.html</a></summary>


|       Subtest        | Results |
|----------------------|---------|
|                      | OK      |
| `Verify the referer` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/skip-waiting-installed.https.html">/service-workers/service-worker/skip-waiting-installed.https.html</a></summary>


|                        Subtest                        | Results |
|-------------------------------------------------------|---------|
|                                                       | OK      |
| `Test skipWaiting when a installed worker is waiting` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/cancel.serviceworker.https.html">/streams/readable-streams/cancel.serviceworker.https.html</a></summary>


|                                                                                   Subtest                                                                                    | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                              | OK      |
| `ReadableStream cancellation: integration test on an infinite stream derived from a random push source`                                                                      | FAIL    |
| `ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source`                                                                  | FAIL    |
| `ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called`                                                                      | FAIL    |
| `ReadableStream cancellation: returning a value from the underlying source's cancel should not affect the fulfillment value of the promise returned by the stream's cancel`  | FAIL    |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should reject when that one does`      | FAIL    |
| `ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel`                                                             | FAIL    |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (2)` | FAIL    |
| `Service worker test setup`                                                                                                                                                  | PASS    |
| `ReadableStream cancellation: should fulfill promise when cancel callback went fine`                                                                                         | FAIL    |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (1)` | FAIL    |
| `ReadableStream cancellation: should reject promise when cancel callback raises an exception`                                                                                | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration.https.html">/service-workers/service-worker/registration.https.html</a></summary>


|                                 Subtest                                 | Results |
|-------------------------------------------------------------------------|---------|
|                                                                         | OK      |
| `Registering script importing non-existent script`                      | PASS    |
| `Registering redirected script`                                         | PASS    |
| `Registering scope with fragment`                                       | PASS    |
| `Registering script including caught exception`                         | PASS    |
| `Registering script including parse error`                              | PASS    |
| `Registration scope outside the script directory`                       | PASS    |
| `Registering scope outside domain`                                      | PASS    |
| `Scope including URL-encoded backslash`                                 | PASS    |
| `Registering same scope as the script directory`                        | PASS    |
| `Registering script outside domain`                                     | PASS    |
| `Scope including self-reference`                                        | PASS    |
| `Script URL is same-origin filesystem: URL`                             | PASS    |
| `Registering normal scope`                                              | PASS    |
| `Registering script with bad MIME type`                                 | PASS    |
| `Scope including non-escaped multibyte characters`                      | PASS    |
| `Registering invalid chunked encoding script with flush`                | PASS    |
| `Registering non-existent script`                                       | PASS    |
| `Script URL including URL-encoded backslash`                            | PASS    |
| `Registering same scope as the script directory without the last slash` | PASS    |
| `Script URL including uppercase URL-encoded slash`                      | PASS    |
| `Registering script with no MIME type`                                  | PASS    |
| `Scope including URL-encoded slash`                                     | PASS    |
| `Registering script including undefined error`                          | PASS    |
| `Scope including consecutive slashes`                                   | PASS    |
| `Scope including URL-encoded multibyte characters`                      | PASS    |
| `Registering invalid chunked encoding script`                           | PASS    |
| `Script URL including URL-encoded slash`                                | PASS    |
| `Script URL including consecutive slashes`                              | PASS    |
| `Registering script including uncaught exception`                       | PASS    |
| `Script URL including parent-reference`                                 | PASS    |
| `Script URL including uppercase URL-encoded backslash`                  | PASS    |
| `Scope URL is same-origin filesystem: URL`                              | PASS    |
| `Scope including parent-reference`                                      | PASS    |
| `Script URL including self-reference`                                   | PASS    |
| `Scope including parent-reference and not under the script directory`   | PASS    |
| `Registering script importing malformed script`                         | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/activation-after-registration.https.html">/service-workers/service-worker/activation-after-registration.https.html</a></summary>


|                Subtest                 | Results |
|----------------------------------------|---------|
|                                        | OK      |
| `activation occurs after registration` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/error-propagation-backward.serviceworker.https.html">/streams/piping/error-propagation-backward.serviceworker.https.html</a></summary>


|                                                                          Subtest                                                                           | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                            | OK      |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true, preventAbort = true, preventClose = true`           | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel =  (falsy); fulfilled cancel promise`                       | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 0 (falsy); fulfilled cancel promise`                      | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = -0 (falsy); fulfilled cancel promise`                     | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel = true`                                                     | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; fulfilled cancel promise`               | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; fulfilled cancel promise`                                        | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 1 (truthy)`                                               | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; fulfilled cancel promise`             | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = a (truthy)`                                               | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; rejected cancel promise`                           | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = undefined (falsy); fulfilled cancel promise`              | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = null (falsy); fulfilled cancel promise`                   | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; rejected cancel promise`                | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true (truthy)`                                            | FAIL    |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; fulfilled cancel promise`                             | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = false (falsy); fulfilled cancel promise`                  | FAIL    |
| `Errors must be propagated backward: starts errored; preventCancel omitted; fulfilled cancel promise`                                                      | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = NaN (falsy); fulfilled cancel promise`                    | FAIL    |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel omitted (but cancel is never called)` | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write, preventCancel = true; preventAbort = true`                                | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; rejected cancel promise`                           | FAIL    |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel = true`                               | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; rejected cancel promise`              | FAIL    |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; rejected cancel promise`                              | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; fulfilled cancel promise`                          | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = true`                                        | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = Symbol() (truthy)`                                        | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; rejected cancel promise`                                         | FAIL    |
| `Errors must be propagated backward: becomes errored after piping; preventCancel = true`                                                                   | FAIL    |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel = true`                                                        | FAIL    |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = true`                                          | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = [object Object] (truthy)`                                 | FAIL    |
| `Errors must be propagated backward: erroring via the controller errors once pending write completes`                                                      | FAIL    |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; fulfilled cancel promise`                          | FAIL    |
| `Service worker test setup`                                                                                                                                | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-link-header.https.html">/service-workers/service-worker/register-link-header.https.html</a></summary>


|                        Subtest                         | Results |
|--------------------------------------------------------|---------|
|                                                        | TIMEOUT |
| `fetch can trigger service worker installation`        | TIMEOUT |
| `A stylesheet can trigger service worker installation` | NOTRUN  |
| `An iframe can trigger service worker installation`    | NOTRUN  |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event-async-respond-with.https.html">/service-workers/service-worker/fetch-event-async-respond-with.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Calling respondWith asynchronously throws an exception` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/foreign-fetch-basics.https.html">/service-workers/service-worker/foreign-fetch-basics.https.html</a></summary>


|                                  Subtest                                  | Results |
|---------------------------------------------------------------------------|---------|
|                                                                           | TIMEOUT |
| `Foreign fetch can intercept fetch requests from SW controlled pages.`    | FAIL    |
| `Service Worker does not intercept fetches from an insecure context.`     | NOTRUN  |
| `Service Worker doesn't intercept fetches with non matching origin.`      | PASS    |
| `Referrer and origin are set correctly in ForeignFetchEvent.`             | NOTRUN  |
| `Service Worker intercepts fetches in scope with wildcard origin.`        | FAIL    |
| `Service Worker intercepts fetches in scope with explicit origin.`        | FAIL    |
| `Service Worker intercepts fetches in scope with explicit origin list.`   | FAIL    |
| `Service Worker does not intercept fetches with CORS preflight`           | NOTRUN  |
| `Service Worker does not intercept same origin fetches.`                  | PASS    |
| `Falling back to network should still respect CORS.`                      | PASS    |
| `Foreign fetch rejects if resolved with a null response.`                 | NOTRUN  |
| `Service Worker does not intercept navigations.`                          | PASS    |
| `Foreign fetch can intercept resource requests from SW controlled pages.` | TIMEOUT |
| `Service Worker that fallback to network should fallback to network.`     | PASS    |
| `Service Worker that fetch from the network should fallback to network.`  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/clients-matchall-client-types.https.html">/service-workers/service-worker/clients-matchall-client-types.https.html</a></summary>


|                    Subtest                    | Results |
|-----------------------------------------------|---------|
|                                               | OK      |
| `Verify matchAll() with various client types` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/getregistrations.https.html">/service-workers/service-worker/getregistrations.https.html</a></summary>


|                                 Subtest                                  | Results |
|--------------------------------------------------------------------------|---------|
|                                                                          | OK      |
| `getRegistrations promise resolves only with same origin registrations.` | PASS    |
| `Register then Unregister with controlled frame then getRegistrations`   | PASS    |
| `Register multiple times then getRegistrations`                          | PASS    |
| `Register then getRegistrations`                                         | PASS    |
| `getRegistrations`                                                       | PASS    |
| `Purge the existing registrations.`                                      | PASS    |
| `Register then Unregister then getRegistrations`                         | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/controller-on-reload.https.html">/service-workers/service-worker/controller-on-reload.https.html</a></summary>


|                      Subtest                       | Results |
|----------------------------------------------------|---------|
|                                                    | OK      |
| `controller is set upon reload after registration` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-delete.https.html">/service-workers/cache-storage/serviceworker/cache-delete.https.html</a></summary>


|                   Subtest                   | Results |
|---------------------------------------------|---------|
|                                             | OK      |
| `Cache.delete with no arguments`            | PASS    |
| `Cache.delete called with a Request object` | PASS    |
| `Cache.delete with a non-existent entry`    | PASS    |
| `Cache.delete`                              | PASS    |
| `Cache.delete called with a HEAD request`   | PASS    |
| `Cache.delete called with a string URL`     | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/skip-waiting-using-registration.https.html">/service-workers/service-worker/skip-waiting-using-registration.https.html</a></summary>


|                           Subtest                           | Results |
|-------------------------------------------------------------|---------|
|                                                             | OK      |
| `Test skipWaiting while a client is using the registration` | PASS    |
| `skipWaiting`                                               | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/interfaces.https.html">/service-workers/service-worker/interfaces.https.html</a></summary>


|                         Subtest                         | Results |
|---------------------------------------------------------|---------|
|                                                         | OK      |
| `Cache`                                                 | PASS    |
| `Interfaces and attributes of ServiceWorkerContainer`   | PASS    |
| `Interfaces and attributes of ServiceWorker`            | PASS    |
| `CacheStorage`                                          | PASS    |
| `Clients`                                               | PASS    |
| `Event constructors`                                    | PASS    |
| `Interfaces and attributes in ServiceWorkerGlobalScope` | PASS    |
| `Client`                                                | PASS    |
| `WindowClient`                                          | PASS    |
| `ServiceWorkerGlobalScope`                              | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/state.https.html">/service-workers/service-worker/state.https.html</a></summary>


|                         Subtest                         | Results |
|---------------------------------------------------------|---------|
|                                                         | OK      |
| `Service Worker state property and "statechange" event` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/ServiceWorkerGlobalScope/update.https.html">/service-workers/service-worker/ServiceWorkerGlobalScope/update.https.html</a></summary>


|                       Subtest                       | Results |
|-----------------------------------------------------|---------|
|                                                     | OK      |
| `Update a registration on ServiceWorkerGlobalScope` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/close-propagation-forward.serviceworker.https.html">/streams/piping/close-propagation-forward.serviceworker.https.html</a></summary>


|                                                                    Subtest                                                                    | Results |
|-----------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                               | OK      |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; fulfilled close promise`                            | FAIL    |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose = true`                                                     | FAIL    |
| `Service worker test setup`                                                                                                                   | PASS    |
| `Closing must be propagated forward: starts closed; preventClose = 1 (truthy)`                                                                | FAIL    |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; rejected close promise`                             | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose omitted; rejected close promise`                                             | FAIL    |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; rejected close promise`  | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = Symbol() (truthy)`                                                         | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true`                                                 | FAIL    |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose = true`                                                      | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = true (truthy)`                                                             | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = false (falsy); fulfilled close promise`                                    | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true, preventCancel = true`                           | FAIL    |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose = true`                           | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = -0 (falsy); fulfilled close promise`                                       | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = undefined (falsy); fulfilled close promise`                                | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = [object Object] (truthy)`                                                  | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = NaN (falsy); fulfilled close promise`                                      | FAIL    |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; fulfilled close promise` | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = a (truthy)`                                                                | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose omitted; fulfilled close promise`                                            | FAIL    |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; rejected close promise`                            | FAIL    |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; fulfilled close promise`                           | FAIL    |
| `Closing must be propagated forward: shutdown must not occur until the final write completes`                                                 | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = 0 (falsy); fulfilled close promise`                                        | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose =  (falsy); fulfilled close promise`                                         | FAIL    |
| `Closing must be propagated forward: starts closed; preventClose = null (falsy); fulfilled close promise`                                     | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-xhr.https.html">/service-workers/service-worker/fetch-request-xhr.https.html</a></summary>


|                       Subtest                        | Results |
|------------------------------------------------------|---------|
|                                                      | OK      |
| `Verify the body of FetchEvent using XMLHttpRequest` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/html/webappapis/scripting/events/messageevent-constructor.https.html">/html/webappapis/scripting/events/messageevent-constructor.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `initMessageEvent operation`                             | PASS    |
| `Passing null for ports member`                          | PASS    |
| `All parameters to initMessageEvent should be mandatory` | PASS    |
| `Default event values`                                   | PASS    |
| `ports attribute should be a FrozenArray`                | PASS    |
| `MessageEventInit dictionary`                            | PASS    |
| `Passing null for ports parameter to initMessageEvent`   | PASS    |
| `Passing ServiceWorker for source member`                | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/bad-strategies.serviceworker.https.html">/streams/writable-streams/bad-strategies.serviceworker.https.html</a></summary>


|                          Subtest                          | Results |
|-----------------------------------------------------------|---------|
|                                                           | OK      |
| `reject any non-function value for strategy.size`         | FAIL    |
| `Writable stream: invalid strategy.size return value`     | FAIL    |
| `Writable stream: invalid strategy.highWaterMark`         | FAIL    |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL    |
| `Writable stream: throwing strategy.size method`          | FAIL    |
| `Service worker test setup`                               | PASS    |
| `Writable stream: throwing strategy.size getter`          | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/controller-on-load.https.html">/service-workers/service-worker/controller-on-load.https.html</a></summary>


|                    Subtest                    | Results |
|-----------------------------------------------|---------|
|                                               | OK      |
| `controller is set for a controlled document` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/request-end-to-end.https.html">/service-workers/service-worker/request-end-to-end.https.html</a></summary>


|        Subtest        | Results |
|-----------------------|---------|
|                       | OK      |
| `Request: end-to-end` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/credentials.https.html">/service-workers/cache-storage/serviceworker/credentials.https.html</a></summary>


|                  Subtest                  | Results |
|-------------------------------------------|---------|
|                                           | OK      |
| `Cache API matching includes credentials` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/transform-streams.serviceworker.https.html">/streams/piping/transform-streams.serviceworker.https.html</a></summary>


|                                              Subtest                                              | Results |
|---------------------------------------------------------------------------------------------------|---------|
|                                                                                                   | OK      |
| `Service worker test setup`                                                                       | PASS    |
| `Piping through an identity transform stream should close the destination when the source closes` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/write.serviceworker.https.html">/streams/writable-streams/write.serviceworker.https.html</a></summary>


|                                                        Subtest                                                         | Results |
|------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                        | OK      |
| `fulfillment value of ws.write() call should be undefined even if the underlying sink returns a non-undefined value`   | FAIL    |
| `WritableStream should complete asynchronous writes before close resolves`                                             | FAIL    |
| `returning a thenable from write() should work`                                                                        | FAIL    |
| `WritableStream should complete synchronous writes before close resolves`                                              | FAIL    |
| `writer.write(), ready and closed reject with the error passed to controller.error() made before sink.write rejection` | FAIL    |
| `when sink's write throws an error, the stream should become errored and the promise should reject`                    | FAIL    |
| `WritableStream should transition to waiting until write is acknowledged`                                              | FAIL    |
| `Service worker test setup`                                                                                            | PASS    |
| `WritableStreamDefaultWriter should work when manually constructed`                                                    | FAIL    |
| `a large queue of writes should be processed completely`                                                               | FAIL    |
| `when write returns a rejected promise, queued writes and close should be cleared`                                     | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html">/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html</a></summary>


|                                     Subtest                                     | Results |
|---------------------------------------------------------------------------------|---------|
|                                                                                 | OK      |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 4)` | FAIL    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 1)` | FAIL    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 0)` | FAIL    |
| `Service worker test setup`                                                     | PASS    |
| `Can construct a readable stream with a valid CountQueuingStrategy`             | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-storage.https.html">/service-workers/cache-storage/serviceworker/cache-storage.https.html</a></summary>


|                      Subtest                       | Results |
|----------------------------------------------------|---------|
|                                                    | OK      |
| `CacheStorage.open with an empty name`             | PASS    |
| `CacheStorage.open with no arguments`              | PASS    |
| `CacheStorage names are DOMStrings not USVStrings` | PASS    |
| `CacheStorage`                                     | PASS    |
| `CacheStorage.has with existing cache`             | PASS    |
| `CacheStorage.delete with nonexistent cache`       | PASS    |
| `CacheStorage.open`                                | PASS    |
| `CacheStorage.has with nonexistent cache`          | PASS    |
| `CacheStorage.open with existing cache`            | PASS    |
| `CacheStorage.delete with existing cache`          | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-same-scope-different-script-url.https.html">/service-workers/service-worker/register-same-scope-different-script-url.https.html</a></summary>


|                          Subtest                          | Results |
|-----------------------------------------------------------|---------|
|                                                           | OK      |
| `Register same-scope new script url effect on controller` | PASS    |
| `Register different scripts concurrently`                 | PASS    |
| `Register then register new script URL`                   | PASS    |
| `Register then register new script that does not install` | PASS    |
| `Register then register new script URL that 404s`         | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-cors-xhr.https.html">/service-workers/service-worker/fetch-cors-xhr.https.html</a></summary>


|                     Subtest                      | Results |
|--------------------------------------------------|---------|
|                                                  | OK      |
| `Verify CORS XHR of fetch() in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/postmessage.https.html">/service-workers/service-worker/postmessage.https.html</a></summary>


|                           Subtest                           | Results |
|-------------------------------------------------------------|---------|
|                                                             | OK      |
| `postMessage to a ServiceWorker (and back via MessagePort)` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/bad-strategies.serviceworker.https.html">/streams/readable-streams/bad-strategies.serviceworker.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `Readable stream: throwing strategy.highWaterMark getter`                    | FAIL    |
| `Readable stream: strategy.size errors the stream and then throws`           | FAIL    |
| `Readable stream: throwing strategy.size method`                             | FAIL    |
| `Readable stream: throwing strategy.size getter`                             | FAIL    |
| `Service worker test setup`                                                  | PASS    |
| `Readable stream: invalid strategy.highWaterMark`                            | FAIL    |
| `Readable stream: invalid strategy.size return value`                        | FAIL    |
| `Readable stream: strategy.size errors the stream and then returns Infinity` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event-network-error.https.html">/service-workers/service-worker/fetch-event-network-error.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `Rejecting the fetch event or using preventDefault() causes a network error` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/navigation-redirect.https.html">/service-workers/service-worker/navigation-redirect.https.html</a></summary>


|                                              Subtest                                               | Results |
|----------------------------------------------------------------------------------------------------|---------|
|                                                                                                    | OK      |
| `Redirect to other-origin in-scope with opaque redirect response which is passed through Cache.`   | PASS    |
| `SW-fetched redirect to other-origin in-scope.`                                                    | PASS    |
| `SW-generated redirect to same-origin other-scope.`                                                | PASS    |
| `Redirect to same-origin other-scope with opaque redirect response.`                               | PASS    |
| `Redirect to other-origin out-scope with opaque redirect response.`                                | PASS    |
| `Normal redirect to same-origin scope.`                                                            | PASS    |
| `SW-generated redirect to other-origin in-scope.`                                                  | PASS    |
| `Redirect to same-origin same-scope with opaque redirect response.`                                | PASS    |
| `Redirect to same-origin out-scope with opaque redirect response.`                                 | PASS    |
| `SW-fallbacked redirect to same-origin other-scope.`                                               | PASS    |
| `SW-generated redirect to other-origin out-scope.`                                                 | PASS    |
| `SW-fallbacked redirect to other-origin out-scope.`                                                | PASS    |
| `Redirect to same-origin out-scope with opaque redirect response which is passed through Cache.`   | PASS    |
| `SW-generated redirect to same-origin out-scope.`                                                  | PASS    |
| `Redirect to other-origin out-scope with opaque redirect response which is passed through Cache.`  | PASS    |
| `SW-fallbacked redirect to same-origin out-scope.`                                                 | PASS    |
| `Normal redirect to other-origin scope.`                                                           | PASS    |
| `Redirect to same-origin same-scope with opaque redirect response which is passed through Cache.`  | PASS    |
| `SW-fallbacked redirect to same-origin same-scope.`                                                | PASS    |
| `SW-fallbacked redirect to other-origin in-scope.`                                                 | PASS    |
| `SW-fetched redirect to same-origin same-scope.`                                                   | PASS    |
| `Redirect to other-origin in-scope with opaque redirect response.`                                 | PASS    |
| `SW-generated redirect to same-origin same-scope.`                                                 | PASS    |
| `SW-fetched redirect to same-origin other-scope.`                                                  | PASS    |
| `SW-fetched redirect to same-origin out-scope.`                                                    | PASS    |
| `Redirect to same-origin other-scope with opaque redirect response which is passed through Cache.` | PASS    |
| `SW-fetched redirect to other-origin out-scope.`                                                   | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/activate-event-after-install-state-change.https.html">/service-workers/service-worker/activate-event-after-install-state-change.https.html</a></summary>


|                              Subtest                               | Results |
|--------------------------------------------------------------------|---------|
|                                                                    | OK      |
| `installed event should be fired before activating service worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/synced-state.https.html">/service-workers/service-worker/synced-state.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `worker objects for the same entity have the same state` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/ready.https.html">/service-workers/service-worker/ready.https.html</a></summary>


|                                 Subtest                                 | Results |
|-------------------------------------------------------------------------|---------|
|                                                                         | OK      |
| `ready returns the same Promise object`                                 | PASS    |
| `ready on a controlled document`                                        | PASS    |
| `ready returns a Promise object in the context of the related document` | PASS    |
| `access ready after it has been resolved`                               | PASS    |
| `ready on a potential controlled document`                              | PASS    |
| `ready after a longer matched registration registered`                  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/install-event-type.https.html">/service-workers/service-worker/install-event-type.https.html</a></summary>


|       Subtest        | Results |
|----------------------|---------|
|                      | OK      |
| `install event type` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/service-worker-csp-script.https.html">/service-workers/service-worker/service-worker-csp-script.https.html</a></summary>


|                        Subtest                        | Results |
|-------------------------------------------------------|---------|
|                                                       | OK      |
| `Redirected fetch test for script-src`                | PASS    |
| `importScripts test for script-src`                   | FAIL    |
| `Fetch test for script-src`                           | PASS    |
| `CSP test for script-src in ServiceWorkerGlobalScope` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-resources.https.html">/service-workers/service-worker/fetch-request-resources.https.html</a></summary>


|              Subtest               | Results |
|------------------------------------|---------|
|                                    | OK      |
| `Verify FetchEvent for resources.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/client-navigate.https.html">/service-workers/service-worker/client-navigate.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Return value should be instance of WindowClient`        | PASS    |
| `Navigating to about:blank should reject with TypeError` | PASS    |
| `Frame location should update on successful navigation`  | PASS    |
| `Frame location should not be accessible after redirect` | PASS    |
| `Redirecting to another origin should resolve with null` | PASS    |
| `Frame location should not update on failed navigation`  | PASS    |
| `Navigating to different origin should reject`           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-fallback.https.html">/service-workers/service-worker/fetch-request-fallback.https.html</a></summary>


|                   Subtest                    | Results |
|----------------------------------------------|---------|
|                                              | OK      |
| `Verify the fallback behavior of FetchEvent` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/unregister-then-register.https.html">/service-workers/service-worker/unregister-then-register.https.html</a></summary>


|                                         Subtest                                          | Results |
|------------------------------------------------------------------------------------------|---------|
|                                                                                          | OK      |
| `Unregister then register resolves to a new value`                                       | PASS    |
| `Unregister then register does not affect existing controllee`                           | PASS    |
| `Unregister then register resurrects the registration`                                   | PASS    |
| `Unregister then register resolves to the original value if the registration is in use.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/clients-get.https.html">/service-workers/service-worker/clients-get.https.html</a></summary>


|       Subtest        | Results |
|----------------------|---------|
|                      | OK      |
| `Test Clients.get()` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/count-queuing-strategy.serviceworker.https.html">/streams/count-queuing-strategy.serviceworker.https.html</a></summary>


|                                           Subtest                                           | Results |
|---------------------------------------------------------------------------------------------|---------|
|                                                                                             | OK      |
| `Can construct a CountQueuingStrategy with a valid high water mark`                         | FAIL    |
| `CountQueuingStrategy constructor behaves as expected with strange arguments`               | FAIL    |
| `CountQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL    |
| `CountQueuingStrategy size behaves as expected with strange arguments`                      | FAIL    |
| `Can construct a CountQueuingStrategy with any value as its high water mark`                | FAIL    |
| `CountQueuingStrategy instances have the correct properties`                                | FAIL    |
| `Service worker test setup`                                                                 | PASS    |
| `CountQueuingStrategy's highWaterMark property can be set to anything`                      | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/pipe-through.serviceworker.https.html">/streams/piping/pipe-through.serviceworker.https.html</a></summary>


|                                                Subtest                                                 | Results |
|--------------------------------------------------------------------------------------------------------|---------|
|                                                                                                        | OK      |
| `pipeThrough can handle calling a pipeTo that returns a non-promise thenable object`                   | FAIL    |
| `pipeThrough generically calls pipeTo with the appropriate args`                                       | FAIL    |
| `Piping through a duck-typed pass-through transform stream should work`                                | FAIL    |
| `Service worker test setup`                                                                            | PASS    |
| `Piping through a transform errored on the writable end does not cause an unhandled promise rejection` | FAIL    |
| `pipeThrough can handle calling a pipeTo that returns a non-promise object`                            | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/byte-length-queuing-strategy.serviceworker.https.html">/streams/byte-length-queuing-strategy.serviceworker.https.html</a></summary>


|                                             Subtest                                              | Results |
|--------------------------------------------------------------------------------------------------|---------|
|                                                                                                  | OK      |
| `Can construct a ByteLengthQueuingStrategy with a valid high water mark`                         | FAIL    |
| `ByteLengthQueuingStrategy constructor behaves as expected with strange arguments`               | FAIL    |
| `ByteLengthQueuingStrategy instances have the correct properties`                                | FAIL    |
| `Can construct a ByteLengthQueuingStrategy with any value as its high water mark`                | FAIL    |
| `ByteLengthQueuingStrategy's highWaterMark property can be set to anything`                      | FAIL    |
| `ByteLengthQueuingStrategy size behaves as expected with strange arguments`                      | FAIL    |
| `ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL    |
| `Service worker test setup`                                                                      | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/extendable-event-waituntil.https.html">/service-workers/service-worker/extendable-event-waituntil.https.html</a></summary>


|                       Subtest                        | Results |
|------------------------------------------------------|---------|
|                                                      | OK      |
| `Test activate event waitUntil rejected.`            | PASS    |
| `Test install event waitUntil fulfilled`             | PASS    |
| `Test ExtendableEvent multiple waitUntil fulfilled.` | PASS    |
| `Test install event waitUntil rejected`              | PASS    |
| `Test activate event waitUntil fulfilled`            | PASS    |
| `Test ExtendableEvent waitUntil reject precedence.`  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration-end-to-end.https.html">/service-workers/service-worker/registration-end-to-end.https.html</a></summary>


|          Subtest           | Results |
|----------------------------|---------|
|                            | OK      |
| `Registration: end-to-end` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/close.serviceworker.https.html">/streams/writable-streams/close.serviceworker.https.html</a></summary>


|                                                              Subtest                                                               | Results |
|------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                    | OK      |
| `releaseLock() should not change the result of async close()`                                                                      | FAIL    |
| `when sink calls error asynchronously while closing, the stream should become errored`                                             | FAIL    |
| `promises must fulfill/reject in the expected order on closure`                                                                    | FAIL    |
| `releaseLock on a stream with a pending write in which the stream has been errored`                                                | FAIL    |
| `the promise returned by async abort during close should resolve`                                                                  | FAIL    |
| `releaseLock() should not change the result of sync close()`                                                                       | FAIL    |
| `releaseLock on a stream with a pending close in which the stream has been errored`                                                | FAIL    |
| `when close is called on a WritableStream in writable state, ready should return a fulfilled promise`                              | FAIL    |
| `promises must fulfill/reject in the expected order on aborted closure`                                                            | FAIL    |
| `returning a thenable from close() should work`                                                                                    | FAIL    |
| `when sink calls error synchronously while closing, the stream should become errored`                                              | FAIL    |
| `close() should set state to CLOSED even if writer has detached`                                                                   | FAIL    |
| `when close is called on a WritableStream in waiting state, ready promise should be fulfilled`                                     | FAIL    |
| `Service worker test setup`                                                                                                        | PASS    |
| `fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined value`                 | FAIL    |
| `promises must fulfill/reject in the expected order on aborted and errored closure`                                                | FAIL    |
| `when close is called on a WritableStream in waiting state, ready should be fulfilled immediately even if close takes a long time` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/activation.https.html">/service-workers/service-worker/activation.https.html</a></summary>


|                     Subtest                      | Results |
|--------------------------------------------------|---------|
|                                                  | OK      |
| `loss of controllees triggers activation`        | PASS    |
| `finishing a request triggers unregister`        | PASS    |
| `skipWaiting bypasses no controllee requirement` | PASS    |
| `finishing a request triggers activation`        | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/foreign-fetch-event.https.html">/service-workers/service-worker/foreign-fetch-event.https.html</a></summary>


|                          Subtest                           | Results |
|------------------------------------------------------------|---------|
|                                                            | OK      |
| `ForeignFetchEvent constructor with all init dict members` | FAIL    |
| `ForeignFetchEvent constructor with null request`          | FAIL    |
| `ForeignFetchEvent constructor`                            | PASS    |
| `ForeignFetchEvent constructor with empty init dict`       | FAIL    |
| `ForeignFetchEvent constructor with no init dict`          | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-matchAll.https.html">/service-workers/cache-storage/serviceworker/cache-matchAll.https.html</a></summary>


|                                    Subtest                                    | Results |
|-------------------------------------------------------------------------------|---------|
|                                                                               | OK      |
| `Cache.matchAll with URL`                                                     | PASS    |
| `Cache.matchAll with ignoreSearch option (request with no search parameters)` | PASS    |
| `Cache.matchAll`                                                              | PASS    |
| `Cache.matchAll with "ignoreVary" parameter`                                  | PASS    |
| `Cache.matchAll with Request`                                                 | PASS    |
| `Cache.matchAll with HEAD`                                                    | PASS    |
| `Cache.matchAll with new Request`                                             | PASS    |
| `Cache.matchAll with ignoreSearch option (request with search parameter)`     | PASS    |
| `Cache.matchAll with string fragment "http" as query`                         | PASS    |
| `Cache.matchAll with no matching entries`                                     | PASS    |
| `Cache.matchAll with URL containing fragment`                                 | PASS    |
| `Cache.matchAll with responses containing "Vary" header`                      | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-canvas-tainting-cache.https.html">/service-workers/service-worker/fetch-canvas-tainting-cache.https.html</a></summary>


|                            Subtest                            | Results |
|---------------------------------------------------------------|---------|
|                                                               | OK      |
| `Verify canvas tainting of fetched image in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/onactivate-script-error.https.html">/service-workers/service-worker/onactivate-script-error.https.html</a></summary>


|                              Subtest                              | Results |
|-------------------------------------------------------------------|---------|
|                                                                   | OK      |
| `activate handler dispatches an event that throws an error`       | PASS    |
| `activate handler throws an error and prevents default`           | PASS    |
| `activate handler throws an error, error handler does not cancel` | PASS    |
| `activate handler throws an error`                                | PASS    |
| `activate handler throws an error that is cancelled`              | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-mixed-content-to-inscope.https.html">/service-workers/service-worker/fetch-mixed-content-to-inscope.https.html</a></summary>


|                        Subtest                        | Results |
|-------------------------------------------------------|---------|
|                                                       | OK      |
| `Verify Mixed content of fetch() in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/update-after-navigation-fetch-event.https.html">/service-workers/service-worker/update-after-navigation-fetch-event.https.html</a></summary>


|                           Subtest                            | Results |
|--------------------------------------------------------------|---------|
|                                                              | OK      |
| `Update should be triggered after a navigation fetch event.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/skip-waiting-without-using-registration.https.html">/service-workers/service-worker/skip-waiting-without-using-registration.https.html</a></summary>


|                          Subtest                          | Results |
|-----------------------------------------------------------|---------|
|                                                           | OK      |
| `skipWaiting`                                             | PASS    |
| `Test skipWaiting while a client is not being controlled` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/general.serviceworker.https.html">/streams/piping/general.serviceworker.https.html</a></summary>


|                                              Subtest                                              | Results |
|---------------------------------------------------------------------------------------------------|---------|
|                                                                                                   | OK      |
| `pipeTo must fail if the ReadableStream is locked, and not lock the WritableStream`               | FAIL    |
| `Piping from a ReadableStream for which a chunk becomes asynchronously readable after the pipeTo` | FAIL    |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is true`    | FAIL    |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is true`      | FAIL    |
| `Piping from a ReadableStream from which lots of chunks are synchronously readable`               | FAIL    |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is false`     | FAIL    |
| `Piping must lock both the ReadableStream and WritableStream`                                     | FAIL    |
| `pipeTo must check the brand of its ReadableStream this value`                                    | FAIL    |
| `Service worker test setup`                                                                       | PASS    |
| `Piping finishing must unlock both the ReadableStream and WritableStream`                         | FAIL    |
| `pipeTo must check the brand of its WritableStream argument`                                      | FAIL    |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is false`   | FAIL    |
| `pipeTo must fail if the WritableStream is locked, and not lock the ReadableStream`               | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/ServiceWorkerGlobalScope/registration-attribute.https.html">/service-workers/service-worker/ServiceWorkerGlobalScope/registration-attribute.https.html</a></summary>


|                           Subtest                           | Results |
|-------------------------------------------------------------|---------|
|                                                             | OK      |
| `Verify registration attribute on ServiceWorkerGlobalScope` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/resource-timing.https.html">/service-workers/service-worker/resource-timing.https.html</a></summary>


|             Subtest             | Results |
|---------------------------------|---------|
|                                 | OK      |
| `Controlled resource loads`     | FAIL    |
| `Non-controlled resource loads` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-header-visibility.https.html">/service-workers/service-worker/fetch-header-visibility.https.html</a></summary>


|                        Subtest                        | Results |
|-------------------------------------------------------|---------|
|                                                       | OK      |
| `Visibility of defaulted headers during interception` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration-events.https.html">/service-workers/service-worker/registration-events.https.html</a></summary>


|        Subtest         | Results |
|------------------------|---------|
|                        | OK      |
| `Registration: events` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/brand-checks.serviceworker.https.html">/streams/readable-streams/brand-checks.serviceworker.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `ReadableStreamController.prototype.close enforces a brand check`            | FAIL    |
| `ReadableStreamReader.prototype.closed enforces a brand check`               | FAIL    |
| `ReadableStreamReader.prototype.read enforces a brand check`                 | FAIL    |
| `ReadableStreamReader.prototype.cancel enforces a brand check`               | FAIL    |
| `Can get the ReadableStreamController constructor indirectly`                | FAIL    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | FAIL    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | FAIL    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | FAIL    |
| `ReadableStreamReader.prototype.releaseLock enforces a brand check`          | FAIL    |
| `ReadableStream.prototype.tee enforces a brand check`                        | FAIL    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | FAIL    |
| `Service worker test setup`                                                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamReader constructor indirectly`                    | FAIL    |
| `ReadableStreamController.prototype.error enforces a brand check`            | FAIL    |
| `ReadableStreamReader enforces a brand check on its argument`                | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-css-images.https.html">/service-workers/service-worker/fetch-request-css-images.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | TIMEOUT |
| `Verify FetchEvent for css image (backgroundImage).`     | PASS    |
| `Verify FetchEvent for css image-set (backgroundImage).` | TIMEOUT |
| `Verify FetchEvent for css image (shapeOutside).`        | TIMEOUT |
| `Verify FetchEvent for css image-set (shapeOutside).`    | TIMEOUT |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/tee.serviceworker.https.html">/streams/readable-streams/tee.serviceworker.https.html</a></summary>


|                                                  Subtest                                                   | Results |
|------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                            | OK      |
| `ReadableStream teeing: values should be equal across each branch`                                         | FAIL    |
| `ReadableStream teeing: canceling branch1 should not impact branch2`                                       | FAIL    |
| `ReadableStream teeing: closing the original should immediately close the branches`                        | FAIL    |
| `ReadableStream teeing: rs.tee() returns an array of two ReadableStreams`                                  | FAIL    |
| `ReadableStream teeing: errors in the source should propagate to both branches`                            | FAIL    |
| `ReadableStream teeing: canceling branch2 should not impact branch2`                                       | FAIL    |
| `ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches` | FAIL    |
| `Service worker test setup`                                                                                | PASS    |
| `ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array`         | FAIL    |
| `ReadableStream teeing: should be able to read one branch to the end without affecting the other`          | FAIL    |
| `ReadableStream teeing: erroring the original should immediately error the branches`                       | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/invalid-header.https.html">/service-workers/service-worker/invalid-header.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Verify the response of FetchEvent using XMLHttpRequest` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration-iframe.https.html">/service-workers/service-worker/registration-iframe.https.html</a></summary>


|                                                                         Subtest                                                                         | Results |
|---------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                         | OK      |
| `Subframe's container's register method should use calling frame's document's url as a base url for parsing its script url and scope url - error case`  | PASS    |
| `Subframe's container's register method should use calling frame's document's url as a base url for parsing its script url and scope url - normal case` | PASS    |
| `A scope url should start with the given script url`                                                                                                    | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/unregister-then-register-new-script.https.html">/service-workers/service-worker/unregister-then-register-new-script.https.html</a></summary>


|                                               Subtest                                                | Results |
|------------------------------------------------------------------------------------------------------|---------|
|                                                                                                      | OK      |
| `Registering a new script URL while an unregistered registration is in use`                          | PASS    |
| `Registering a new script URL that fails to install does not resurrect an unregistered registration` | PASS    |
| `Registering a new script URL that 404s does not resurrect an unregistered registration`             | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/multiple-update.https.html">/service-workers/service-worker/multiple-update.https.html</a></summary>


|           Subtest           | Results |
|-----------------------------|---------|
|                             | OK      |
| `Trigger multiple updates.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event-after-navigation-within-page.https.html">/service-workers/service-worker/fetch-event-after-navigation-within-page.https.html</a></summary>


|                                Subtest                                | Results |
|-----------------------------------------------------------------------|---------|
|                                                                       | OK      |
| `Service Worker should respond to fetch event after the pushState`    | PASS    |
| `Service Worker should respond to fetch event after the hash changes` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/foreign-fetch-cors.https.html">/service-workers/service-worker/foreign-fetch-cors.https.html</a></summary>


|                                  Subtest                                   | Results |
|----------------------------------------------------------------------------|---------|
|                                                                            | OK      |
| `Same origin fetch without CORS headers, exposed to wrong origin`          | FAIL    |
| `Same origin fetch without CORS headers, headers and origin exposed`       | FAIL    |
| `Cross origin fetch with ACEHeaders header, only origin exposed`           | FAIL    |
| `Cross origin fetch with ACEHeaders header, not exposed`                   | PASS    |
| `Cross origin fetch without ACEHeaders header, only origin exposed`        | FAIL    |
| `Cross origin fetch with ACEHeaders header, headers and origin exposed`    | FAIL    |
| `Same origin fetch without CORS headers, only origin exposed`              | FAIL    |
| `Cross origin fetch without ACEHeaders header, not exposed`                | PASS    |
| `Same origin fetch without CORS headers, not exposed`                      | PASS    |
| `Same origin fetch with CORS headers, not exposed`                         | PASS    |
| `Same origin fetch with CORS headers, headers and origin exposed`          | FAIL    |
| `Cross origin fetch with ACEHeaders header, exposed to wrong origin`       | FAIL    |
| `Cross origin fetch without ACEHeaders header, headers and origin exposed` | FAIL    |
| `Same origin fetch with CORS headers, exposed to wrong origin`             | FAIL    |
| `Cross origin fetch without CORS headers, not exposed`                     | PASS    |
| `Same origin fetch with CORS headers, only origin exposed`                 | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-no-freshness-headers.https.html">/service-workers/service-worker/fetch-request-no-freshness-headers.https.html</a></summary>


|                             Subtest                              | Results |
|------------------------------------------------------------------|---------|
|                                                                  | OK      |
| `The headers of FetchEvent shouldn't contain freshness headers.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/pipe-through.serviceworker.https.html">/streams/readable-streams/pipe-through.serviceworker.https.html</a></summary>


|                                                   Subtest                                                   | Results |
|-------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                             | OK      |
| `ReadableStream.prototype.pipeThrough should throw when "this" has no pipeTo method`                        | FAIL    |
| `ReadableStream.prototype.pipeThrough should work generically on its this and its arguments`                | FAIL    |
| `Service worker test setup`                                                                                 | PASS    |
| `ReadableStream.prototype.pipeThrough should rethrow errors from accessing pipeTo, readable, or writable`   | FAIL    |
| `ReadableStream.prototype.pipeThrough should throw when its first argument is not convertible to an object` | FAIL    |
| `ReadableStream.prototype.pipeThrough should work with missing readable, writable, or options`              | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/installing.https.html">/service-workers/service-worker/installing.https.html</a></summary>


|       Subtest       | Results |
|---------------------|---------|
|                     | OK      |
| `installing is set` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-storage-keys.https.html">/service-workers/cache-storage/serviceworker/cache-storage-keys.https.html</a></summary>


|       Subtest       | Results |
|---------------------|---------|
|                     | OK      |
| `CacheStorage.keys` | PASS    |
| `CacheStorage keys` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/multiple-register.https.html">/service-workers/service-worker/multiple-register.https.html</a></summary>


|                                                                       Subtest                                                                       | Results |
|-----------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                     | OK      |
| `Subsequent registrations resolve to the same registration object`                                                                                  | PASS    |
| `Concurrent registrations resolve to the same registration object`                                                                                  | PASS    |
| `Subsequent registrations from a different iframe resolve to the different registration object but they refer to the same registration and workers` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/indexeddb.https.html">/service-workers/service-worker/indexeddb.https.html</a></summary>


|                      Subtest                      | Results |
|---------------------------------------------------|---------|
|                                                   | OK      |
| `Verify Indexed DB operation in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/ServiceWorkerGlobalScope/unregister.https.html">/service-workers/service-worker/ServiceWorkerGlobalScope/unregister.https.html</a></summary>


|                 Subtest                 | Results |
|-----------------------------------------|---------|
|                                         | OK      |
| `Unregister on activate event`          | PASS    |
| `Unregister on installing event`        | PASS    |
| `Unregister controlling service worker` | PASS    |
| `Unregister on script evaluation`       | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/uncontrolled-page.https.html">/service-workers/service-worker/uncontrolled-page.https.html</a></summary>


|                         Subtest                         | Results |
|---------------------------------------------------------|---------|
|                                                         | OK      |
| `Fetch events should not go through uncontrolled page.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/update.https.html">/service-workers/service-worker/update.https.html</a></summary>


|         Subtest          | Results |
|--------------------------|---------|
|                          | OK      |
| `Update a registration.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/error-propagation-forward.serviceworker.https.html">/streams/piping/error-propagation-forward.serviceworker.https.html</a></summary>


|                                                                    Subtest                                                                     | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                | OK      |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = true`                               | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true, preventClose = true`                            | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort =  (falsy); fulfilled abort promise`                                          | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = false; rejected abort promise`                                              | FAIL    |
| `Service worker test setup`                                                                                                                    | PASS    |
| `Errors must be propagated forward: starts errored; preventAbort = a (truthy)`                                                                 | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = -0 (falsy); fulfilled abort promise`                                        | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = [object Object] (truthy)`                                                   | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; rejected abort promise`                             | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = false; fulfilled abort promise`                                             | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = true`                                                      | FAIL    |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; fulfilled abort promise`     | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; rejected abort promise`  | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = false (falsy); fulfilled abort promise`                                     | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = null (falsy); fulfilled abort promise`                                      | FAIL    |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; rejected abort promise`      | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true`                                                 | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL    |
| `Errors must be propagated forward: shutdown must not occur until the final write completes`                                                   | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; fulfilled abort promise`                            | FAIL    |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; fulfilled abort promise`                                | FAIL    |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; rejected abort promise`                                 | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = undefined (falsy); fulfilled abort promise`                                 | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = 1 (truthy)`                                                                 | FAIL    |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = true`                           | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = Symbol() (truthy)`                                                          | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = true (truthy)`                                                              | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = NaN (falsy); fulfilled abort promise`                                       | FAIL    |
| `Errors must be propagated forward: starts errored; preventAbort = 0 (falsy); fulfilled abort promise`                                         | FAIL    |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = true`                                                          | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/websocket.https.html">/service-workers/service-worker/websocket.https.html</a></summary>


|                            Subtest                            | Results |
|---------------------------------------------------------------|---------|
|                                                               | OK      |
| `Verify WebSocket handshake channel does not get intercepted` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/register-link-element.https.html">/service-workers/service-worker/register-link-element.https.html</a></summary>


|                                 Subtest                                 | Results |
|-------------------------------------------------------------------------|---------|
|                                                                         | TIMEOUT |
| `Registering script importing non-existent script`                      | NOTRUN  |
| `Registering redirected script`                                         | NOTRUN  |
| `Registering scope with fragment`                                       | NOTRUN  |
| `Registering script including caught exception`                         | NOTRUN  |
| `Registering script including parse error`                              | NOTRUN  |
| `Registration scope outside the script directory`                       | NOTRUN  |
| `Registering scope outside domain`                                      | NOTRUN  |
| `Scope including URL-encoded backslash`                                 | NOTRUN  |
| `Registering same scope as the script directory`                        | NOTRUN  |
| `Registering script outside domain`                                     | NOTRUN  |
| `Scope including self-reference`                                        | NOTRUN  |
| `Script URL is same-origin filesystem: URL`                             | NOTRUN  |
| `Registering normal scope`                                              | TIMEOUT |
| `Registering script with bad MIME type`                                 | NOTRUN  |
| `Scope including non-escaped multibyte characters`                      | NOTRUN  |
| `Registering invalid chunked encoding script with flush`                | NOTRUN  |
| `Registering non-existent script`                                       | NOTRUN  |
| `Script URL including URL-encoded backslash`                            | NOTRUN  |
| `Registering same scope as the script directory without the last slash` | NOTRUN  |
| `Script URL including uppercase URL-encoded slash`                      | NOTRUN  |
| `Registering script with no MIME type`                                  | NOTRUN  |
| `Scope including URL-encoded slash`                                     | NOTRUN  |
| `Registering script including undefined error`                          | NOTRUN  |
| `Scope including consecutive slashes`                                   | NOTRUN  |
| `Scope including URL-encoded multibyte characters`                      | NOTRUN  |
| `Registering invalid chunked encoding script`                           | NOTRUN  |
| `Script URL including URL-encoded slash`                                | NOTRUN  |
| `Script URL including consecutive slashes`                              | NOTRUN  |
| `Registering script including uncaught exception`                       | NOTRUN  |
| `Script URL including parent-reference`                                 | NOTRUN  |
| `Script URL including uppercase URL-encoded backslash`                  | NOTRUN  |
| `Scope URL is same-origin filesystem: URL`                              | NOTRUN  |
| `Scope including parent-reference`                                      | NOTRUN  |
| `Script URL including self-reference`                                   | NOTRUN  |
| `Scope including parent-reference and not under the script directory`   | NOTRUN  |
| `Registering script importing malformed script`                         | NOTRUN  |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/count-queuing-strategy.serviceworker.https.html">/streams/writable-streams/count-queuing-strategy.serviceworker.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `Correctly governs the value of a WritableStream's state property (HWM = 0)` | FAIL    |
| `Can construct a writable stream with a valid CountQueuingStrategy`          | FAIL    |
| `Service worker test setup`                                                  | PASS    |
| `Correctly governs the value of a WritableStream's state property (HWM = 4)` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/postmessage-msgport-to-client.https.html">/service-workers/service-worker/postmessage-msgport-to-client.https.html</a></summary>


|                         Subtest                         | Results |
|---------------------------------------------------------|---------|
|                                                         | OK      |
| `postMessage MessagePorts from ServiceWorker to Client` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-mixed-content-to-outscope.https.html">/service-workers/service-worker/fetch-mixed-content-to-outscope.https.html</a></summary>


|                        Subtest                        | Results |
|-------------------------------------------------------|---------|
|                                                       | OK      |
| `Verify Mixed content of fetch() in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-request-css-base-url.https.html">/service-workers/service-worker/fetch-request-css-base-url.https.html</a></summary>


|                                  Subtest                                   | Results |
|----------------------------------------------------------------------------|---------|
|                                                                            | OK      |
| `CSS's base URL must be the request URL even when fetched from other URL.` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/getregistration.https.html">/service-workers/service-worker/getregistration.https.html</a></summary>


|                           Subtest                            | Results |
|--------------------------------------------------------------|---------|
|                                                              | OK      |
| `getRegistration`                                            | PASS    |
| `Register then Unregister then getRegistration`              | PASS    |
| `Register then getRegistration`                              | PASS    |
| `Register then getRegistration with a URL having a fragment` | PASS    |
| `getRegistration with a cross origin URL`                    | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/waiting.https.html">/service-workers/service-worker/waiting.https.html</a></summary>


|          Subtest           | Results |
|----------------------------|---------|
|                            | OK      |
| `waiting or active is set` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/registration-useCache.https.html">/service-workers/service-worker/registration-useCache.https.html</a></summary>


|                             Subtest                              | Results |
|------------------------------------------------------------------|---------|
|                                                                  | OK      |
| `Test with useCache: true`                                       | PASS    |
| `Test with useCache: default`                                    | PASS    |
| `Consecutive registrations with useCache settings(true, true)`   | PASS    |
| `Consecutive registrations with useCache settings(false, false)` | PASS    |
| `Consecutive registrations with useCache settings(true, false)`  | PASS    |
| `Test with useCache: false`                                      | PASS    |
| `Consecutive registrations with useCache settings(false, true)`  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html">/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html</a></summary>


|                                                  Subtest                                                   | Results |
|------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                            | OK      |
| `Closing a writable stream with in-flight writes below the high water mark delays the close call properly` | FAIL    |
| `Service worker test setup`                                                                                | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event-respond-with-stops-propagation.https.html">/service-workers/service-worker/fetch-event-respond-with-stops-propagation.https.html</a></summary>


|                      Subtest                       | Results |
|----------------------------------------------------|---------|
|                                                    | OK      |
| `respondWith() invokes stopImmediatePropagation()` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/foreign-fetch-workers.https.html">/service-workers/service-worker/foreign-fetch-workers.https.html</a></summary>


|                              Subtest                               | Results |
|--------------------------------------------------------------------|---------|
|                                                                    | TIMEOUT |
| `Foreign fetch can intercept fetches made from a shared worker`    | NOTRUN  |
| `Foreign fetch can intercept fetches made from a service worker`   | TIMEOUT |
| `Foreign fetch can intercept fetches made from a dedicated worker` | NOTRUN  |
| `Fetches from an insecure dedicated worker aren't intercepted.`    | NOTRUN  |
| `Fetches from an insecure shared worker aren't intercepted.`       | NOTRUN  |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/oninstall-script-error.https.html">/service-workers/service-worker/oninstall-script-error.https.html</a></summary>


|                             Subtest                              | Results |
|------------------------------------------------------------------|---------|
|                                                                  | OK      |
| `install handler throws an error`                                | PASS    |
| `install handler throws an error that is cancelled`              | PASS    |
| `install handler throws an error and prevents default`           | PASS    |
| `install handler throws an error, error handler does not cancel` | PASS    |
| `install handler dispatches an event that throws an error`       | PASS    |
| `install handler throws an error in the waitUntil`               | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/serviceworkerobject-scripturl.https.html">/service-workers/service-worker/serviceworkerobject-scripturl.https.html</a></summary>


|                  Subtest                  | Results |
|-------------------------------------------|---------|
|                                           | OK      |
| `Verify the scriptURL property: relative` | PASS    |
| `Verify the scriptURL property: absolute` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/iframe-controller.https.html">/service-workers/service-worker/iframe-controller.https.html</a></summary>


|                        Subtest                         | Results |
|--------------------------------------------------------|---------|
|                                                        | OK      |
| `Service worker inheritance for sandboxed iframe.`     | FAIL    |
| `Service worker inheritance for navigate match.`       | PASS    |
| `Service worker inheritance for iframe srcdoc.`        | FAIL    |
| `Service worker inheritance for about:blank Document.` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-storage-match.https.html">/service-workers/cache-storage/serviceworker/cache-storage-match.https.html</a></summary>


|                            Subtest                             | Results |
|----------------------------------------------------------------|---------|
|                                                                | OK      |
| `CacheStorageMatch from one of many caches by name`            | PASS    |
| `CacheStorage.match`                                           | PASS    |
| `CacheStorageMatch from one of many caches`                    | PASS    |
| `CacheStorageMatch with no cached entry`                       | PASS    |
| `CacheStorageMatch with no caches available but name provided` | PASS    |
| `CacheStorageMatch with no cache name provided`                | PASS    |
| `CacheStorageMatch a string request`                           | PASS    |
| `CacheStorageMatch a HEAD request`                             | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/general.serviceworker.https.html">/streams/readable-streams/general.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream can be constructed with no errors`                                                                           | FAIL    |
| `ReadableStream: enqueue should throw when the stream is readable but draining`                                              | FAIL    |
| `ReadableStream: should not call pull until the previous pull call's promise fulfills`                                       | FAIL    |
| `ReadableStream: should not call pull after start if the stream is now closed`                                               | FAIL    |
| `ReadableStream pull should be able to close a stream.`                                                                      | FAIL    |
| `ReadableStream start controller parameter should be extensible`                                                             | FAIL    |
| `ReadableStream should be able to enqueue different objects.`                                                                | FAIL    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream constructor should throw for non-function start arguments`                                                   | FAIL    |
| `ReadableStream constructor can get initial garbage as cancel argument`                                                      | FAIL    |
| `ReadableStream: should not call pull() in reaction to read()ing the last chunk, if draining`                                | FAIL    |
| `ReadableStream constructor can get initial garbage as pull argument`                                                        | FAIL    |
| `ReadableStream: should call underlying source methods as methods`                                                           | FAIL    |
| `ReadableStream pull should be able to error a stream and throw.`                                                            | FAIL    |
| `ReadableStream: should only call pull once on a non-empty stream read from before start fulfills`                           | FAIL    |
| `ReadableStream: should only call pull once upon starting the stream`                                                        | FAIL    |
| `ReadableStream: should call pull in reaction to read()ing the last chunk, if not draining`                                  | FAIL    |
| `ReadableStream start should be called with the proper parameters`                                                           | FAIL    |
| `ReadableStream can't be constructed with an invalid type`                                                                   | FAIL    |
| `ReadableStream: should pull after start, and after every read`                                                              | FAIL    |
| `ReadableStream strategies: the default strategy should give desiredSize of 1 to start, decreasing by 1 per enqueue`         | FAIL    |
| `ReadableStream instances should have the correct list of properties`                                                        | FAIL    |
| `ReadableStream strategies: the default strategy should continue giving desiredSize of 1 if the chunks are read immediately` | FAIL    |
| `ReadableStream pull should be able to error a stream.`                                                                      | FAIL    |
| `ReadableStream should be able to call start method within prototype chain of its source`                                    | FAIL    |
| `ReadableStream: should only call pull once on a non-empty stream read from after start fulfills`                            | FAIL    |
| `ReadableStream: if pull rejects, it should error the stream`                                                                | FAIL    |
| `ReadableStream integration test: adapting a random push source`                                                             | FAIL    |
| `ReadableStream: enqueue should throw when the stream is closed`                                                             | FAIL    |
| `ReadableStream can't be constructed with garbage`                                                                           | FAIL    |
| `ReadableStream integration test: adapting an async pull source`                                                             | FAIL    |
| `ReadableStream: should call pull when trying to read from a started, empty stream`                                          | FAIL    |
| `ReadableStream integration test: adapting a sync pull source`                                                               | FAIL    |
| `ReadableStream: should call pull after enqueueing from inside pull (with no read requests), if strategy allows`             | FAIL    |
| `ReadableStream start should be able to return a promise and reject it`                                                      | FAIL    |
| `ReadableStream start should be able to return a promise`                                                                    | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/readable-stream-reader.serviceworker.https.html">/streams/readable-streams/readable-stream-reader.serviceworker.https.html</a></summary>


|                                                       Subtest                                                        | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | OK      |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise`                 | FAIL    |
| `Service worker test setup`                                                                                          | PASS    |
| `Reading twice on a closed stream`                                                                                   | FAIL    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via direct construction)` | FAIL    |
| `Multiple readers can access the stream in sequence`                                                                 | FAIL    |
| `cancel() on a reader does not release the reader`                                                                   | FAIL    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                          | FAIL    |
| `ReadableStreamReader constructor should get a ReadableStream object as argument`                                    | PASS    |
| `ReadableStreamReader: if start rejects with no parameter, it should error the stream with an undefined error`       | FAIL    |
| `ReadableStreamReader closed promise should be rejected with undefined if that is the error`                         | FAIL    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                   | FAIL    |
| `Cannot use an already-released reader to unlock a stream again`                                                     | FAIL    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                | FAIL    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via getReader)`           | FAIL    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is errored`                                 | FAIL    |
| `Reading twice on a stream that gets closed`                                                                         | FAIL    |
| `Can get the ReadableStreamReader constructor indirectly`                                                            | FAIL    |
| `ReadableStreamReader instances should have the correct list of properties`                                          | FAIL    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is closed`                                  | FAIL    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                     | FAIL    |
| `Reading twice on a stream that gets errored`                                                                        | FAIL    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise`                  | FAIL    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via getReader)`           | FAIL    |
| `cancel() on a released reader is a no-op and does not pass through`                                                 | FAIL    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)` | FAIL    |
| `ReadableStreamReader closed should always return the same promise object`                                           | FAIL    |
| `Reading twice on an errored stream`                                                                                 | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/unregister.https.html">/service-workers/service-worker/unregister.https.html</a></summary>


|          Subtest           | Results |
|----------------------------|---------|
|                            | OK      |
| `Register then unregister` | PASS    |
| `Unregister twice`         | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/multi-globals/url-parsing.https.html">/service-workers/service-worker/multi-globals/url-parsing.https.html</a></summary>


|                                                  Subtest                                                  | Results |
|-----------------------------------------------------------------------------------------------------------|---------|
|                                                                                                           | OK      |
| `register should use the relevant global of the object it was called on to resolve the scope URL`         | FAIL    |
| `getRegistration should use the relevant global of the object it was called on to resolve the script URL` | PASS    |
| `register should use the relevant global of the object it was called on to resolve the script URL`        | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-canvas-tainting.https.html">/service-workers/service-worker/fetch-canvas-tainting.https.html</a></summary>


|                            Subtest                            | Results |
|---------------------------------------------------------------|---------|
|                                                               | OK      |
| `Verify canvas tainting of fetched image in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/brand-checks.serviceworker.https.html">/streams/writable-streams/brand-checks.serviceworker.https.html</a></summary>


|           Subtest           | Results |
|-----------------------------|---------|
|                             | OK      |
| `Service worker test setup` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-waits-for-activate.https.html">/service-workers/service-worker/fetch-waits-for-activate.https.html</a></summary>


|                            Subtest                             | Results |
|----------------------------------------------------------------|---------|
|                                                                | OK      |
| `Fetch events should wait for the activate event to complete.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html">/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html</a></summary>


|                                                           Subtest                                                           | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | OK      |
| `write: returning a promise that becomes rejected after the writer write() should cause writer write() and ready to reject` | FAIL    |
| `abort: non-function abort method with .apply`                                                                              | FAIL    |
| `write: throwing method should cause write() and closed to reject`                                                          | FAIL    |
| `close: returning a rejected promise should cause writer close() and ready to reject`                                       | FAIL    |
| `close: throwing method should cause writer close() and ready to reject`                                                    | FAIL    |
| `write: returning a rejected promise (second write) should cause writer write() and ready to reject`                        | FAIL    |
| `Service worker test setup`                                                                                                 | PASS    |
| `abort: throwing getter should cause abort() and closed to reject`                                                          | FAIL    |
| `close: throwing getter should cause writer close() to reject`                                                              | FAIL    |
| `write: throwing getter should cause write() and closed to reject`                                                          | FAIL    |
| `start: errors in start cause WritableStream constructor to throw`                                                          | FAIL    |
| `abort: throwing method should cause abort() and closed to reject`                                                          | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/clients-matchall-include-uncontrolled.https.html">/service-workers/service-worker/clients-matchall-include-uncontrolled.https.html</a></summary>


|                     Subtest                     | Results |
|-------------------------------------------------|---------|
|                                                 | OK      |
| `Verify matchAll() respect includeUncontrolled` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/postmessage-to-client.https.html">/service-workers/service-worker/postmessage-to-client.https.html</a></summary>


|                  Subtest                   | Results |
|--------------------------------------------|---------|
|                                            | OK      |
| `postMessage from ServiceWorker to Client` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/skip-waiting.https.html">/service-workers/service-worker/skip-waiting.https.html</a></summary>


|                         Subtest                         | Results |
|---------------------------------------------------------|---------|
|                                                         | OK      |
| `Test skipWaiting with both active and waiting workers` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/unregister-controller.https.html">/service-workers/service-worker/unregister-controller.https.html</a></summary>


|                                  Subtest                                  | Results |
|---------------------------------------------------------------------------|---------|
|                                                                           | OK      |
| `Unregister prevents new controllee even if registration is still in use` | PASS    |
| `Unregister does not affect existing controller`                          | PASS    |
| `Unregister prevents control of subsequent navigations`                   | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/garbage-collection.serviceworker.https.html">/streams/readable-streams/garbage-collection.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `Garbage-collecting a ReadableStreamReader should not unlock its stream`                                                     | FAIL    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | FAIL    |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | FAIL    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | FAIL    |
| `Service worker test setup`                                                                                                  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/appcache-ordering-main.https.html">/service-workers/service-worker/appcache-ordering-main.https.html</a></summary>


|                    Subtest                    | Results |
|-----------------------------------------------|---------|
|                                               | OK      |
| `serviceworkers take priority over appcaches` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-frame-resource.https.html">/service-workers/service-worker/fetch-frame-resource.https.html</a></summary>


|                            Subtest                            | Results |
|---------------------------------------------------------------|---------|
|                                                               | OK      |
| `CORS type response could be loaded in the new window.`       | PASS    |
| `Opaque type response could not be loaded in the new window.` | PASS    |
| `CORS type response could be loaded in the iframe.`           | PASS    |
| `Basic type response could be loaded in the new window.`      | PASS    |
| `Opaque type response could not be loaded in the iframe.`     | PASS    |
| `Basic type response could be loaded in the iframe.`          | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/performance-timeline.https.html">/service-workers/service-worker/performance-timeline.https.html</a></summary>


|                              Subtest                               | Results |
|--------------------------------------------------------------------|---------|
|                                                                    | OK      |
| `Test Performance Timeline API in Service Worker`                  | PASS    |
| `User Timing`                                                      | PASS    |
| `empty service worker fetch event included in performance timings` | FAIL    |
| `Resource Timing`                                                  | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/start.serviceworker.https.html">/streams/writable-streams/start.serviceworker.https.html</a></summary>


|                                                Subtest                                                | Results |
|-------------------------------------------------------------------------------------------------------|---------|
|                                                                                                       | OK      |
| `underlying sink's write or close should not be called if start throws`                               | FAIL    |
| `underlying sink's write or close should not be invoked if the promise returned by start is rejected` | FAIL    |
| `returning a thenable from start() should work`                                                       | FAIL    |
| `underlying sink's write should not be called until start finishes`                                   | FAIL    |
| `underlying sink's close should not be called until start finishes`                                   | FAIL    |
| `Service worker test setup`                                                                           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/controller-on-disconnect.https.html">/service-workers/service-worker/controller-on-disconnect.https.html</a></summary>


|                    Subtest                     | Results |
|------------------------------------------------|---------|
|                                                | OK      |
| `controller is cleared on disconnected window` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/update-after-oneday.https.html">/service-workers/service-worker/update-after-oneday.https.html</a></summary>


|                                           Subtest                                            | Results |
|----------------------------------------------------------------------------------------------|---------|
|                                                                                              | TIMEOUT |
| `Update should be triggered after a functional event when last update time is over 24 hours` | TIMEOUT |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/worker-interception.https.html">/service-workers/service-worker/worker-interception.https.html</a></summary>


|                                      Subtest                                       | Results |
|------------------------------------------------------------------------------------|---------|
|                                                                                    | OK      |
| `Verify worker script intercepted by no-cors cross-origin response fails`          | PASS    |
| `Verify worker script from uncontrolled document is intercepted by Service Worker` | PASS    |
| `Verify worker loads from controlled document are intercepted by Service Worker`   | PASS    |
| `Verify worker script intercepted by same-origin response succeeds`                | PASS    |
| `Verify worker script intercepted by cors response succeeds`                       | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/piping/close-propagation-backward.serviceworker.https.html">/streams/piping/close-propagation-backward.serviceworker.https.html</a></summary>


|                                                       Subtest                                                        | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | OK      |
| `Closing must be propagated backward: starts closed; preventCancel = undefined (falsy); fulfilled cancel promise`    | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = -0 (falsy); fulfilled cancel promise`           | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel =  (falsy); fulfilled cancel promise`             | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = 1 (truthy)`                                     | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true, preventClose = true` | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = null (falsy); fulfilled cancel promise`         | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = [object Object] (truthy)`                       | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel omitted; rejected cancel promise`                 | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel omitted; fulfilled cancel promise`                | FAIL    |
| `Service worker test setup`                                                                                          | PASS    |
| `Closing must be propagated backward: starts closed; preventCancel = a (truthy)`                                     | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = Symbol() (truthy)`                              | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = 0 (falsy); fulfilled cancel promise`            | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = NaN (falsy); fulfilled cancel promise`          | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = true (truthy)`                                  | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true`                      | FAIL    |
| `Closing must be propagated backward: starts closed; preventCancel = false (falsy); fulfilled cancel promise`        | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/clients-matchall.https.html">/service-workers/service-worker/clients-matchall.https.html</a></summary>


|          Subtest          | Results |
|---------------------------|---------|
|                           | OK      |
| `Test Clients.matchAll()` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/constructor.serviceworker.https.html">/streams/writable-streams/constructor.serviceworker.https.html</a></summary>


|                                                       Subtest                                                        | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | OK      |
| `controller argument should be passed to write method`                                                               | FAIL    |
| `WritableStream should be constructible with no arguments`                                                           | FAIL    |
| `WritableStream instances should have standard methods and properties`                                               | FAIL    |
| `WritableStreamDefaultWriter constructor should throw when stream argument is locked`                                | FAIL    |
| `controller argument should be passed to start method`                                                               | FAIL    |
| `WritableStreamDefaultWriter should throw unless passed a WritableStream`                                            | FAIL    |
| `Service worker test setup`                                                                                          | PASS    |
| `WritableStream should be writable and ready should fulfill immediately if the strategy does not apply backpressure` | FAIL    |
| `WritableStreamDefaultController constructor should throw when passed an initialised WritableStream`                 | FAIL    |
| `WritableStreamDefaultController constructor should throw unless passed a WritableStream`                            | FAIL    |
| `highWaterMark should be reflected to desiredSize`                                                                   | FAIL    |
| `controller argument should be passed to close method`                                                               | FAIL    |
| `private constructors should not be exported`                                                                        | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-csp.https.html">/service-workers/service-worker/fetch-csp.https.html</a></summary>


|                       Subtest                       | Results |
|-----------------------------------------------------|---------|
|                                                     | OK      |
| `Verify CSP control of fetch() in a Service Worker` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-match.https.html">/service-workers/cache-storage/serviceworker/cache-match.https.html</a></summary>


|                                  Subtest                                   | Results |
|----------------------------------------------------------------------------|---------|
|                                                                            | OK      |
| `Cache produces large Responses that can be cloned and read correctly.`    | PASS    |
| `Cache.match with a network error Response`                                | PASS    |
| `Cache.match with ignoreSearch option (request with no search parameters)` | PASS    |
| `Cache.match with responses containing "Vary" header`                      | PASS    |
| `Cache.match with URL`                                                     | PASS    |
| `Cache.match with no matching entries`                                     | PASS    |
| `Cache.match with string fragment "http" as query`                         | PASS    |
| `Cache.match with ignoreSearch option (request with search parameter)`     | PASS    |
| `Cache.match with HEAD`                                                    | PASS    |
| `Cache.match invoked multiple times for the same Request/Response`         | PASS    |
| `Cache.match with new Request`                                             | PASS    |
| `Cache.match with Request and Response objects with different URLs`        | PASS    |
| `Cache.match with URL containing fragment`                                 | PASS    |
| `Cache.match with POST Request`                                            | PASS    |
| `Cache.match`                                                              | PASS    |
| `Cache.match with a non-2xx Response`                                      | PASS    |
| `Cache.match with Request`                                                 | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/writable-streams/general.serviceworker.https.html">/streams/writable-streams/general.serviceworker.https.html</a></summary>


|                              Subtest                              | Results |
|-------------------------------------------------------------------|---------|
|                                                                   | OK      |
| `closed and ready on a released writer`                           | FAIL    |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    |
| `WritableStream's strategy.size should not be called as a method` | FAIL    |
| `ws.getWriter() on a closing WritableStream`                      | FAIL    |
| `methods should not not have .apply() or .call() called`          | FAIL    |
| `Service worker test setup`                                       | PASS    |
| `WritableStream should call underlying sink methods as methods`   | FAIL    |
| `ws.getWriter() on a closed WritableStream`                       | FAIL    |
| `desiredSize on a writer for a closed stream`                     | FAIL    |
| `desiredSize on a released writer`                                | FAIL    |
| `redundant releaseLock() is no-op`                                | FAIL    |
| `desiredSize initial value`                                       | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-event-redirect.https.html">/service-workers/service-worker/fetch-event-redirect.https.html</a></summary>


|                                                                                         Subtest                                                                                         | Results |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                                         | OK      |
| `Non-navigation, follow redirect, no-cors mode Request redirected to same-origin without credentials should succeed interception and response should be redirected`                     | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to same-origin with credentials should fail interception and response should not be redirected`                        | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to no-cors without credentials should fail interception and response should not be redirected`                     | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to same-origin without credentials should fail interception and response should not be redirected`                        | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to cors without credentials should fail opaqueredirect interception and response should not be redirected`               | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to no-cors without credentials should fail interception and response should not be redirected`                    | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to no-cors without credentials should fail interception and response should not be redirected`                           | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to cors with credentials should fail interception and response should not be redirected`                          | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to no-cors with credentials should succeed interception and response should not be redirected`                        | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to cors without credentials should succeed interception and response should be redirected`                               | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to same-origin with credentials should fail interception and response should not be redirected`                           | PASS    |
| `Non-navigation, follow redirect, no-cors mode Request redirected to no-cors without credentials should succeed interception and response should not be redirected`                     | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to same-origin with credentials should succeed interception and response should be redirected`                    | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to same-origin without credentials should fail interception and response should not be redirected`                 | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to cors without credentials should succeed interception and response should not be redirected`                        | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to no-cors without credentials should succeed interception and response should not be redirected`                     | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to cors without credentials should fail interception and response should not be redirected`                               | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to no-cors with credentials should fail interception and response should not be redirected`                       | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to cors with credentials should fail interception and response should not be redirected`                           | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to cors with credentials should succeed interception and response should not be redirected`                           | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to cors with credentials should fail interception and response should be redirected`                                     | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to cors without credentials should fail interception and response should not be redirected`                       | PASS    |
| `Non-navigation, follow redirect, no-cors mode Request redirected to cors with credentials should succeed interception and response should not be redirected`                           | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to same-origin with credentials should succeed interception and response should be redirected`                           | PASS    |
| `Non-navigation, follow redirect, same-origin mode Request redirected to same-origin without credentials should succeed interception and response should be redirected`                 | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to same-origin without credentials should fail interception and response should not be redirected`                     | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to no-cors with credentials should fail interception and response should not be redirected`                            | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to same-origin with credentials should fail opaqueredirect interception and response should not be redirected`        | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to same-origin without credentials should succeed interception and response should be redirected`                        | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to same-origin with credentials should fail interception and response should not be redirected`                    | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to same-origin without credentials should fail opaqueredirect interception and response should not be redirected` | PASS    |
| `Non-navigation, follow redirect, no-cors mode Request redirected to cors without credentials should succeed interception and response should not be redirected`                        | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to no-cors without credentials should fail interception and response should not be redirected`                            | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to cors with credentials should fail opaqueredirect interception and response should not be redirected`           | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to no-cors without credentials should fail opaqueredirect interception and response should not be redirected`            | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to cors without credentials should fail interception and response should not be redirected`                        | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to cors with credentials should fail opaqueredirect interception and response should not be redirected`                  | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to cors without credentials should fail interception and response should not be redirected`                            | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to same-origin with credentials should fail opaqueredirect interception and response should not be redirected`    | PASS    |
| `Non-navigation, follow redirect, no-cors mode Request redirected to same-origin with credentials should succeed interception and response should be redirected`                        | PASS    |
| `Non-navigation, follow redirect, cors mode Request redirected to no-cors with credentials should fail interception and response should not be redirected`                              | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to cors without credentials should fail opaqueredirect interception and response should not be redirected`        | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to no-cors without credentials should fail interception and response should not be redirected`                         | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to same-origin with credentials should fail opaqueredirect interception and response should not be redirected`           | PASS    |
| `Non-navigation, error redirect, no-cors mode Request redirected to cors with credentials should fail interception and response should not be redirected`                               | PASS    |
| `Non-navigation, error redirect, same-origin mode Request redirected to no-cors with credentials should fail interception and response should not be redirected`                        | PASS    |
| `Non-navigation, follow redirect, no-cors mode Request redirected to no-cors with credentials should succeed interception and response should not be redirected`                        | PASS    |
| `Non-navigation, manual redirect, no-cors mode Request redirected to same-origin without credentials should fail opaqueredirect interception and response should not be redirected`     | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to no-cors with credentials should fail opaqueredirect interception and response should not be redirected`               | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to no-cors with credentials should fail interception and response should not be redirected`                               | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to no-cors without credentials should fail opaqueredirect interception and response should not be redirected`     | PASS    |
| `Non-navigation, manual redirect, cors mode Request redirected to same-origin without credentials should fail opaqueredirect interception and response should not be redirected`        | PASS    |
| `Non-navigation, manual redirect, same-origin mode Request redirected to no-cors with credentials should fail opaqueredirect interception and response should not be redirected`        | PASS    |
| `Non-navigation, error redirect, cors mode Request redirected to cors with credentials should fail interception and response should not be redirected`                                  | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/shared-worker-controlled.https.html">/service-workers/service-worker/shared-worker-controlled.https.html</a></summary>


|                                    Subtest                                    | Results |
|-------------------------------------------------------------------------------|---------|
|                                                                               | ERROR   |
| `Verify subresource loads in SharedWorker are controlled by a Service Worker` | FAIL    |
| `Verify SharedWorker construction is controlled by a Service Worker`          | PASS    |
| `Verify importScripts from SharedWorker is controlled by a Service Worker`    | TIMEOUT |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/active.https.html">/service-workers/service-worker/active.https.html</a></summary>


|     Subtest     | Results |
|-----------------|---------|
|                 | OK      |
| `active is set` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/extendable-event-async-waituntil.https.html">/service-workers/service-worker/extendable-event-async-waituntil.https.html</a></summary>


|                                        Subtest                                         | Results |
|----------------------------------------------------------------------------------------|---------|
|                                                                                        | OK      |
| `Test calling waitUntil in a different microtask without an existing extension throws` | PASS    |
| `Test calling waitUntil asynchronously with pending respondWith promise.`              | PASS    |
| `Test calling waitUntil after the current extension expired in a different task fails` | PASS    |
| `Test calling waitUntil in a different task with an existing extension succeeds`       | PASS    |
| `Test calling waitUntil in a different task without an existing extension throws`      | PASS    |
| `Test calling waitUntil with an existing extension promise handler succeeds`           | PASS    |
| `Test calling waitUntil at the end of the microtask turn throws`                       | PASS    |
| `Test calling waitUntil on a script constructed ExtendableEvent throws exception`      | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/bad-underlying-sources.serviceworker.https.html">/streams/readable-streams/bad-underlying-sources.serviceworker.https.html</a></summary>


|                                                               Subtest                                                                | Results |
|--------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                      | OK      |
| `Underlying source pull: throwing getter (second pull)`                                                                              | FAIL    |
| `Underlying source start: throwing method`                                                                                           | FAIL    |
| `Underlying source cancel: throwing getter`                                                                                          | FAIL    |
| `Underlying source cancel: throwing method`                                                                                          | FAIL    |
| `Underlying source: calling close after error should throw`                                                                          | FAIL    |
| `Service worker test setup`                                                                                                          | PASS    |
| `Underlying source: calling close on a non-empty canceled stream should throw`                                                       | FAIL    |
| `Underlying source pull: throwing method (second pull)`                                                                              | FAIL    |
| `read should not error if it dequeues and pull() throws`                                                                             | FAIL    |
| `Underlying source: calling error and returning a rejected promise from pull should cause the stream to error with the first error`  | FAIL    |
| `Underlying source start: throwing getter`                                                                                           | FAIL    |
| `Underlying source: calling enqueue on an empty canceled stream should throw`                                                        | FAIL    |
| `Underlying source: calling enqueue on a closed stream should throw`                                                                 | FAIL    |
| `Underlying source: calling enqueue on an errored stream should throw`                                                               | FAIL    |
| `Underlying source: calling enqueue on a non-empty canceled stream should throw`                                                     | FAIL    |
| `Underlying source: throwing pull method (initial pull)`                                                                             | FAIL    |
| `Underlying source: throwing pull getter (initial pull)`                                                                             | FAIL    |
| `Underlying source: calling close twice on an empty stream should throw the second time`                                             | FAIL    |
| `Underlying source: calling error and returning a rejected promise from start should cause the stream to error with the first error` | FAIL    |
| `Underlying source: calling close on an empty canceled stream should throw`                                                          | FAIL    |
| `Underlying source: calling close twice on a non-empty stream should throw the second time`                                          | FAIL    |
| `Underlying source: calling error after close should throw`                                                                          | FAIL    |
| `Underlying source: calling error twice should throw the second time`                                                                | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/streams/readable-streams/templated.serviceworker.https.html">/streams/readable-streams/templated.serviceworker.https.html</a></summary>


|                                                                               Subtest                                                                               | Results |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                     | OK      |
| `Running templatedRSClosed with ReadableStream (closed via cancel)`                                                                                                 | PASS    |
| `ReadableStream (errored via call in start): getReader() should return a reader that acts errored`                                                                  | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError`                         | FAIL    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)`                       | FAIL    |
| `ReadableStream reader (errored before getting reader): read() should reject with the error`                                                                        | FAIL    |
| `ReadableStream (empty) reader: instances have the correct methods and properties`                                                                                  | FAIL    |
| `ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession`                                          | FAIL    |
| `ReadableStream (empty) reader: releasing the lock should cause locked to become false`                                                                             | FAIL    |
| `Running templatedRSErrored with ReadableStream (errored via call in start)`                                                                                        | PASS    |
| `ReadableStream (errored via call in start): locked should be false`                                                                                                | FAIL    |
| `ReadableStream (empty) reader: getReader() again on the stream should fail`                                                                                        | FAIL    |
| `Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)`                                                               | PASS    |
| `ReadableStream (empty) reader: two read()s should both never settle`                                                                                               | FAIL    |
| `ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback`                                          | FAIL    |
| `ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time`                                                         | FAIL    |
| `ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors`                                                                  | FAIL    |
| `Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start)`                                                                | PASS    |
| `Running templatedRSEmptyReader with ReadableStream (empty) reader`                                                                                                 | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): releasing the lock should cause closed to reject and change identity`                              | FAIL    |
| `ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time`                                                                 | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise`                                                | FAIL    |
| `ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                        | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored`                                          | FAIL    |
| `ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined`                                                              | FAIL    |
| `ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession`                                                 | FAIL    |
| `Running templatedRSErroredReader with ReadableStream reader (errored before getting reader)`                                                                       | PASS    |
| `ReadableStream reader (closed after getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                                   | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start): locked should be false`                                                                        | FAIL    |
| `ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback`                               | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error`                                                    | FAIL    |
| `ReadableStream (empty) reader: locked should be true`                                                                                                              | FAIL    |
| `Running templatedRSClosedReader with ReadableStream reader (closed after getting reader)`                                                                          | PASS    |
| `ReadableStream reader (errored before getting reader): releasing the lock should cause closed to reject and change identity`                                       | FAIL    |
| `ReadableStream (closed via call in start): locked should be false`                                                                                                 | FAIL    |
| `ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time`                                                   | FAIL    |
| `ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result`                                        | FAIL    |
| `ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                                  | FAIL    |
| `ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity`                                         | FAIL    |
| `ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time`                                                | FAIL    |
| `ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError`                                                    | FAIL    |
| `Running templatedRSEmpty with ReadableStream (empty)`                                                                                                              | PASS    |
| `ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity`                                        | FAIL    |
| `ReadableStream reader (errored after getting reader): read() should reject with the error`                                                                         | FAIL    |
| `ReadableStream reader (closed before getting reader): closed should fulfill with undefined`                                                                        | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true` | FAIL    |
| `ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time`                                                          | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error`                                                    | FAIL    |
| `ReadableStream (empty): instances have the correct methods and properties`                                                                                         | FAIL    |
| `ReadableStream (closed via call in start): getReader() should be OK`                                                                                               | FAIL    |
| `ReadableStream reader (errored after getting reader): closed should reject with the error`                                                                         | FAIL    |
| `ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending`                               | FAIL    |
| `Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)`                                                                                | PASS    |
| `ReadableStream (closed via cancel): locked should be false`                                                                                                        | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)`                | FAIL    |
| `Running templatedRSErroredReader with ReadableStream reader (errored after getting reader)`                                                                        | PASS    |
| `ReadableStream reader (closed after getting reader): closed should fulfill with undefined`                                                                         | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)`                    | FAIL    |
| `ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }`                                       | FAIL    |
| `ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time`                                               | FAIL    |
| `ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity`                                        | FAIL    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false`                       | FAIL    |
| `ReadableStream (closed via cancel): getReader() should be OK`                                                                                                      | FAIL    |
| `ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }`                                                 | FAIL    |
| `ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError`                                                            | FAIL    |
| `ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise`                                             | FAIL    |
| `Running templatedRSClosed with ReadableStream (closed via call in start)`                                                                                          | PASS    |
| `ReadableStream reader (closed before getting reader): read() should work when used within another read() fulfill callback`                                         | FAIL    |
| `ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one`                                               | FAIL    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)`                           | FAIL    |
| `ReadableStream (empty) reader: canceling via the stream should fail`                                                                                               | FAIL    |
| `ReadableStream (empty) reader: read() should never settle`                                                                                                         | FAIL    |
| `Service worker test setup`                                                                                                                                         | PASS    |
| `ReadableStream reader (errored before getting reader): closed should reject with the error`                                                                        | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time`                                                  | FAIL    |
| `ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time`                                     | FAIL    |
| `ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }`                                                  | FAIL    |
| `ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed`                                                                     | FAIL    |
| `ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time`                                                          | FAIL    |
| `ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock`                                    | FAIL    |
| `ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity`                   | FAIL    |
| `ReadableStream (errored via call in start): read() twice should give the error each time`                                                                          | FAIL    |
| `ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one`                                        | FAIL    |
| `Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)`                                                                         | PASS    |
| `ReadableStream (empty) reader: read() should return distinct promises each time`                                                                                   | FAIL    |
| `Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader`                                                            | PASS    |
| `Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader`                                                               | PASS    |
| `Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader`                                                   | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/update-recovery.https.html">/service-workers/service-worker/update-recovery.https.html</a></summary>


|                                  Subtest                                   | Results |
|----------------------------------------------------------------------------|---------|
|                                                                            | OK      |
| `Recover from a bad service worker by updating after a failed navigation.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/fetch-response-xhr.https.html">/service-workers/service-worker/fetch-response-xhr.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Verify the response of FetchEvent using XMLHttpRequest` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/cache-storage/serviceworker/cache-add.https.html">/service-workers/cache-storage/serviceworker/cache-add.https.html</a></summary>


|                              Subtest                               | Results |
|--------------------------------------------------------------------|---------|
|                                                                    | OK      |
| `Cache.addAll with an empty array`                                 | PASS    |
| `Cache.addAll with string URL arguments`                           | PASS    |
| `Cache.add and Cache.addAll`                                       | PASS    |
| `Cache.add called with Request object`                             | PASS    |
| `Cache.add with 206 response`                                      | FAIL    |
| `Cache.addAll with a mix of succeeding and failing requests`       | PASS    |
| `Cache.add with request that results in a status of 404`           | PASS    |
| `Cache.addAll with 206 response`                                   | FAIL    |
| `Cache.addAll called with the same Request object specified twice` | PASS    |
| `Cache.add called with relative URL specified as a string`         | PASS    |
| `Cache.add called with non-HTTP/HTTPS URL`                         | PASS    |
| `Cache.add called twice with the same Request object`              | PASS    |
| `Cache.addAll with no arguments`                                   | PASS    |
| `Cache.addAll with Request arguments`                              | PASS    |
| `Cache.add with request that results in a status of 500`           | PASS    |
| `Cache.add called with no arguments`                               | PASS    |
| `Cache.addAll with a mix of valid and undefined arguments`         | PASS    |
| `Cache.add called with POST request`                               | PASS    |
| `Cache.add with request with null body (not consumed)`             | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/navigate-window.https.html">/service-workers/service-worker/navigate-window.https.html</a></summary>


|                                       Subtest                                        | Results |
|--------------------------------------------------------------------------------------|---------|
|                                                                                      | OK      |
| `Clients.matchAll() should not show an old window after it navigates.`               | PASS    |
| `Clients.matchAll() should not show an old window as controlled after it navigates.` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/serviceworker-message-event-historical.https.html">/service-workers/service-worker/serviceworker-message-event-historical.https.html</a></summary>


|                         Subtest                          | Results |
|----------------------------------------------------------|---------|
|                                                          | OK      |
| `Test MessageEvent supplants ServiceWorkerMessageEvent.` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/preload/fetch-destination.https.html">/preload/fetch-destination.https.html</a></summary>


|           Subtest           | Results |
|-----------------------------|---------|
|                             | OK      |
| `Fetch destination preload` | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/clients-get-cross-origin.https.html">/service-workers/service-worker/clients-get-cross-origin.https.html</a></summary>


|              Subtest              | Results |
|-----------------------------------|---------|
|                                   | OK      |
| `Test Clients.get() cross origin` | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4610/service-workers/service-worker/service-worker-csp-connect.https.html">/service-workers/service-worker/service-worker-csp-connect.https.html</a></summary>


|                        Subtest                         | Results |
|--------------------------------------------------------|---------|
|                                                        | OK      |
| `Fetch test for connect-src`                           | FAIL    |
| `CSP test for connect-src in ServiceWorkerGlobalScope` | PASS    |
| `importScripts test for connect-src`                   | PASS    |
| `Redirected fetch test for connect-src`                | FAIL    |

</details>

View on GitHub: https://github.com/w3c/web-platform-tests/pull/4610#issuecomment-279630262

Received on Tuesday, 14 February 2017 07:40:11 UTC