Add m-esr52 at 52.6.0

4 files changed, 876 insertions, 0 deletions

diff --git a/testing/web-platform/tests/streams/resources/rs-test-templates.js b/testing/web-platform/tests/streams/resources/rs-test-templates.js
new file mode 100644
index 000000000..e36463ba7
--- /dev/null
+++ b/testing/web-platform/tests/streams/resources/rs-test-templates.js
@@ -0,0 +1,634 @@
+'use strict';
+
+// These tests can be run against any readable stream produced by the web platform that meets the given descriptions.
+// For readable stream tests, the factory should return the stream. For reader tests, the factory should return a
+// { stream, reader } object. (You can use this to vary the time at which you acquire a reader.)
+
+self.templatedRSEmpty = (label, factory) => {
+  test(() => {}, 'Running templatedRSEmpty with ' + label);
+
+  test(() => {
+
+    const rs = factory();
+
+    assert_equals(typeof rs.locked, 'boolean', 'has a boolean locked getter');
+    assert_equals(typeof rs.cancel, 'function', 'has a cancel method');
+    assert_equals(typeof rs.getReader, 'function', 'has a getReader method');
+    assert_equals(typeof rs.pipeThrough, 'function', 'has a pipeThrough method');
+    assert_equals(typeof rs.pipeTo, 'function', 'has a pipeTo method');
+    assert_equals(typeof rs.tee, 'function', 'has a tee method');
+
+  }, 'instances have the correct methods and properties');
+
+  test(() => {
+    const rs = factory();
+
+    assert_throws(new RangeError(), () => rs.getReader({ mode: '' }), 'empty string mode should throw');
+    assert_throws(new RangeError(), () => rs.getReader({ mode: null }), 'null mode should throw');
+    assert_throws(new RangeError(), () => rs.getReader({ mode: 'asdf' }), 'asdf mode should throw');
+    assert_throws(new TypeError(), () => rs.getReader(null), 'null should throw');
+
+  }, 'calling getReader with invalid arguments should throw appropriate errors');
+};
+
+self.templatedRSClosed = (label, factory) => {
+  test(() => {}, 'Running templatedRSClosed with ' + label);
+
+  promise_test(() => {
+
+    const rs = factory();
+    const cancelPromise1 = rs.cancel();
+    const cancelPromise2 = rs.cancel();
+
+    assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
+
+    return Promise.all([
+      cancelPromise1.then(v => assert_equals(v, undefined, 'first cancel() call should fulfill with undefined')),
+      cancelPromise2.then(v => assert_equals(v, undefined, 'second cancel() call should fulfill with undefined'))
+    ]);
+
+  }, 'cancel() should return a distinct fulfilled promise each time');
+
+  test(() => {
+
+    const rs = factory();
+    assert_false(rs.locked, 'locked getter should return false');
+
+  }, 'locked should be false');
+
+  test(() => {
+
+    const rs = factory();
+    rs.getReader(); // getReader() should not throw.
+
+  }, 'getReader() should be OK');
+
+  test(() => {
+
+    const rs = factory();
+
+    const reader = rs.getReader();
+    reader.releaseLock();
+
+    const reader2 = rs.getReader(); // Getting a second reader should not throw.
+    reader2.releaseLock();
+
+    rs.getReader(); // Getting a third reader should not throw.
+
+  }, 'should be able to acquire multiple readers if they are released in succession');
+
+  test(() => {
+
+    const rs = factory();
+
+    rs.getReader();
+
+    assert_throws(new TypeError(), () => rs.getReader(), 'getting a second reader should throw');
+    assert_throws(new TypeError(), () => rs.getReader(), 'getting a third reader should throw');
+
+  }, 'should not be able to acquire a second reader if we don\'t release the first one');
+};
+
+self.templatedRSErrored = (label, factory, error) => {
+  test(() => {}, 'Running templatedRSErrored with ' + label);
+
+  promise_test(t => {
+
+    const rs = factory();
+    const reader = rs.getReader();
+
+    return Promise.all([
+      promise_rejects(t, error, reader.closed),
+      promise_rejects(t, error, reader.read())
+    ]);
+
+  }, 'getReader() should return a reader that acts errored');
+
+  promise_test(t => {
+
+    const rs = factory();
+    const reader = rs.getReader();
+
+    return Promise.all([
+      promise_rejects(t, error, reader.read()),
+      promise_rejects(t, error, reader.read()),
+      promise_rejects(t, error, reader.closed)
+    ]);
+
+  }, 'read() twice should give the error each time');
+
+  test(() => {
+    const rs = factory();
+
+    assert_false(rs.locked, 'locked getter should return false');
+  }, 'locked should be false');
+};
+
+self.templatedRSErroredSyncOnly = (label, factory, error) => {
+  test(() => {}, 'Running templatedRSErroredSyncOnly with ' + label);
+
+  promise_test(t => {
+
+    const rs = factory();
+    rs.getReader().releaseLock();
+    const reader = rs.getReader(); // Calling getReader() twice does not throw (the stream is not locked).
+
+    return promise_rejects(t, error, reader.closed);
+
+  }, 'should be able to obtain a second reader, with the correct closed promise');
+
+  test(() => {
+
+    const rs = factory();
+    rs.getReader();
+
+    assert_throws(new TypeError(), () => rs.getReader(), 'getting a second reader should throw a TypeError');
+    assert_throws(new TypeError(), () => rs.getReader(), 'getting a third reader should throw a TypeError');
+
+  }, 'should not be able to obtain additional readers if we don\'t release the first lock');
+
+  promise_test(t => {
+
+    const rs = factory();
+    const cancelPromise1 = rs.cancel();
+    const cancelPromise2 = rs.cancel();
+
+    assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
+
+    return Promise.all([
+      promise_rejects(t, error, cancelPromise1),
+      promise_rejects(t, error, cancelPromise2)
+    ]);
+
+  }, 'cancel() should return a distinct rejected promise each time');
+
+  promise_test(t => {
+
+    const rs = factory();
+    const reader = rs.getReader();
+    const cancelPromise1 = reader.cancel();
+    const cancelPromise2 = reader.cancel();
+
+    assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
+
+    return Promise.all([
+      promise_rejects(t, error, cancelPromise1),
+      promise_rejects(t, error, cancelPromise2)
+    ]);
+
+  }, 'reader cancel() should return a distinct rejected promise each time');
+};
+
+self.templatedRSEmptyReader = (label, factory) => {
+  test(() => {}, 'Running templatedRSEmptyReader with ' + label);
+
+  test(() => {
+
+    const reader = factory().reader;
+
+    assert_true('closed' in reader, 'has a closed property');
+    assert_equals(typeof reader.closed.then, 'function', 'closed property is thenable');
+
+    assert_equals(typeof reader.cancel, 'function', 'has a cancel method');
+    assert_equals(typeof reader.read, 'function', 'has a read method');
+    assert_equals(typeof reader.releaseLock, 'function', 'has a releaseLock method');
+
+  }, 'instances have the correct methods and properties');
+
+  test(() => {
+
+    const stream = factory().stream;
+
+    assert_true(stream.locked, 'locked getter should return true');
+
+  }, 'locked should be true');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+
+    reader.read().then(
+      t.unreached_func('read() should not fulfill'),
+      t.unreached_func('read() should not reject')
+    );
+
+    return delay(500);
+
+  }, 'read() should never settle');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+
+    reader.read().then(
+      t.unreached_func('read() should not fulfill'),
+      t.unreached_func('read() should not reject')
+    );
+
+    reader.read().then(
+      t.unreached_func('read() should not fulfill'),
+      t.unreached_func('read() should not reject')
+    );
+
+    return delay(500);
+
+  }, 'two read()s should both never settle');
+
+  test(() => {
+
+    const reader = factory().reader;
+    assert_not_equals(reader.read(), reader.read(), 'the promises returned should be distinct');
+
+  }, 'read() should return distinct promises each time');
+
+  test(() => {
+
+    const stream = factory().stream;
+    assert_throws(new TypeError(), () => stream.getReader(), 'stream.getReader() should throw a TypeError');
+
+  }, 'getReader() again on the stream should fail');
+
+  promise_test(t => {
+
+    const streamAndReader = factory();
+    const stream = streamAndReader.stream;
+    const reader = streamAndReader.reader;
+
+    reader.read().then(
+      t.unreached_func('first read() should not fulfill'),
+      t.unreached_func('first read() should not reject')
+    );
+
+    reader.read().then(
+      t.unreached_func('second read() should not fulfill'),
+      t.unreached_func('second read() should not reject')
+    );
+
+    reader.closed.then(
+      t.unreached_func('closed should not fulfill'),
+      t.unreached_func('closed should not reject')
+    );
+
+    assert_throws(new TypeError(), () => reader.releaseLock(), 'releaseLock should throw a TypeError');
+
+    assert_true(stream.locked, 'the stream should still be locked');
+
+    return delay(500);
+
+  }, 'releasing the lock with pending read requests should throw but the read requests should stay pending');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+    reader.releaseLock();
+
+    return Promise.all([
+      promise_rejects(t, new TypeError(), reader.read()),
+      promise_rejects(t, new TypeError(), reader.read())
+    ]);
+
+  }, 'releasing the lock should cause further read() calls to reject with a TypeError');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+
+    const closedBefore = reader.closed;
+    reader.releaseLock();
+    const closedAfter = reader.closed;
+
+    assert_equals(closedBefore, closedAfter, 'the closed promise should not change identity');
+
+    return promise_rejects(t, new TypeError(), closedBefore);
+
+  }, 'releasing the lock should cause closed calls to reject with a TypeError');
+
+  test(() => {
+
+    const streamAndReader = factory();
+    const stream = streamAndReader.stream;
+    const reader = streamAndReader.reader;
+
+    reader.releaseLock();
+    assert_false(stream.locked, 'locked getter should return false');
+
+  }, 'releasing the lock should cause locked to become false');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+    reader.cancel();
+
+    return reader.read().then(r => {
+      assert_object_equals(r, { value: undefined, done: true }, 'read()ing from the reader should give a done result');
+    });
+
+  }, 'canceling via the reader should cause the reader to act closed');
+
+  promise_test(t => {
+
+    const stream = factory().stream;
+    return promise_rejects(t, new TypeError(), stream.cancel());
+
+  }, 'canceling via the stream should fail');
+};
+
+self.templatedRSClosedReader = (label, factory) => {
+  test(() => {}, 'Running templatedRSClosedReader with ' + label);
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return reader.read().then(v => {
+      assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+    });
+
+  }, 'read() should fulfill with { value: undefined, done: true }');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return Promise.all([
+      reader.read().then(v => {
+        assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+      }),
+      reader.read().then(v => {
+        assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+      })
+    ]);
+
+  }, 'read() multiple times should fulfill with { value: undefined, done: true }');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return reader.read().then(() => reader.read()).then(v => {
+      assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+    });
+
+  }, 'read() should work when used within another read() fulfill callback');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return reader.closed.then(v => assert_equals(v, undefined, 'reader closed should fulfill with undefined'));
+
+  }, 'closed should fulfill with undefined');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+
+    const closedBefore = reader.closed;
+    reader.releaseLock();
+    const closedAfter = reader.closed;
+
+    assert_not_equals(closedBefore, closedAfter, 'the closed promise should change identity');
+
+    return Promise.all([
+      closedBefore.then(v => assert_equals(v, undefined, 'reader.closed acquired before release should fulfill')),
+      promise_rejects(t, new TypeError(), closedAfter)
+    ]);
+
+  }, 'releasing the lock should cause closed to reject and change identity');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+    const cancelPromise1 = reader.cancel();
+    const cancelPromise2 = reader.cancel();
+    const closedReaderPromise = reader.closed;
+
+    assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
+    assert_not_equals(cancelPromise1, closedReaderPromise, 'cancel() promise 1 should be distinct from reader.closed');
+    assert_not_equals(cancelPromise2, closedReaderPromise, 'cancel() promise 2 should be distinct from reader.closed');
+
+    return Promise.all([
+      cancelPromise1.then(v => assert_equals(v, undefined, 'first cancel() should fulfill with undefined')),
+      cancelPromise2.then(v => assert_equals(v, undefined, 'second cancel() should fulfill with undefined'))
+    ]);
+
+  }, 'cancel() should return a distinct fulfilled promise each time');
+};
+
+self.templatedRSErroredReader = (label, factory, error) => {
+  test(() => {}, 'Running templatedRSErroredReader with ' + label);
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+    return promise_rejects(t, error, reader.closed);
+
+  }, 'closed should reject with the error');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+    const closedBefore = reader.closed;
+
+    return promise_rejects(t, error, closedBefore).then(() => {
+      reader.releaseLock();
+
+      const closedAfter = reader.closed;
+      assert_not_equals(closedBefore, closedAfter, 'the closed promise should change identity');
+
+      return promise_rejects(t, new TypeError(), closedAfter);
+    });
+
+  }, 'releasing the lock should cause closed to reject and change identity');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+    return promise_rejects(t, error, reader.read());
+
+  }, 'read() should reject with the error');
+};
+
+self.templatedRSTwoChunksOpenReader = (label, factory, chunks) => {
+  test(() => {}, 'Running templatedRSTwoChunksOpenReader with ' + label);
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return Promise.all([
+      reader.read().then(r => {
+        assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
+      }),
+      reader.read().then(r => {
+        assert_object_equals(r, { value: chunks[1], done: false }, 'second result should be correct');
+      })
+    ]);
+
+  }, 'calling read() twice without waiting will eventually give both chunks (sequential)');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return reader.read().then(r => {
+      assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
+
+      return reader.read().then(r2 => {
+        assert_object_equals(r2, { value: chunks[1], done: false }, 'second result should be correct');
+      });
+    });
+
+  }, 'calling read() twice without waiting will eventually give both chunks (nested)');
+
+  test(() => {
+
+    const reader = factory().reader;
+    assert_not_equals(reader.read(), reader.read(), 'the promises returned should be distinct');
+
+  }, 'read() should return distinct promises each time');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    const promise1 = reader.closed.then(v => {
+      assert_equals(v, undefined, 'reader closed should fulfill with undefined');
+    });
+
+    const promise2 = reader.read().then(r => {
+      assert_object_equals(r, { value: chunks[0], done: false },
+                           'promise returned before cancellation should fulfill with a chunk');
+    });
+
+    reader.cancel();
+
+    const promise3 = reader.read().then(r => {
+      assert_object_equals(r, { value: undefined, done: true },
+                           'promise returned after cancellation should fulfill with an end-of-stream signal');
+    });
+
+    return Promise.all([promise1, promise2, promise3]);
+
+  }, 'cancel() after a read() should still give that single read result');
+};
+
+self.templatedRSTwoChunksClosedReader = function (label, factory, chunks) {
+  test(() => {}, 'Running templatedRSTwoChunksClosedReader with ' + label);
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return Promise.all([
+      reader.read().then(r => {
+        assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
+      }),
+      reader.read().then(r => {
+        assert_object_equals(r, { value: chunks[1], done: false }, 'second result should be correct');
+      }),
+      reader.read().then(r => {
+        assert_object_equals(r, { value: undefined, done: true }, 'third result should be correct');
+      })
+    ]);
+
+  }, 'third read(), without waiting, should give { value: undefined, done: true } (sequential)');
+
+  promise_test(() => {
+
+    const reader = factory().reader;
+
+    return reader.read().then(r => {
+      assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
+
+      return reader.read().then(r2 => {
+        assert_object_equals(r2, { value: chunks[1], done: false }, 'second result should be correct');
+
+        return reader.read().then(r3 => {
+          assert_object_equals(r3, { value: undefined, done: true }, 'third result should be correct');
+        });
+      });
+    });
+
+  }, 'third read(), without waiting, should give { value: undefined, done: true } (nested)');
+
+  promise_test(() => {
+
+    const streamAndReader = factory();
+    const stream = streamAndReader.stream;
+    const reader = streamAndReader.reader;
+
+    assert_true(stream.locked, 'stream should start locked');
+
+    const promise = reader.closed.then(v => {
+      assert_equals(v, undefined, 'reader closed should fulfill with undefined');
+      assert_true(stream.locked, 'stream should remain locked');
+    });
+
+    reader.read();
+    reader.read();
+
+    return promise;
+
+  }, 'draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true');
+
+  promise_test(() => {
+
+    const streamAndReader = factory();
+    const stream = streamAndReader.stream;
+    const reader = streamAndReader.reader;
+
+    const promise = reader.closed.then(() => {
+      assert_true(stream.locked, 'the stream should start locked');
+      reader.releaseLock(); // Releasing the lock after reader closed should not throw.
+      assert_false(stream.locked, 'the stream should end unlocked');
+    });
+
+    reader.read();
+    reader.read();
+
+    return promise;
+
+  }, 'releasing the lock after the stream is closed should cause locked to become false');
+
+  promise_test(t => {
+
+    const reader = factory().reader;
+
+    reader.releaseLock();
+
+    return Promise.all([
+      promise_rejects(t, new TypeError(), reader.read()),
+      promise_rejects(t, new TypeError(), reader.read()),
+      promise_rejects(t, new TypeError(), reader.read())
+    ]);
+
+  }, 'releasing the lock should cause further read() calls to reject with a TypeError');
+
+  promise_test(() => {
+
+    const streamAndReader = factory();
+    const stream = streamAndReader.stream;
+    const reader = streamAndReader.reader;
+
+    const readerClosed = reader.closed;
+
+    assert_equals(reader.closed, readerClosed, 'accessing reader.closed twice in succession gives the same value');
+
+    const promise = reader.read().then(() => {
+      assert_equals(reader.closed, readerClosed, 'reader.closed is the same after read() fulfills');
+
+      reader.releaseLock();
+
+      assert_equals(reader.closed, readerClosed, 'reader.closed is the same after releasing the lock');
+
+      const newReader = stream.getReader();
+      return newReader.read();
+    });
+
+    assert_equals(reader.closed, readerClosed, 'reader.closed is the same after calling read()');
+
+    return promise;
+
+  }, 'reader\'s closed property always returns the same promise');
+};
diff --git a/testing/web-platform/tests/streams/resources/rs-utils.js b/testing/web-platform/tests/streams/resources/rs-utils.js
new file mode 100644
index 000000000..0f3222e23
--- /dev/null
+++ b/testing/web-platform/tests/streams/resources/rs-utils.js
@@ -0,0 +1,185 @@
+'use strict';
+(function () {
+
+  class RandomPushSource {
+    constructor(toPush) {
+      this.pushed = 0;
+      this.toPush = toPush;
+      this.started = false;
+      this.paused = false;
+      this.closed = false;
+
+      this._intervalHandle = null;
+    }
+
+    readStart() {
+      if (this.closed) {
+        return;
+      }
+
+      if (!this.started) {
+        this._intervalHandle = setInterval(writeChunk, 2);
+        this.started = true;
+      }
+
+      if (this.paused) {
+        this._intervalHandle = setInterval(writeChunk, 2);
+        this.paused = false;
+      }
+
+      const source = this;
+      function writeChunk() {
+        if (source.paused) {
+          return;
+        }
+
+        source.pushed++;
+
+        if (source.toPush > 0 && source.pushed > source.toPush) {
+          if (source._intervalHandle) {
+            clearInterval(source._intervalHandle);
+            source._intervalHandle = undefined;
+          }
+          source.closed = true;
+          source.onend();
+        } else {
+          source.ondata(randomChunk(128));
+        }
+      }
+    }
+
+    readStop() {
+      if (this.paused) {
+        return;
+      }
+
+      if (this.started) {
+        this.paused = true;
+        clearInterval(this._intervalHandle);
+        this._intervalHandle = undefined;
+      } else {
+        throw new Error('Can\'t pause reading an unstarted source.');
+      }
+    }
+  }
+
+  function randomChunk(size) {
+    let chunk = '';
+
+    for (let i = 0; i < size; ++i) {
+      // Add a random character from the basic printable ASCII set.
+      chunk += String.fromCharCode(Math.round(Math.random() * 84) + 32);
+    }
+
+    return chunk;
+  }
+
+  function readableStreamToArray(readable, reader) {
+    if (reader === undefined) {
+      reader = readable.getReader();
+    }
+
+    const chunks = [];
+
+    return pump();
+
+    function pump() {
+      return reader.read().then(result => {
+        if (result.done) {
+          return chunks;
+        }
+
+        chunks.push(result.value);
+        return pump();
+      });
+    }
+  }
+
+  class SequentialPullSource {
+    constructor(limit, options) {
+      const async = options && options.async;
+
+      this.current = 0;
+      this.limit = limit;
+      this.opened = false;
+      this.closed = false;
+
+      this._exec = f => f();
+      if (async) {
+        this._exec = f => setTimeout(f, 0);
+      }
+    }
+
+    open(cb) {
+      this._exec(() => {
+        this.opened = true;
+        cb();
+      });
+    }
+
+    read(cb) {
+      this._exec(() => {
+        if (++this.current <= this.limit) {
+          cb(null, false, this.current);
+        } else {
+          cb(null, true, null);
+        }
+      });
+    }
+
+    close(cb) {
+      this._exec(() => {
+        this.closed = true;
+        cb();
+      });
+    }
+  }
+
+  function sequentialReadableStream(limit, options) {
+    const sequentialSource = new SequentialPullSource(limit, options);
+
+    const stream = new ReadableStream({
+      start() {
+        return new Promise((resolve, reject) => {
+          sequentialSource.open(err => {
+            if (err) {
+              reject(err);
+            }
+            resolve();
+          });
+        });
+      },
+
+      pull(c) {
+        return new Promise((resolve, reject) => {
+          sequentialSource.read((err, done, chunk) => {
+            if (err) {
+              reject(err);
+            } else if (done) {
+              sequentialSource.close(err2 => {
+                if (err2) {
+                  reject(err2);
+                }
+                c.close();
+                resolve();
+              });
+            } else {
+              c.enqueue(chunk);
+              resolve();
+            }
+          });
+        });
+      }
+    });
+
+    stream.source = sequentialSource;
+
+    return stream;
+  }
+
+
+  self.RandomPushSource = RandomPushSource;
+  self.readableStreamToArray = readableStreamToArray;
+  self.sequentialReadableStream = sequentialReadableStream;
+
+}());
diff --git a/testing/web-platform/tests/streams/resources/test-initializer.js b/testing/web-platform/tests/streams/resources/test-initializer.js
new file mode 100644
index 000000000..d6ed4a7aa
--- /dev/null
+++ b/testing/web-platform/tests/streams/resources/test-initializer.js
@@ -0,0 +1,14 @@
+'use strict';
+
+function worker_test(file) {
+  fetch_tests_from_worker(new Worker(file));
+  if (typeof SharedWorker === 'function') {
+    fetch_tests_from_worker(new SharedWorker(file));
+  } else {
+    test(() => {
+      assert_unreached('SharedWorker is unavailable');
+    }, 'Load ' + file + ' with SharedWorker');
+  }
+  service_worker_test(file);
+}
+
diff --git a/testing/web-platform/tests/streams/resources/test-utils.js b/testing/web-platform/tests/streams/resources/test-utils.js
new file mode 100644
index 000000000..cc47898a6
--- /dev/null
+++ b/testing/web-platform/tests/streams/resources/test-utils.js
@@ -0,0 +1,43 @@
+'use strict';
+
+self.getterRejects = (t, obj, getterName, target) => {
+  const getter = Object.getOwnPropertyDescriptor(obj, getterName).get;
+
+  return promise_rejects(t, new TypeError(), getter.call(target));
+};
+
+self.methodRejects = (t, obj, methodName, target) => {
+  const method = obj[methodName];
+
+  return promise_rejects(t, new TypeError(), method.call(target));
+};
+
+self.getterThrows = (obj, getterName, target) => {
+  const getter = Object.getOwnPropertyDescriptor(obj, getterName).get;
+
+  assert_throws(new TypeError(), () => getter.call(target), getterName + ' should throw a TypeError');
+};
+
+self.methodThrows = (obj, methodName, target, args) => {
+  const method = obj[methodName];
+
+  assert_throws(new TypeError(), () => method.apply(target, args), methodName + ' should throw a TypeError');
+};
+
+self.garbageCollect = () => {
+  if (self.gc) {
+    // Use --expose_gc for V8 (and Node.js)
+    // Exposed in SpiderMonkey shell as well
+    self.gc();
+  } else if (self.GCController) {
+    // Present in some WebKit development environments
+    GCController.collect();
+  } else {
+    /* eslint-disable no-console */
+    console.warn('Tests are running without the ability to do manual garbage collection. They will still work, but ' +
+      'coverage will be suboptimal.');
+    /* eslint-enable no-console */
+  }
+};
+
+self.delay = ms => new Promise(resolve => step_timeout(resolve, ms));