Test https://w3c.github.io/webtransport/#webtransportreceivestream-pull-bytes

From WebKit/WebKit#70271

Author: achristensen07

webtransport/receive-stream-pull.https.any.js

@@ -0,0 +1,111 @@
+// META: global=window,worker
+// META: script=resources/webtransport-test-helpers.sub.js
+// META: timeout=long
+
+// Tests the pull steps of a WebTransportReceiveStream:
+// https://w3c.github.io/webtransport/#webtransportreceivestream-pull-bytes
+
+// Returns a bidirectional stream whose readable end receives |data| echoed back
+// by the server, followed by FIN.
+async function echo_bidirectional_stream(wt, data) {
+  const bidi_stream = await wt.createBidirectionalStream();
+  const writer = bidi_stream.writable.getWriter();
+  await writer.write(data);
+  await writer.close();
+  return bidi_stream;
+}
+
+function ascending_bytes(length) {
+  const data = new Uint8Array(length);
+  for (let i = 0; i < data.byteLength; ++i) {
+    data[i] = i;
+  }
+  return data;
+}
+
+promise_test(async t => {
+  const wt = new WebTransport(webtransport_url('echo.py'));
+  await wt.ready;
+
+  const data = ascending_bytes(64);
+  const bidi_stream = await echo_bidirectional_stream(wt, data);
+
+  // Give the echoed bytes and the FIN a chance to be received before anything
+  // reads them, so that the reads below are served from buffered bytes. The test
+  // is valid either way: a read that arrives first waits for the bytes instead.
+  await wait(100);
+
+  const chunks = await read_stream(bidi_stream.readable);
+  const received = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    received.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  // No bytes may be lost when the stream is closed while bytes are still waiting
+  // to be given to the readable end.
+  assert_array_equals(received, data);
+  wt.close();
+}, 'Bytes received before any read are given to later reads');
+
+promise_test(async t => {
+  const wt = new WebTransport(webtransport_url('echo.py'));
+  await wt.ready;
+
+  const data = ascending_bytes(64);
+  const bidi_stream = await echo_bidirectional_stream(wt, data);
+  await wait(100);
+
+  // Read one byte at a time. Each view is smaller than what the server sent, so
+  // the bytes that do not fit in it must be kept for the following reads.
+  const reader = bidi_stream.readable.getReader({mode: 'byob'});
+  for (let i = 0; i < data.byteLength; ++i) {
+    const {value: view, done} = await reader.read(new Uint8Array(1));
+    assert_false(done, `read ${i} should not be done`);
+    assert_array_equals(view, data.subarray(i, i + 1), `read ${i}`);
+  }
+
+  // All the bytes have been read and the server ended its stream, so the next
+  // read closes the readable end.
+  const {value: view, done} = await reader.read(new Uint8Array(1));
+  assert_true(done, 'the last read should be done');
+  assert_equals(view.byteLength, 0, 'the last read should not fill the view');
+  await reader.closed;
+  reader.releaseLock();
+  wt.close();
+}, 'A BYOB read smaller than the received bytes keeps the rest for later reads');
+
+promise_test(async t => {
+  const wt = new WebTransport(webtransport_url('echo.py'));
+  await wt.ready;
+
+  const bidi_stream = await wt.createBidirectionalStream();
+
+  // Read before anything is received. The read has to wait until either a byte is
+  // received or the server ends its stream.
+  const reader = bidi_stream.readable.getReader();
+  const read = reader.read();
+
+  const data = ascending_bytes(8);
+  const writer = bidi_stream.writable.getWriter();
+  await writer.write(data);
+
+  const {value: chunk, done} = await read;
+  assert_false(done, 'the pending read should not be done');
+  assert_greater_than(chunk.byteLength, 0, 'the pending read should receive at least one byte');
+
+  // Read the rest in case the bytes did not all arrive in a single chunk.
+  let received = Array.from(chunk);
+  await writer.close();
+  while (received.length < data.byteLength) {
+    const {value: chunk, done} = await reader.read();
+    assert_false(done, 'the stream should not end before all its bytes are read');
+    received = received.concat(Array.from(chunk));
+  }
+  assert_array_equals(received, Array.from(data));
+
+  assert_true((await reader.read()).done, 'the read after FIN should be done');
+  reader.releaseLock();
+  wt.close();
+}, 'A read waits for bytes that have not been received yet');