Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 212 insertions, 0 deletions

diff --git a/testing/web-platform/tests/streams/piping/general.any.js b/testing/web-platform/tests/streams/piping/general.any.js
new file mode 100644
index 0000000000..f051d8102c
--- /dev/null
+++ b/testing/web-platform/tests/streams/piping/general.any.js
@@ -0,0 +1,212 @@
+// META: global=window,worker,shadowrealm
+// META: script=../resources/recording-streams.js
+'use strict';
+
+test(() => {
+
+  const rs = new ReadableStream();
+  const ws = new WritableStream();
+
+  assert_false(rs.locked, 'sanity check: the ReadableStream must not start locked');
+  assert_false(ws.locked, 'sanity check: the WritableStream must not start locked');
+
+  rs.pipeTo(ws);
+
+  assert_true(rs.locked, 'the ReadableStream must become locked');
+  assert_true(ws.locked, 'the WritableStream must become locked');
+
+}, 'Piping must lock both the ReadableStream and WritableStream');
+
+promise_test(() => {
+
+  const rs = new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+  const ws = new WritableStream();
+
+  return rs.pipeTo(ws).then(() => {
+    assert_false(rs.locked, 'the ReadableStream must become unlocked');
+    assert_false(ws.locked, 'the WritableStream must become unlocked');
+  });
+
+}, 'Piping finishing must unlock both the ReadableStream and WritableStream');
+
+promise_test(t => {
+
+  const fakeRS = Object.create(ReadableStream.prototype);
+  const ws = new WritableStream();
+
+  return promise_rejects_js(t, TypeError, ReadableStream.prototype.pipeTo.apply(fakeRS, [ws]),
+    'pipeTo should reject with a TypeError');
+
+}, 'pipeTo must check the brand of its ReadableStream this value');
+
+promise_test(t => {
+
+  const rs = new ReadableStream();
+  const fakeWS = Object.create(WritableStream.prototype);
+
+  return promise_rejects_js(t, TypeError, ReadableStream.prototype.pipeTo.apply(rs, [fakeWS]),
+    'pipeTo should reject with a TypeError');
+
+}, 'pipeTo must check the brand of its WritableStream argument');
+
+promise_test(t => {
+
+  const rs = new ReadableStream();
+  const ws = new WritableStream();
+
+  rs.getReader();
+
+  assert_true(rs.locked, 'sanity check: the ReadableStream starts locked');
+  assert_false(ws.locked, 'sanity check: the WritableStream does not start locked');
+
+  return promise_rejects_js(t, TypeError, rs.pipeTo(ws)).then(() => {
+    assert_false(ws.locked, 'the WritableStream must still be unlocked');
+  });
+
+}, 'pipeTo must fail if the ReadableStream is locked, and not lock the WritableStream');
+
+promise_test(t => {
+
+  const rs = new ReadableStream();
+  const ws = new WritableStream();
+
+  ws.getWriter();
+
+  assert_false(rs.locked, 'sanity check: the ReadableStream does not start locked');
+  assert_true(ws.locked, 'sanity check: the WritableStream starts locked');
+
+  return promise_rejects_js(t, TypeError, rs.pipeTo(ws)).then(() => {
+    assert_false(rs.locked, 'the ReadableStream must still be unlocked');
+  });
+
+}, 'pipeTo must fail if the WritableStream is locked, and not lock the ReadableStream');
+
+promise_test(() => {
+
+  const CHUNKS = 10;
+
+  const rs = new ReadableStream({
+    start(c) {
+      for (let i = 0; i < CHUNKS; ++i) {
+        c.enqueue(i);
+      }
+      c.close();
+    }
+  });
+
+  const written = [];
+  const ws = new WritableStream({
+    write(chunk) {
+      written.push(chunk);
+    },
+    close() {
+      written.push('closed');
+    }
+  }, new CountQueuingStrategy({ highWaterMark: CHUNKS }));
+
+  return rs.pipeTo(ws).then(() => {
+    const targetValues = [];
+    for (let i = 0; i < CHUNKS; ++i) {
+      targetValues.push(i);
+    }
+    targetValues.push('closed');
+
+    assert_array_equals(written, targetValues, 'the correct values must be written');
+
+    // Ensure both readable and writable are closed by the time the pipe finishes.
+    return Promise.all([
+      rs.getReader().closed,
+      ws.getWriter().closed
+    ]);
+  });
+
+  // NOTE: no requirement on *when* the pipe finishes; that is left to implementations.
+
+}, 'Piping from a ReadableStream from which lots of chunks are synchronously readable');
+
+promise_test(t => {
+
+  let controller;
+  const rs = recordingReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+
+  const ws = recordingWritableStream();
+
+  const pipePromise = rs.pipeTo(ws).then(() => {
+    assert_array_equals(ws.events, ['write', 'Hello', 'close']);
+  });
+
+  t.step_timeout(() => {
+    controller.enqueue('Hello');
+    t.step_timeout(() => controller.close(), 10);
+  }, 10);
+
+  return pipePromise;
+
+}, 'Piping from a ReadableStream for which a chunk becomes asynchronously readable after the pipeTo');
+
+for (const preventAbort of [true, false]) {
+  promise_test(() => {
+
+    const rs = new ReadableStream({
+      pull() {
+        return Promise.reject(undefined);
+      }
+    });
+
+    return rs.pipeTo(new WritableStream(), { preventAbort }).then(
+        () => assert_unreached('pipeTo promise should be rejected'),
+        value => assert_equals(value, undefined, 'rejection value should be undefined'));
+
+  }, `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is ${preventAbort}`);
+}
+
+for (const preventCancel of [true, false]) {
+  promise_test(() => {
+
+    const rs = new ReadableStream({
+      pull(controller) {
+        controller.enqueue(0);
+      }
+    });
+
+    const ws = new WritableStream({
+      write() {
+        return Promise.reject(undefined);
+      }
+    });
+
+    return rs.pipeTo(ws, { preventCancel }).then(
+         () => assert_unreached('pipeTo promise should be rejected'),
+        value => assert_equals(value, undefined, 'rejection value should be undefined'));
+
+  }, `an undefined rejection from write should cause pipeTo() to reject when preventCancel is ${preventCancel}`);
+}
+
+promise_test(t => {
+  const rs = new ReadableStream();
+  const ws = new WritableStream();
+  return promise_rejects_js(t, TypeError, rs.pipeTo(ws, {
+    get preventAbort() {
+      ws.getWriter();
+    }
+  }), 'pipeTo should reject');
+}, 'pipeTo() should reject if an option getter grabs a writer');
+
+promise_test(t => {
+  const rs = new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+  const ws = new WritableStream();
+
+  return rs.pipeTo(ws, null);
+}, 'pipeTo() promise should resolve if null is passed');