Tests for https://github.com/whatwg/fetch/pull/435 #4518

jakearchibald · 2017-01-10T13:24:59Z

Summary of spec changes: Previously any fetches started within a service worker would bypass the service worker fetch event. We're changing this so only particular methods bypass the fetch event.

This PR tests the fetch, cache.all and notification APIs to ensure they use/bypass the fetch event as required.

No browser passes all the tests - Chrome and Firefox fail on the notification tests.

wpt-pr-bot · 2017-01-10T13:25:06Z

Notifying @ehsan and @mkruisselbrink. (Learn how reviewing works.)

ehsan · 2017-01-11T09:39:56Z

@wanderview Any chance you could review this please?

wanderview

Overall looks reasonable. It would be really nice if we could avoid the wait(1000) calls, though.

wanderview · 2017-01-11T16:59:52Z

service-workers/service-worker/fetch-event-within-sw-manual.html

+        });
+        notification.close();
+      }),
+      wait(1000).then(() => { throw Error(`Did not capture icon request for notification created from page`); })


Any way we can avoid these arbitrary delays? They tend to play havoc with automated tests on slow virtualized machines.

Could you set a cookie from the a server .py indicating the icon was loaded? Then the window could then poll for the completion cookie.

The broadcast channel does the same thing the cookie would. The problem is, how do you detect the icon wasn't loaded. That's what the timeout is currently doing.

Oh wait, the cookie would be detecting no-fetch-event. Sorry, I get it now.

wanderview · 2017-01-11T17:01:54Z

service-workers/service-worker/resources/fetch-event-within-sw-worker.js

+addEventListener('fetch', event => {
+  const url = new URL(event.request.url);
+
+  if (url.origin == location.origin) {


nit: Can you use short-circuit style logic? Like:

if (url.origin !== location.origin) { return; }

Doh! Of course. Schoolboy error.

wanderview · 2017-01-11T17:02:22Z

service-workers/service-worker/resources/test-helpers.sub.js

@@ -52,6 +52,7 @@ function unreached_rejection(test, prefix) {
 function with_iframe(url) {
  return new Promise(function(resolve) {
      var frame = document.createElement('iframe');
+      frame.className = 'test-iframe';


What does this do?

See reset() - it removes all elements with that class name.

wanderview · 2017-01-11T17:05:54Z

service-workers/service-worker/fetch-event-within-sw-manual.html

+
+        iframe.contentWindow.fetch('show-notification');
+      }),
+      wait(1000).then(() => { throw Error(`Did not capture icon request for notification created within SW`); })


For this wait(1000) you could wait for the Done text in the Response no? It seems all the async delays should be handled by then.

Interesting. Once the notification appears in the sequence returned by registration.getNotifications(), it must have made the fetch for the icon (if the browser is following the spec). But that means there's a race between calling showNotification and getNotification, since showNotification resolves before icon fetches.

Filed whatwg/notifications#90

jakearchibald · 2017-01-12T14:23:26Z

@wanderview great feedback - I've replaced the timeouts with cookies & polling.

sideshowbarker · 2017-01-12T16:00:55Z

w3c-test:mirror

jakearchibald · 2017-01-16T12:31:11Z

@wanderview I don't suppose you could give this a second review?

jakearchibald · 2017-01-25T13:25:42Z

@mkruisselbrink could you give this a look-through?

mkruisselbrink

I wonder if it might be a good idea to split out the manual test from the automated tests. Having them all in the same file kind of makes sense, but it would be unfortunate if that means that tests that could be run automated end up not being run as much because of the one manual test...

mkruisselbrink · 2017-01-25T17:52:56Z

service-workers/service-worker/fetch-event-within-sw-manual.html

+      notification.close();
+
+      return race.then(winner => {
+        assert_true(winner == 'broadcast', 'The service worker intercepted the from-window notification icon request');


nit: why not assert_equals?

mkruisselbrink · 2017-01-25T17:53:02Z

service-workers/service-worker/fetch-event-within-sw-manual.html

+      iframe.contentWindow.fetch(`show-notification?set-cookie-notification=${Math.random()}`);
+
+      return race.then(winner => {
+        assert_true(winner == 'broadcast', 'The service worker intercepted the from-service-worker notification icon request');


nit: why not assert_equals?

mkruisselbrink · 2017-01-25T17:56:10Z

service-workers/service-worker/fetch-event-within-sw-manual.html

+  return new Promise(r => setTimeout(r, ms));
+}
+
+function reset() {


Maybe it would be a good idea to not only call reset() at the beginning of your tests, but also have add_completion_callback(reset) somewhere to make sure things get cleaned up after running the tests

jakearchibald · 2017-02-13T14:45:24Z

Thanks for the feedback @mkruisselbrink!

I think I've addressed the issues - this should be good to merge.

w3c-bots · 2017-02-13T15:20:30Z

Chrome (unstable channel)

Testing web-platform-tests at revision 885f165
Using browser at version 58.0.3004.3 dev
Starting 10 test iterations

Unstable results

Test	Subtest	Results
`/service-workers/service-worker/request-end-to-end.https.html`		OK: 8/10, TIMEOUT: 2/10
`/service-workers/service-worker/request-end-to-end.https.html`	`Request: end-to-end`	FAIL: 8/10, TIMEOUT: 2/10

All results

/service-workers/service-worker/claim-using-registration.https.html

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

/service-workers/service-worker/claim-not-using-registration.https.html

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

/streams/readable-byte-streams/general.serviceworker.https.html

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`	PASS
`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

/streams/piping/multiple-propagation.serviceworker.https.html

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

/service-workers/service-worker/registration-service-worker-attributes.https.html

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

/service-workers/service-worker/register-closed-window.https.html

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

/streams/writable-streams/aborting.serviceworker.https.html

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

/streams/piping/flow-control.serviceworker.https.html

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

/service-workers/service-worker/register-default-scope.https.html

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

/service-workers/service-worker/service-worker-csp-default.https.html

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

/service-workers/cache-storage/serviceworker/cache-put.https.html

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

/service-workers/service-worker/skip-waiting-without-client.https.html

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

/service-workers/service-worker/xhr.https.html

Subtest	Results
	OK
`Verify XHR does not exist`	PASS

/service-workers/service-worker/fetch-event.https.html

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`	FAIL
`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.`	FAIL
`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`	FAIL
`Service Worker should intercept EventSource`	FAIL
`Service Worker does not respond to fetch event`	PASS

/service-workers/service-worker/fetch-request-redirect.https.html

Subtest	Results
	ERROR
`Verify redirect mode of Fetch API and ServiceWorker FetchEvent.`	FAIL
`Verify redirected of Response(Fetch API), Cache API and ServiceWorker FetchEvent.`	FAIL
`Verify redirected of Response(Fetch API) and ServiceWorker FetchEvent.`	FAIL

/service-workers/service-worker/register-wait-forever-in-install-worker.https.html

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

/service-workers/service-worker/invalid-blobtype.https.html

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

/service-workers/service-worker/referer.https.html

Subtest	Results
	OK
`Verify the referer`	PASS

/service-workers/service-worker/skip-waiting-installed.https.html

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

/streams/readable-streams/cancel.serviceworker.https.html

Subtest	Results
	OK
`ReadableStream cancellation: integration test on an infinite stream derived from a random push source`	PASS
`ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source`	PASS
`ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called`	PASS
`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`	PASS
`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`	PASS
`ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel`	PASS
`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)`	PASS
`Service worker test setup`	PASS
`ReadableStream cancellation: should fulfill promise when cancel callback went fine`	PASS
`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)`	PASS
`ReadableStream cancellation: should reject promise when cancel callback raises an exception`	PASS

/service-workers/service-worker/registration.https.html

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

/service-workers/service-worker/activation-after-registration.https.html

Subtest	Results
	OK
`activation occurs after registration`	PASS

/streams/piping/error-propagation-backward.serviceworker.https.html

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

/service-workers/service-worker/register-link-header.https.html

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

/service-workers/service-worker/fetch-event-async-respond-with.https.html

Subtest	Results
	TIMEOUT
`Calling respondWith asynchronously throws an exception`	TIMEOUT

/service-workers/service-worker/clients-matchall-client-types.https.html

Subtest	Results
	ERROR
`Verify matchAll() with various client types`	TIMEOUT

/service-workers/service-worker/getregistrations.https.html

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

/service-workers/service-worker/controller-on-reload.https.html

Subtest	Results
	OK
`controller is set upon reload after registration`	FAIL

/service-workers/cache-storage/serviceworker/cache-delete.https.html

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

/service-workers/service-worker/skip-waiting-using-registration.https.html

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

/service-workers/service-worker/interfaces.https.html

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

/service-workers/service-worker/state.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/update.https.html

Subtest	Results
	OK
`Update a registration on ServiceWorkerGlobalScope`	PASS

/streams/piping/close-propagation-forward.serviceworker.https.html

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

/service-workers/service-worker/fetch-request-xhr.https.html

Subtest	Results
	OK
`Verify the body of FetchEvent using XMLHttpRequest`	FAIL

/html/webappapis/scripting/events/messageevent-constructor.https.html

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

/streams/writable-streams/bad-strategies.serviceworker.https.html

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

/service-workers/service-worker/controller-on-load.https.html

Subtest	Results
	OK
`controller is set for a controlled document`	FAIL

/service-workers/service-worker/request-end-to-end.https.html

Subtest	Results
	OK: 8/10, TIMEOUT: 2/10
`Request: end-to-end`	FAIL: 8/10, TIMEOUT: 2/10

/streams/piping/transform-streams.serviceworker.https.html

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

/streams/writable-streams/write.serviceworker.https.html

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

/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html

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

/service-workers/cache-storage/serviceworker/cache-storage.https.html

Subtest	Results
	OK
`CacheStorage.open with an empty name`	PASS
`CacheStorage.open with no arguments`	PASS
`CacheStorage names are DOMStrings not USVStrings`	FAIL
`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

/service-workers/service-worker/register-same-scope-different-script-url.https.html

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

/service-workers/service-worker/fetch-cors-xhr.https.html

Subtest	Results
	OK
`Verify CORS XHR of fetch() in a Service Worker`	FAIL

/service-workers/service-worker/postmessage.https.html

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

/streams/readable-streams/bad-strategies.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-network-error.https.html

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

/service-workers/service-worker/navigation-redirect.https.html

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.`	FAIL
`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.`	FAIL
`SW-fallbacked redirect to other-origin in-scope.`	FAIL
`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

/service-workers/service-worker/activate-event-after-install-state-change.https.html

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

/service-workers/service-worker/synced-state.https.html

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

/service-workers/service-worker/ready.https.html

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

/service-workers/service-worker/install-event-type.https.html

Subtest	Results
	OK
`install event type`	PASS

/service-workers/service-worker/service-worker-csp-script.https.html

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

/service-workers/service-worker/fetch-request-resources.https.html

Subtest	Results
	OK
`Verify FetchEvent for resources.`	FAIL

/service-workers/service-worker/client-navigate.https.html

Subtest	Results
	TIMEOUT
`Frame location should update on successful navigation`	PASS
`Frame location should not update on failed navigation`	TIMEOUT
`Frame location should not be accessible after redirect`	PASS

/service-workers/service-worker/fetch-request-fallback.https.html

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

/service-workers/service-worker/unregister-then-register.https.html

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

/service-workers/service-worker/clients-get.https.html

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

/streams/count-queuing-strategy.serviceworker.https.html

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

/streams/piping/pipe-through.serviceworker.https.html

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

/streams/byte-length-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/extendable-event-waituntil.https.html

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

/service-workers/service-worker/registration-end-to-end.https.html

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

/streams/writable-streams/close.serviceworker.https.html

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

/service-workers/service-worker/activation.https.html

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

/service-workers/cache-storage/serviceworker/cache-matchAll.https.html

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`	FAIL
`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`	FAIL

/service-workers/service-worker/fetch-canvas-tainting-cache.https.html

Subtest	Results
	OK
`Verify canvas tainting of fetched image in a Service Worker`	FAIL

/service-workers/service-worker/onactivate-script-error.https.html

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

/service-workers/service-worker/fetch-mixed-content-to-inscope.https.html

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

/service-workers/service-worker/update-after-navigation-fetch-event.https.html

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

/service-workers/service-worker/skip-waiting-without-using-registration.https.html

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

/streams/piping/general.serviceworker.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/registration-attribute.https.html

Subtest	Results
	OK
`Verify registration attribute on ServiceWorkerGlobalScope`	PASS

/service-workers/service-worker/resource-timing.https.html

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

/service-workers/service-worker/fetch-header-visibility.https.html

Subtest	Results
	OK
`Visibility of defaulted headers during interception`	FAIL

/streams/readable-streams/templated.serviceworker.https.html

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

/streams/readable-streams/brand-checks.serviceworker.https.html

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

/streams/readable-streams/tee.serviceworker.https.html

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

/service-workers/service-worker/invalid-header.https.html

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

/service-workers/service-worker/registration-iframe.https.html

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

/service-workers/service-worker/unregister-then-register-new-script.https.html

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

/service-workers/service-worker/multiple-update.https.html

Subtest	Results
	OK
`Trigger multiple updates.`	PASS

/service-workers/service-worker/registration-events.https.html

Subtest	Results
	OK
`Registration: events`	PASS

/service-workers/service-worker/fetch-request-css-images.https.html

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

/service-workers/service-worker/fetch-request-no-freshness-headers.https.html

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

/streams/readable-streams/pipe-through.serviceworker.https.html

Subtest	Results
	OK
`ReadableStream.prototype.pipeThrough should throw when "this" has no pipeTo method`	PASS
`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`	PASS
`ReadableStream.prototype.pipeThrough should work with missing readable, writable, or options`	FAIL

/service-workers/service-worker/installing.https.html

Subtest	Results
	OK
`installing is set`	PASS

/service-workers/cache-storage/serviceworker/cache-storage-keys.https.html

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

/service-workers/service-worker/multiple-register.https.html

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

/service-workers/service-worker/indexeddb.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/unregister.https.html

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

/service-workers/service-worker/uncontrolled-page.https.html

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

/service-workers/service-worker/update.https.html

Subtest	Results
	OK
`Update a registration.`	PASS

/streams/piping/error-propagation-forward.serviceworker.https.html

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

/service-workers/service-worker/websocket.https.html

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

/service-workers/service-worker/register-link-element.https.html

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

/streams/writable-streams/count-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/postmessage-msgport-to-client.https.html

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

/service-workers/service-worker/fetch-mixed-content-to-outscope.https.html

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

/service-workers/service-worker/fetch-request-css-base-url.https.html

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

/service-workers/service-worker/getregistration.https.html

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

/service-workers/service-worker/waiting.https.html

Subtest	Results
	OK
`waiting or active is set`	PASS

/service-workers/service-worker/registration-useCache.https.html

Subtest	Results
	ERROR
`Test with useCache: true`	NOTRUN
`Test with useCache: default`	TIMEOUT
`Consecutive registrations with useCache settings(true, true)`	NOTRUN
`Consecutive registrations with useCache settings(false, false)`	NOTRUN
`Consecutive registrations with useCache settings(true, false)`	NOTRUN
`Test with useCache: false`	NOTRUN
`Consecutive registrations with useCache settings(false, true)`	NOTRUN

/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-respond-with-stops-propagation.https.html

Subtest	Results
	TIMEOUT
`respondWith() invokes stopImmediatePropagation()`	TIMEOUT

/service-workers/cache-storage/serviceworker/credentials.https.html

Subtest	Results
	OK
`Cache API matching includes credentials`	PASS

/service-workers/service-worker/oninstall-script-error.https.html

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

/service-workers/service-worker/serviceworkerobject-scripturl.https.html

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

/service-workers/cache-storage/serviceworker/cache-storage-match.https.html

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

/streams/readable-streams/general.serviceworker.https.html

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

/streams/readable-streams/readable-stream-reader.serviceworker.https.html

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

/service-workers/service-worker/unregister.https.html

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

/service-workers/service-worker/multi-globals/url-parsing.https.html

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`	FAIL
`register should use the relevant global of the object it was called on to resolve the script URL`	FAIL

/service-workers/service-worker/fetch-event-within-sw.html

Subtest	Results
	OK
`Service worker does not intercept fetch/cache requests within service worker`	FAIL
`Service worker intercepts requests from window`	FAIL

/service-workers/service-worker/fetch-canvas-tainting.https.html

Subtest	Results
	OK
`Verify canvas tainting of fetched image in a Service Worker`	FAIL

/streams/writable-streams/brand-checks.serviceworker.https.html

Subtest	Results
	OK
`Service worker test setup`	FAIL

/service-workers/service-worker/fetch-waits-for-activate.https.html

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

/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html

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

/service-workers/service-worker/clients-matchall-include-uncontrolled.https.html

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

/service-workers/service-worker/postmessage-to-client.https.html

Subtest	Results
	OK
`postMessage from ServiceWorker to Client`	PASS

/service-workers/service-worker/skip-waiting.https.html

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

/service-workers/service-worker/unregister-controller.https.html

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

/streams/readable-streams/garbage-collection.serviceworker.https.html

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

/service-workers/service-worker/appcache-ordering-main.https.html

Subtest	Results
	OK
`serviceworkers take priority over appcaches`	PASS

/service-workers/service-worker/fetch-frame-resource.https.html

Subtest	Results
	ERROR
`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.`	TIMEOUT
`Basic type response could be loaded in the iframe.`	PASS

/service-workers/service-worker/performance-timeline.https.html

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

/streams/writable-streams/start.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-after-navigation-within-page.https.html

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

/service-workers/service-worker/controller-on-disconnect.https.html

Subtest	Results
	OK
`controller is cleared on disconnected window`	FAIL

/service-workers/service-worker/update-after-oneday.https.html

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

/service-workers/service-worker/worker-interception.https.html

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`	FAIL
`Verify worker loads from controlled document are intercepted by Service Worker`	PASS
`Verify worker script intercepted by same-origin response succeeds`	FAIL
`Verify worker script intercepted by cors response succeeds`	FAIL

/streams/piping/close-propagation-backward.serviceworker.https.html

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

/service-workers/service-worker/clients-matchall.https.html

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

/streams/writable-streams/constructor.serviceworker.https.html

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

/service-workers/service-worker/fetch-csp.https.html

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

/service-workers/cache-storage/serviceworker/cache-match.https.html

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

/streams/writable-streams/general.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-redirect.https.html

Subtest	Results
	ERROR

/service-workers/service-worker/shared-worker-controlled.https.html

Subtest	Results
	OK
`Verify subresource loads in SharedWorker are controlled by a Service Worker`	PASS
`Verify SharedWorker construction is controlled by a Service Worker`	PASS
`Verify importScripts from SharedWorker is controlled by a Service Worker`	PASS

/service-workers/service-worker/active.https.html

Subtest	Results
	OK
`active is set`	PASS

/service-workers/service-worker/extendable-event-async-waituntil.https.html

Subtest	Results
	OK
`Test calling waitUntil in a different microtask without an existing extension throws`	FAIL
`Test calling waitUntil asynchronously with pending respondWith promise.`	FAIL
`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`	FAIL
`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`	FAIL
`Test calling waitUntil on a script constructed ExtendableEvent throws exception`	FAIL

/streams/readable-streams/bad-underlying-sources.serviceworker.https.html

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

/service-workers/service-worker/update-recovery.https.html

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

/service-workers/service-worker/fetch-response-xhr.https.html

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

/service-workers/cache-storage/serviceworker/cache-add.https.html

Subtest	Results
	ERROR
`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`	FAIL
`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)`	PASS

/service-workers/service-worker/navigate-window.https.html

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

/service-workers/service-worker/serviceworker-message-event-historical.https.html

Subtest	Results
	OK
`Test MessageEvent supplants ServiceWorkerMessageEvent.`	PASS

/preload/fetch-destination.https.html

Subtest	Results
	OK
`Fetch destination preload`	FAIL

/service-workers/service-worker/clients-get-cross-origin.https.html

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

/service-workers/service-worker/service-worker-csp-connect.https.html

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

w3c-bots · 2017-02-13T15:20:31Z

Firefox (nightly channel)

Testing web-platform-tests at revision 885f165
Using browser at version BuildID 20170123125947; SourceStamp 36486fdc3813ef7943ae5b07b4128866d1938a6c
Starting 10 test iterations
All results were stable

All results

/service-workers/service-worker/claim-using-registration.https.html

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

/service-workers/service-worker/claim-not-using-registration.https.html

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

/streams/readable-byte-streams/general.serviceworker.https.html

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

/streams/piping/multiple-propagation.serviceworker.https.html

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

/service-workers/service-worker/registration-service-worker-attributes.https.html

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

/service-workers/service-worker/register-closed-window.https.html

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

/streams/writable-streams/aborting.serviceworker.https.html

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

/streams/piping/flow-control.serviceworker.https.html

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

/service-workers/service-worker/register-default-scope.https.html

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

/service-workers/service-worker/service-worker-csp-default.https.html

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

/service-workers/cache-storage/serviceworker/cache-put.https.html

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

/service-workers/service-worker/skip-waiting-without-client.https.html

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

/service-workers/service-worker/xhr.https.html

Subtest	Results
	OK
`Verify XHR does not exist`	PASS

/service-workers/service-worker/fetch-event.https.html

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

/service-workers/service-worker/fetch-request-redirect.https.html

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

/service-workers/service-worker/register-wait-forever-in-install-worker.https.html

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

/service-workers/service-worker/invalid-blobtype.https.html

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

/service-workers/service-worker/referer.https.html

Subtest	Results
	OK
`Verify the referer`	PASS

/service-workers/service-worker/skip-waiting-installed.https.html

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

/streams/readable-streams/cancel.serviceworker.https.html

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

/service-workers/service-worker/registration.https.html

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

/service-workers/service-worker/activation-after-registration.https.html

Subtest	Results
	OK
`activation occurs after registration`	PASS

/streams/piping/error-propagation-backward.serviceworker.https.html

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

/service-workers/service-worker/register-link-header.https.html

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

/service-workers/service-worker/fetch-event-async-respond-with.https.html

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

/service-workers/service-worker/clients-matchall-client-types.https.html

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

/service-workers/service-worker/getregistrations.https.html

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

/service-workers/service-worker/controller-on-reload.https.html

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

/service-workers/cache-storage/serviceworker/cache-delete.https.html

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

/service-workers/service-worker/skip-waiting-using-registration.https.html

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

/service-workers/service-worker/interfaces.https.html

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

/service-workers/service-worker/state.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/update.https.html

Subtest	Results
	OK
`Update a registration on ServiceWorkerGlobalScope`	PASS

/streams/piping/close-propagation-forward.serviceworker.https.html

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

/service-workers/service-worker/fetch-request-xhr.https.html

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

/html/webappapis/scripting/events/messageevent-constructor.https.html

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

/streams/writable-streams/bad-strategies.serviceworker.https.html

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

/service-workers/service-worker/controller-on-load.https.html

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

/service-workers/service-worker/request-end-to-end.https.html

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

/streams/piping/transform-streams.serviceworker.https.html

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

/streams/writable-streams/write.serviceworker.https.html

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

/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html

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

/service-workers/cache-storage/serviceworker/cache-storage.https.html

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

/service-workers/service-worker/register-same-scope-different-script-url.https.html

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

/service-workers/service-worker/fetch-cors-xhr.https.html

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

/service-workers/service-worker/postmessage.https.html

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

/streams/readable-streams/bad-strategies.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-network-error.https.html

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

/service-workers/service-worker/navigation-redirect.https.html

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

/service-workers/service-worker/activate-event-after-install-state-change.https.html

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

/service-workers/service-worker/synced-state.https.html

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

/service-workers/service-worker/ready.https.html

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

/service-workers/service-worker/install-event-type.https.html

Subtest	Results
	OK
`install event type`	PASS

/service-workers/service-worker/service-worker-csp-script.https.html

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

/service-workers/service-worker/fetch-request-resources.https.html

Subtest	Results
	OK
`Verify FetchEvent for resources.`	PASS

/service-workers/service-worker/client-navigate.https.html

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

/service-workers/service-worker/fetch-request-fallback.https.html

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

/service-workers/service-worker/unregister-then-register.https.html

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

/service-workers/service-worker/clients-get.https.html

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

/streams/count-queuing-strategy.serviceworker.https.html

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

/streams/piping/pipe-through.serviceworker.https.html

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

/streams/byte-length-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/extendable-event-waituntil.https.html

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

/service-workers/service-worker/registration-end-to-end.https.html

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

/streams/writable-streams/close.serviceworker.https.html

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

/service-workers/service-worker/activation.https.html

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

/service-workers/cache-storage/serviceworker/cache-matchAll.https.html

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

/service-workers/service-worker/fetch-canvas-tainting-cache.https.html

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

/service-workers/service-worker/onactivate-script-error.https.html

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

/service-workers/service-worker/fetch-mixed-content-to-inscope.https.html

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

/service-workers/service-worker/update-after-navigation-fetch-event.https.html

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

/service-workers/service-worker/skip-waiting-without-using-registration.https.html

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

/streams/piping/general.serviceworker.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/registration-attribute.https.html

Subtest	Results
	OK
`Verify registration attribute on ServiceWorkerGlobalScope`	FAIL

/service-workers/service-worker/resource-timing.https.html

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

/service-workers/service-worker/fetch-header-visibility.https.html

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

/streams/readable-streams/templated.serviceworker.https.html

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

/streams/readable-streams/brand-checks.serviceworker.https.html

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

/streams/readable-streams/tee.serviceworker.https.html

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

/service-workers/service-worker/invalid-header.https.html

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

/service-workers/service-worker/registration-iframe.https.html

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

/service-workers/service-worker/unregister-then-register-new-script.https.html

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

/service-workers/service-worker/multiple-update.https.html

Subtest	Results
	OK
`Trigger multiple updates.`	PASS

/service-workers/service-worker/registration-events.https.html

Subtest	Results
	OK
`Registration: events`	PASS

/service-workers/service-worker/fetch-request-css-images.https.html

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

/service-workers/service-worker/fetch-request-no-freshness-headers.https.html

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

/streams/readable-streams/pipe-through.serviceworker.https.html

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

/service-workers/service-worker/installing.https.html

Subtest	Results
	OK
`installing is set`	PASS

/service-workers/cache-storage/serviceworker/cache-storage-keys.https.html

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

/service-workers/service-worker/multiple-register.https.html

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

/service-workers/service-worker/indexeddb.https.html

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

/service-workers/service-worker/ServiceWorkerGlobalScope/unregister.https.html

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

/service-workers/service-worker/uncontrolled-page.https.html

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

/service-workers/service-worker/update.https.html

Subtest	Results
	OK
`Update a registration.`	PASS

/streams/piping/error-propagation-forward.serviceworker.https.html

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

/service-workers/service-worker/websocket.https.html

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

/service-workers/service-worker/register-link-element.https.html

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

/streams/writable-streams/count-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/postmessage-msgport-to-client.https.html

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

/service-workers/service-worker/fetch-mixed-content-to-outscope.https.html

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

/service-workers/service-worker/fetch-request-css-base-url.https.html

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

/service-workers/service-worker/getregistration.https.html

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

/service-workers/service-worker/waiting.https.html

Subtest	Results
	OK
`waiting or active is set`	PASS

/service-workers/service-worker/registration-useCache.https.html

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

/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-respond-with-stops-propagation.https.html

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

/service-workers/cache-storage/serviceworker/credentials.https.html

Subtest	Results
	OK
`Cache API matching includes credentials`	PASS

/service-workers/service-worker/oninstall-script-error.https.html

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

/service-workers/service-worker/serviceworkerobject-scripturl.https.html

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

/service-workers/cache-storage/serviceworker/cache-storage-match.https.html

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

/streams/readable-streams/general.serviceworker.https.html

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

/streams/readable-streams/readable-stream-reader.serviceworker.https.html

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

/service-workers/service-worker/unregister.https.html

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

/service-workers/service-worker/multi-globals/url-parsing.https.html

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

/service-workers/service-worker/fetch-event-within-sw.html

Subtest	Results
	OK
`Service worker does not intercept fetch/cache requests within service worker`	FAIL
`Service worker intercepts requests from window`	FAIL

/service-workers/service-worker/fetch-canvas-tainting.https.html

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

/streams/writable-streams/brand-checks.serviceworker.https.html

Subtest	Results
	OK
`Service worker test setup`	FAIL

/service-workers/service-worker/fetch-waits-for-activate.https.html

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

/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html

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

/service-workers/service-worker/clients-matchall-include-uncontrolled.https.html

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

/service-workers/service-worker/postmessage-to-client.https.html

Subtest	Results
	OK
`postMessage from ServiceWorker to Client`	FAIL

/service-workers/service-worker/skip-waiting.https.html

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

/service-workers/service-worker/unregister-controller.https.html

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

/streams/readable-streams/garbage-collection.serviceworker.https.html

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
`Service worker test setup`	PASS
`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-workers/service-worker/appcache-ordering-main.https.html

Subtest	Results
	OK
`serviceworkers take priority over appcaches`	PASS

/service-workers/service-worker/fetch-frame-resource.https.html

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

/service-workers/service-worker/performance-timeline.https.html

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

/streams/writable-streams/start.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-after-navigation-within-page.https.html

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

/service-workers/service-worker/controller-on-disconnect.https.html

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

/service-workers/service-worker/update-after-oneday.https.html

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

/service-workers/service-worker/worker-interception.https.html

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

/streams/piping/close-propagation-backward.serviceworker.https.html

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

/service-workers/service-worker/clients-matchall.https.html

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

/streams/writable-streams/constructor.serviceworker.https.html

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

/service-workers/service-worker/fetch-csp.https.html

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

/service-workers/cache-storage/serviceworker/cache-match.https.html

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

/streams/writable-streams/general.serviceworker.https.html

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

/service-workers/service-worker/fetch-event-redirect.https.html

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

/service-workers/service-worker/shared-worker-controlled.https.html

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

/service-workers/service-worker/active.https.html

Subtest	Results
	OK
`active is set`	PASS

/service-workers/service-worker/extendable-event-async-waituntil.https.html

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

/streams/readable-streams/bad-underlying-sources.serviceworker.https.html

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

/service-workers/service-worker/update-recovery.https.html

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

/service-workers/service-worker/fetch-response-xhr.https.html

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

/service-workers/cache-storage/serviceworker/cache-add.https.html

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

/service-workers/service-worker/navigate-window.https.html

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

/service-workers/service-worker/serviceworker-message-event-historical.https.html

Subtest	Results
	OK
`Test MessageEvent supplants ServiceWorkerMessageEvent.`	FAIL

/preload/fetch-destination.https.html

Subtest	Results
	OK
`Fetch destination preload`	FAIL

/service-workers/service-worker/clients-get-cross-origin.https.html

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

/service-workers/service-worker/service-worker-csp-connect.https.html

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

jakearchibald · 2017-02-14T10:25:39Z

The travis failure is unrelated to this PR. Due to a rebase it thinks I wrote all of the tests.

This allows certain fetches within service workers to trigger fetch events. It also makes interception of redirects by foreign fetch possible. Tests: web-platform-tests/wpt#4518. Related service worker PR: w3c/ServiceWorker#1025. Fixes #303 and fixes #362.

wpt-pr-bot added service-workers wg-webplatform labels Jan 10, 2017

jakearchibald mentioned this pull request Jan 10, 2017

Changing skip-service-worker flag to use-service-workers enum whatwg/fetch#435

Merged

wanderview requested changes Jan 11, 2017

View reviewed changes

mkruisselbrink reviewed Jan 25, 2017

View reviewed changes

jakearchibald added 7 commits February 13, 2017 14:43

Tests for whatwg/fetch#435

61d3c7f

Marking test as manual

4f63637

Removing trailing whitespace

5b41cce

Removing need for timeout in test

f65db43

Comments

1fee869

Removing trailing whitespace

be01fd3

Minor changes & splitting manual tests from automated one

a6a7620

jakearchibald force-pushed the fetch-within-serviceworker-tests branch from 49d1eec to a6a7620 Compare February 13, 2017 14:43

Ms2ger merged commit 6dbe2c7 into web-platform-tests:master Feb 14, 2017

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tests for https://github.com/whatwg/fetch/pull/435 #4518

Tests for https://github.com/whatwg/fetch/pull/435 #4518

jakearchibald commented Jan 10, 2017

wpt-pr-bot commented Jan 10, 2017

ehsan commented Jan 11, 2017

wanderview left a comment

wanderview Jan 11, 2017

wanderview Jan 11, 2017

jakearchibald Jan 11, 2017

jakearchibald Jan 12, 2017

wanderview Jan 11, 2017

jakearchibald Jan 11, 2017

wanderview Jan 11, 2017

jakearchibald Jan 11, 2017

wanderview Jan 11, 2017

jakearchibald Jan 11, 2017

jakearchibald Jan 11, 2017

jakearchibald commented Jan 12, 2017

sideshowbarker commented Jan 12, 2017

jakearchibald commented Jan 16, 2017

jakearchibald commented Jan 25, 2017

mkruisselbrink left a comment

mkruisselbrink Jan 25, 2017

mkruisselbrink Jan 25, 2017

mkruisselbrink Jan 25, 2017

jakearchibald commented Feb 13, 2017

w3c-bots commented Feb 13, 2017 •

edited

Loading

w3c-bots commented Feb 13, 2017 •

edited

Loading

jakearchibald commented Feb 14, 2017

Tests for https://github.com/whatwg/fetch/pull/435 #4518

Tests for https://github.com/whatwg/fetch/pull/435 #4518

Conversation

jakearchibald commented Jan 10, 2017

wpt-pr-bot commented Jan 10, 2017

ehsan commented Jan 11, 2017

wanderview left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jakearchibald commented Jan 12, 2017

sideshowbarker commented Jan 12, 2017

jakearchibald commented Jan 16, 2017

jakearchibald commented Jan 25, 2017

mkruisselbrink left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jakearchibald commented Feb 13, 2017

w3c-bots commented Feb 13, 2017 • edited Loading

Chrome (unstable channel)

Unstable results

All results

w3c-bots commented Feb 13, 2017 • edited Loading

Firefox (nightly channel)

All results

jakearchibald commented Feb 14, 2017

w3c-bots commented Feb 13, 2017 •

edited

Loading

w3c-bots commented Feb 13, 2017 •

edited

Loading