// META: global=window,worker,shadowrealm
// META: script=../resources/rs-utils.js
// META: script=../resources/test-utils.js
'use strict';

const error1 = new Error('error1');
error1.name = 'error1';

test(() => {
  assert_throws_js(TypeError, () => new ReadableStream().getReader({ mode: 'byob' }));
}, 'getReader({mode: "byob"}) throws on non-bytes streams');


test(() => {
  // Constructing ReadableStream with an empty underlying byte source object as parameter shouldn't throw.
  new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' });
  // Constructor must perform ToString(type).
  new ReadableStream({ type: { toString() {return 'bytes';} } })
    .getReader({ mode: 'byob' });
  new ReadableStream({ type: { toString: null, valueOf() {return 'bytes';} } })
    .getReader({ mode: 'byob' });
}, 'ReadableStream with byte source can be constructed with no errors');

test(() => {
  const ReadableStreamBYOBReader = new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' }).constructor;
  const rs = new ReadableStream({ type: 'bytes' });

  let reader = rs.getReader({ mode: { toString() { return 'byob'; } } });
  assert_true(reader instanceof ReadableStreamBYOBReader, 'must give a BYOB reader');
  reader.releaseLock();

  reader = rs.getReader({ mode: { toString: null, valueOf() {return 'byob';} } });
  assert_true(reader instanceof ReadableStreamBYOBReader, 'must give a BYOB reader');
  reader.releaseLock();

  reader = rs.getReader({ mode: 'byob', notmode: 'ignored' });
  assert_true(reader instanceof ReadableStreamBYOBReader, 'must give a BYOB reader');
}, 'getReader({mode}) must perform ToString()');

promise_test(() => {
  let startCalled = false;
  let startCalledBeforePull = false;
  let desiredSize;
  let controller;

  let resolveTestPromise;
  const testPromise = new Promise(resolve => {
    resolveTestPromise = resolve;
  });

  new ReadableStream({
    start(c) {
      controller = c;
      startCalled = true;
    },
    pull() {
      startCalledBeforePull = startCalled;
      desiredSize = controller.desiredSize;
      resolveTestPromise();
    },
    type: 'bytes'
  }, {
    highWaterMark: 256
  });

  return testPromise.then(() => {
    assert_true(startCalledBeforePull, 'start should be called before pull');
    assert_equals(desiredSize, 256, 'desiredSize should equal highWaterMark');
  });

}, 'ReadableStream with byte source: Construct and expect start and pull being called');

promise_test(() => {
  let pullCount = 0;
  let checkedNoPull = false;

  let resolveTestPromise;
  const testPromise = new Promise(resolve => {
    resolveTestPromise = resolve;
  });
  let resolveStartPromise;

  new ReadableStream({
    start() {
      return new Promise(resolve => {
        resolveStartPromise = resolve;
      });
    },
    pull() {
      if (checkedNoPull) {
        resolveTestPromise();
      }

      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 256
  });

  Promise.resolve().then(() => {
    assert_equals(pullCount, 0);
    checkedNoPull = true;
    resolveStartPromise();
  });

  return testPromise;

}, 'ReadableStream with byte source: No automatic pull call if start doesn\'t finish');

test(() => {
  assert_throws_js(Error, () => new ReadableStream({ start() { throw new Error(); }, type:'bytes' }),
      'start() can throw an exception with type: bytes');
}, 'ReadableStream with byte source: start() throws an exception');

promise_test(t => {
  new ReadableStream({
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  }, {
    highWaterMark: 0
  });

  return Promise.resolve();
}, 'ReadableStream with byte source: Construct with highWaterMark of 0');

test(() => {
  new ReadableStream({
    start(c) {
      assert_equals(c.desiredSize, 10, 'desiredSize must start at the highWaterMark');
      c.close();
      assert_equals(c.desiredSize, 0, 'after closing, desiredSize must be 0');
    },
    type: 'bytes'
  }, {
    highWaterMark: 10
  });
}, 'ReadableStream with byte source: desiredSize when closed');

test(() => {
  new ReadableStream({
    start(c) {
      assert_equals(c.desiredSize, 10, 'desiredSize must start at the highWaterMark');
      c.error();
      assert_equals(c.desiredSize, null, 'after erroring, desiredSize must be null');
    },
    type: 'bytes'
  }, {
    highWaterMark: 10
  });
}, 'ReadableStream with byte source: desiredSize when errored');

promise_test(t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader();
  reader.releaseLock();

  return promise_rejects_js(t, TypeError, reader.closed, 'closed must reject');
}, 'ReadableStream with byte source: getReader(), then releaseLock()');

promise_test(t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });
  reader.releaseLock();

  return promise_rejects_js(t, TypeError, reader.closed, 'closed must reject');
}, 'ReadableStream with byte source: getReader() with mode set to byob, then releaseLock()');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.close();
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader();

  return reader.closed.then(() => {
    assert_throws_js(TypeError, () => stream.getReader(), 'getReader() must throw');
  });
}, 'ReadableStream with byte source: Test that closing a stream does not release a reader automatically');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.close();
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.closed.then(() => {
    assert_throws_js(TypeError, () => stream.getReader({ mode: 'byob' }), 'getReader() must throw');
  });
}, 'ReadableStream with byte source: Test that closing a stream does not release a BYOB reader automatically');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.error(error1);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader();

  return promise_rejects_exactly(t, error1, reader.closed, 'closed must reject').then(() => {
    assert_throws_js(TypeError, () => stream.getReader(), 'getReader() must throw');
  });
}, 'ReadableStream with byte source: Test that erroring a stream does not release a reader automatically');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.error(error1);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_exactly(t, error1, reader.closed, 'closed must reject').then(() => {
    assert_throws_js(TypeError, () => stream.getReader({ mode: 'byob' }), 'getReader() must throw');
  });
}, 'ReadableStream with byte source: Test that erroring a stream does not release a BYOB reader automatically');

promise_test(async t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader();
  const read = reader.read();
  reader.releaseLock();
  await promise_rejects_js(t, TypeError, read, 'pending read must reject');
}, 'ReadableStream with byte source: releaseLock() on ReadableStreamDefaultReader must reject pending read()');

promise_test(async t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });
  const read = reader.read(new Uint8Array(1));
  reader.releaseLock();
  await promise_rejects_js(t, TypeError, read, 'pending read must reject');
}, 'ReadableStream with byte source: releaseLock() on ReadableStreamBYOBReader must reject pending read()');

promise_test(() => {
  let pullCount = 0;

  const stream = new ReadableStream({
    pull() {
      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 8
  });

  stream.getReader();

  assert_equals(pullCount, 0, 'No pull as start() just finished and is not yet reflected to the state of the stream');

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 1, 'pull must be invoked');
  });
}, 'ReadableStream with byte source: Automatic pull() after start()');

promise_test(() => {
  let pullCount = 0;

  const stream = new ReadableStream({
    pull() {
      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 0
  });

  const reader = stream.getReader();
  reader.read();

  assert_equals(pullCount, 0, 'No pull as start() just finished and is not yet reflected to the state of the stream');

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 1, 'pull must be invoked');
  });
}, 'ReadableStream with byte source: Automatic pull() after start() and read()');

// View buffers are detached after pull() returns, so record the information at the time that pull() was called.
function extractViewInfo(view) {
  return {
    constructor: view.constructor,
    bufferByteLength: view.buffer.byteLength,
    byteOffset: view.byteOffset,
    byteLength: view.byteLength
  };
}

promise_test(() => {
  let pullCount = 0;
  let controller;
  const byobRequests = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      const byobRequest = controller.byobRequest;
      const view = byobRequest.view;
      byobRequests[pullCount] = {
        nonNull: byobRequest !== null,
        viewNonNull: view !== null,
        viewInfo: extractViewInfo(view)
      };
      if (pullCount === 0) {
        view[0] = 0x01;
        byobRequest.respond(1);
      } else if (pullCount === 1) {
        view[0] = 0x02;
        view[1] = 0x03;
        byobRequest.respond(2);
      }

      ++pullCount;
    },
    type: 'bytes',
    autoAllocateChunkSize: 16
  }, {
    highWaterMark: 0
  });

  const reader = stream.getReader();
  const p0 = reader.read();
  const p1 = reader.read();

  assert_equals(pullCount, 0, 'No pull() as start() just finished and is not yet reflected to the state of the stream');

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 1, 'pull() must have been invoked once');
    const byobRequest = byobRequests[0];
    assert_true(byobRequest.nonNull, 'first byobRequest must not be null');
    assert_true(byobRequest.viewNonNull, 'first byobRequest.view must not be null');
    const viewInfo = byobRequest.viewInfo;
    assert_equals(viewInfo.constructor, Uint8Array, 'first view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 16, 'first view.buffer.byteLength should be 16');
    assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 16, 'first view.byteLength should be 16');

    return p0;
  }).then(result => {
    assert_equals(pullCount, 2, 'pull() must have been invoked twice');
    const value = result.value;
    assert_not_equals(value, undefined, 'first read should have a value');
    assert_equals(value.constructor, Uint8Array, 'first value should be a Uint8Array');
    assert_equals(value.buffer.byteLength, 16, 'first value.buffer.byteLength should be 16');
    assert_equals(value.byteOffset, 0, 'first value.byteOffset should be 0');
    assert_equals(value.byteLength, 1, 'first value.byteLength should be 1');
    assert_equals(value[0], 0x01, 'first value[0] should be 0x01');
    const byobRequest = byobRequests[1];
    assert_true(byobRequest.nonNull, 'second byobRequest must not be null');
    assert_true(byobRequest.viewNonNull, 'second byobRequest.view must not be null');
    const viewInfo = byobRequest.viewInfo;
    assert_equals(viewInfo.constructor, Uint8Array, 'second view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 16, 'second view.buffer.byteLength should be 16');
    assert_equals(viewInfo.byteOffset, 0, 'second view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 16, 'second view.byteLength should be 16');

    return p1;
  }).then(result => {
    assert_equals(pullCount, 2, 'pull() should only be invoked twice');
    const value = result.value;
    assert_not_equals(value, undefined, 'second read should have a value');
    assert_equals(value.constructor, Uint8Array, 'second value should be a Uint8Array');
    assert_equals(value.buffer.byteLength, 16, 'second value.buffer.byteLength should be 16');
    assert_equals(value.byteOffset, 0, 'second value.byteOffset should be 0');
    assert_equals(value.byteLength, 2, 'second value.byteLength should be 2');
    assert_equals(value[0], 0x02, 'second value[0] should be 0x02');
    assert_equals(value[1], 0x03, 'second value[1] should be 0x03');
  });
}, 'ReadableStream with byte source: autoAllocateChunkSize');

promise_test(() => {
  let pullCount = 0;
  let controller;
  const byobRequests = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      const byobRequest = controller.byobRequest;
      const view = byobRequest.view;
      byobRequests[pullCount] = {
        nonNull: byobRequest !== null,
        viewNonNull: view !== null,
        viewInfo: extractViewInfo(view)
      };
      if (pullCount === 0) {
        view[0] = 0x01;
        byobRequest.respond(1);
      } else if (pullCount === 1) {
        view[0] = 0x02;
        view[1] = 0x03;
        byobRequest.respond(2);
      }

      ++pullCount;
    },
    type: 'bytes',
    autoAllocateChunkSize: 16
  }, {
    highWaterMark: 0
  });

  const reader = stream.getReader();
  return reader.read().then(result => {
    const value = result.value;
    assert_not_equals(value, undefined, 'first read should have a value');
    assert_equals(value.constructor, Uint8Array, 'first value should be a Uint8Array');
    assert_equals(value.buffer.byteLength, 16, 'first value.buffer.byteLength should be 16');
    assert_equals(value.byteOffset, 0, 'first value.byteOffset should be 0');
    assert_equals(value.byteLength, 1, 'first value.byteLength should be 1');
    assert_equals(value[0], 0x01, 'first value[0] should be 0x01');
    const byobRequest = byobRequests[0];
    assert_true(byobRequest.nonNull, 'first byobRequest must not be null');
    assert_true(byobRequest.viewNonNull, 'first byobRequest.view must not be null');
    const viewInfo = byobRequest.viewInfo;
    assert_equals(viewInfo.constructor, Uint8Array, 'first view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 16, 'first view.buffer.byteLength should be 16');
    assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 16, 'first view.byteLength should be 16');

    reader.releaseLock();
    const byobReader = stream.getReader({ mode: 'byob' });
    return byobReader.read(new Uint8Array(32));
  }).then(result => {
    const value = result.value;
    assert_not_equals(value, undefined, 'second read should have a value');
    assert_equals(value.constructor, Uint8Array, 'second value should be a Uint8Array');
    assert_equals(value.buffer.byteLength, 32, 'second value.buffer.byteLength should be 32');
    assert_equals(value.byteOffset, 0, 'second value.byteOffset should be 0');
    assert_equals(value.byteLength, 2, 'second value.byteLength should be 2');
    assert_equals(value[0], 0x02, 'second value[0] should be 0x02');
    assert_equals(value[1], 0x03, 'second value[1] should be 0x03');
    const byobRequest = byobRequests[1];
    assert_true(byobRequest.nonNull, 'second byobRequest must not be null');
    assert_true(byobRequest.viewNonNull, 'second byobRequest.view must not be null');
    const viewInfo = byobRequest.viewInfo;
    assert_equals(viewInfo.constructor, Uint8Array, 'second view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 32, 'second view.buffer.byteLength should be 32');
    assert_equals(viewInfo.byteOffset, 0, 'second view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 32, 'second view.byteLength should be 32');
    assert_equals(pullCount, 2, 'pullCount should be 2');
  });
}, 'ReadableStream with byte source: Mix of auto allocate and BYOB');

promise_test(() => {
  let pullCount = 0;

  const stream = new ReadableStream({
    pull() {
      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 0
  });

  const reader = stream.getReader();
  reader.read(new Uint8Array(8));

  assert_equals(pullCount, 0, 'No pull as start() just finished and is not yet reflected to the state of the stream');

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 1, 'pull must be invoked');
  });
}, 'ReadableStream with byte source: Automatic pull() after start() and read(view)');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let desiredSizeInStart;
  let desiredSizeInPull;

  const stream = new ReadableStream({
    start(c) {
      c.enqueue(new Uint8Array(16));
      desiredSizeInStart = c.desiredSize;
      controller = c;
    },
    pull() {
      ++pullCount;

      if (pullCount === 1) {
        desiredSizeInPull = controller.desiredSize;
      }
    },
    type: 'bytes'
  }, {
    highWaterMark: 8
  });

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 0, 'No pull as the queue was filled by start()');
    assert_equals(desiredSizeInStart, -8, 'desiredSize after enqueue() in start()');

    const reader = stream.getReader();

    const promise = reader.read();
    assert_equals(pullCount, 1, 'The first pull() should be made on read()');
    assert_equals(desiredSizeInPull, 8, 'desiredSize in pull()');

    return promise.then(result => {
      assert_false(result.done, 'result.done');

      const view = result.value;
      assert_equals(view.constructor, Uint8Array, 'view.constructor');
      assert_equals(view.buffer.byteLength, 16, 'view.buffer');
      assert_equals(view.byteOffset, 0, 'view.byteOffset');
      assert_equals(view.byteLength, 16, 'view.byteLength');
    });
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then read()');

promise_test(() => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  const promise = reader.read().then(result => {
    assert_false(result.done);

    const view = result.value;
    assert_equals(view.constructor, Uint8Array);
    assert_equals(view.buffer.byteLength, 1);
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 1);
  });

  controller.enqueue(new Uint8Array(1));

  return promise;
}, 'ReadableStream with byte source: Push source that doesn\'t understand pull signal');

test(() => {
  assert_throws_js(TypeError, () => new ReadableStream({
    pull: 'foo',
    type: 'bytes'
  }), 'constructor should throw');
}, 'ReadableStream with byte source: pull() function is not callable');

promise_test(() => {
  const stream = new ReadableStream({
    start(c) {
      c.enqueue(new Uint16Array(16));
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  return reader.read().then(result => {
    assert_false(result.done);

    const view = result.value;
    assert_equals(view.constructor, Uint8Array);
    assert_equals(view.buffer.byteLength, 32);
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 32);
  });
}, 'ReadableStream with byte source: enqueue() with Uint16Array, getReader(), then read()');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(16);
      view[0] = 0x01;
      view[8] = 0x02;
      c.enqueue(view);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const byobReader = stream.getReader({ mode: 'byob' });

  return byobReader.read(new Uint8Array(8)).then(result => {
    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.constructor, Uint8Array, 'value.constructor');
    assert_equals(view.buffer.byteLength, 8, 'value.buffer.byteLength');
    assert_equals(view.byteOffset, 0, 'value.byteOffset');
    assert_equals(view.byteLength, 8, 'value.byteLength');
    assert_equals(view[0], 0x01);

    byobReader.releaseLock();

    const reader = stream.getReader();

    return reader.read();
  }).then(result => {
    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.constructor, Uint8Array, 'value.constructor');
    assert_equals(view.buffer.byteLength, 16, 'value.buffer.byteLength');
    assert_equals(view.byteOffset, 8, 'value.byteOffset');
    assert_equals(view.byteLength, 8, 'value.byteLength');
    assert_equals(view[0], 0x02);
  });
}, 'ReadableStream with byte source: enqueue(), read(view) partially, then read()');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader();

  controller.enqueue(new Uint8Array(16));
  controller.close();

  return reader.read().then(result => {
    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'byteOffset');
    assert_equals(view.byteLength, 16, 'byteLength');

    return reader.read();
  }).then(result => {
    assert_true(result.done, 'done');
    assert_equals(result.value, undefined, 'value');
  });
}, 'ReadableStream with byte source: getReader(), enqueue(), close(), then read()');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.enqueue(new Uint8Array(16));
      c.close();
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader();

  return reader.read().then(result => {
    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'byteOffset');
    assert_equals(view.byteLength, 16, 'byteLength');

    return reader.read();
  }).then(result => {
    assert_true(result.done, 'done');
    assert_equals(result.value, undefined, 'value');
  });
}, 'ReadableStream with byte source: enqueue(), close(), getReader(), then read()');

promise_test(() => {
  let controller;
  let byobRequest;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      controller.enqueue(new Uint8Array(16));
      byobRequest = controller.byobRequest;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  return reader.read().then(result => {
    assert_false(result.done, 'done');
    assert_equals(result.value.byteLength, 16, 'byteLength');
    assert_equals(byobRequest, null, 'byobRequest must be null');
  });
}, 'ReadableStream with byte source: Respond to pull() by enqueue()');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let byobRequest;
  const desiredSizes = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;
      desiredSizes.push(controller.desiredSize);
      controller.enqueue(new Uint8Array(1));
      desiredSizes.push(controller.desiredSize);
      controller.enqueue(new Uint8Array(1));
      desiredSizes.push(controller.desiredSize);

      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 0
  });

  const reader = stream.getReader();

  const p0 = reader.read();
  const p1 = reader.read();
  const p2 = reader.read();

  // Respond to the first pull call.
  controller.enqueue(new Uint8Array(1));

  assert_equals(pullCount, 0, 'pullCount after the enqueue() outside pull');

  return Promise.all([p0, p1, p2]).then(result => {
    assert_equals(pullCount, 1, 'pullCount after completion of all read()s');

    assert_equals(result[0].done, false, 'result[0].done');
    assert_equals(result[0].value.byteLength, 1, 'result[0].value.byteLength');
    assert_equals(result[1].done, false, 'result[1].done');
    assert_equals(result[1].value.byteLength, 1, 'result[1].value.byteLength');
    assert_equals(result[2].done, false, 'result[2].done');
    assert_equals(result[2].value.byteLength, 1, 'result[2].value.byteLength');
    assert_equals(byobRequest, null, 'byobRequest should be null');
    assert_equals(desiredSizes[0], 0, 'desiredSize on pull should be 0');
    assert_equals(desiredSizes[1], 0, 'desiredSize after 1st enqueue() should be 0');
    assert_equals(desiredSizes[2], 0, 'desiredSize after 2nd enqueue() should be 0');
    assert_equals(pullCount, 1, 'pull() should only be called once');
  });
}, 'ReadableStream with byte source: Respond to pull() by enqueue() asynchronously');

promise_test(() => {
  let pullCount = 0;

  let byobRequest;
  const desiredSizes = [];

  const stream = new ReadableStream({
    pull(c) {
      byobRequest = c.byobRequest;
      desiredSizes.push(c.desiredSize);

      if (pullCount < 3) {
        c.enqueue(new Uint8Array(1));
      } else {
        c.close();
      }

      ++pullCount;
    },
    type: 'bytes'
  }, {
    highWaterMark: 256
  });

  const reader = stream.getReader();

  const p0 = reader.read();
  const p1 = reader.read();
  const p2 = reader.read();

  assert_equals(pullCount, 0, 'No pull as start() just finished and is not yet reflected to the state of the stream');

  return Promise.all([p0, p1, p2]).then(result => {
    assert_equals(pullCount, 4, 'pullCount after completion of all read()s');

    assert_equals(result[0].done, false, 'result[0].done');
    assert_equals(result[0].value.byteLength, 1, 'result[0].value.byteLength');
    assert_equals(result[1].done, false, 'result[1].done');
    assert_equals(result[1].value.byteLength, 1, 'result[1].value.byteLength');
    assert_equals(result[2].done, false, 'result[2].done');
    assert_equals(result[2].value.byteLength, 1, 'result[2].value.byteLength');
    assert_equals(byobRequest, null, 'byobRequest should be null');
    assert_equals(desiredSizes[0], 256, 'desiredSize on pull should be 256');
    assert_equals(desiredSizes[1], 256, 'desiredSize after 1st enqueue() should be 256');
    assert_equals(desiredSizes[2], 256, 'desiredSize after 2nd enqueue() should be 256');
    assert_equals(desiredSizes[3], 256, 'desiredSize after 3rd enqueue() should be 256');
  });
}, 'ReadableStream with byte source: Respond to multiple pull() by separate enqueue()');

promise_test(() => {
  let controller;

  let pullCount = 0;
  const byobRequestDefined = [];
  let byobRequestViewDefined;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequestDefined.push(controller.byobRequest !== null);
      const initialByobRequest = controller.byobRequest;

      const view = controller.byobRequest.view;
      view[0] = 0x01;
      controller.byobRequest.respond(1);

      byobRequestDefined.push(controller.byobRequest !== null);
      byobRequestViewDefined = initialByobRequest.view !== null;

      ++pullCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(1)).then(result => {
    assert_false(result.done, 'result.done');
    assert_equals(result.value.byteLength, 1, 'result.value.byteLength');
    assert_equals(result.value[0], 0x01, 'result.value[0]');
    assert_equals(pullCount, 1, 'pull() should be called only once');
    assert_true(byobRequestDefined[0], 'byobRequest must not be null before respond()');
    assert_false(byobRequestDefined[1], 'byobRequest must be null after respond()');
    assert_false(byobRequestViewDefined, 'view of initial byobRequest must be null after respond()');
  });
}, 'ReadableStream with byte source: read(view), then respond()');

promise_test(() => {
  let controller;

  let pullCount = 0;
  const byobRequestDefined = [];
  let byobRequestViewDefined;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    async pull() {
      byobRequestDefined.push(controller.byobRequest !== null);
      const initialByobRequest = controller.byobRequest;

      const transferredView = await transferArrayBufferView(controller.byobRequest.view);
      transferredView[0] = 0x01;
      controller.byobRequest.respondWithNewView(transferredView);

      byobRequestDefined.push(controller.byobRequest !== null);
      byobRequestViewDefined = initialByobRequest.view !== null;

      ++pullCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(1)).then(result => {
    assert_false(result.done, 'result.done');
    assert_equals(result.value.byteLength, 1, 'result.value.byteLength');
    assert_equals(result.value[0], 0x01, 'result.value[0]');
    assert_equals(pullCount, 1, 'pull() should be called only once');
    assert_true(byobRequestDefined[0], 'byobRequest must not be null before respondWithNewView()');
    assert_false(byobRequestDefined[1], 'byobRequest must be null after respondWithNewView()');
    assert_false(byobRequestViewDefined, 'view of initial byobRequest must be null after respondWithNewView()');
  });
}, 'ReadableStream with byte source: read(view), then respondWithNewView() with a transferred ArrayBuffer');

promise_test(() => {
  let controller;
  let byobRequestWasDefined;
  let incorrectRespondException;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequestWasDefined = controller.byobRequest !== null;

      try {
        controller.byobRequest.respond(2);
      } catch (e) {
        incorrectRespondException = e;
      }

      controller.byobRequest.respond(1);
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(1)).then(() => {
    assert_true(byobRequestWasDefined, 'byobRequest should be non-null');
    assert_not_equals(incorrectRespondException, undefined, 'respond() must throw');
    assert_equals(incorrectRespondException.name, 'RangeError', 'respond() must throw a RangeError');
  });
}, 'ReadableStream with byte source: read(view), then respond() with too big value');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let byobRequest;
  let viewInfo;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      ++pullCount;

      byobRequest = controller.byobRequest;
      const view = byobRequest.view;
      viewInfo = extractViewInfo(view);

      view[0] = 0x01;
      view[1] = 0x02;
      view[2] = 0x03;

      controller.byobRequest.respond(3);
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint16Array(2)).then(result => {
    assert_equals(pullCount, 1);

    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'byteOffset');
    assert_equals(view.byteLength, 2, 'byteLength');

    const dataView = new DataView(view.buffer, view.byteOffset, view.byteLength);
    assert_equals(dataView.getUint16(0), 0x0102);

    return reader.read(new Uint8Array(1));
  }).then(result => {
    assert_equals(pullCount, 1);
    assert_not_equals(byobRequest, null, 'byobRequest must not be null');
    assert_equals(viewInfo.constructor, Uint8Array, 'view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 4, 'view.buffer.byteLength should be 4');
    assert_equals(viewInfo.byteOffset, 0, 'view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 4, 'view.byteLength should be 4');

    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'byteOffset');
    assert_equals(view.byteLength, 1, 'byteLength');

    assert_equals(view[0], 0x03);
  });
}, 'ReadableStream with byte source: respond(3) to read(view) with 2 element Uint16Array enqueues the 1 byte ' +
   'remainder');

promise_test(t => {
  const stream = new ReadableStream({
    start(controller) {
      const view = new Uint8Array(16);
      view[15] = 0x01;
      controller.enqueue(view);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(16)).then(result => {
    assert_false(result.done);

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 16);
    assert_equals(view[15], 0x01);
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then read(view)');

promise_test(t => {
  let cancelCount = 0;
  let reason;

  const passedReason = new TypeError('foo');

  const stream = new ReadableStream({
    start(c) {
      c.enqueue(new Uint8Array(16));
    },
    pull: t.unreached_func('pull() should not be called'),
    cancel(r) {
      if (cancelCount === 0) {
        reason = r;
      }

      ++cancelCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  return reader.cancel(passedReason).then(result => {
    assert_equals(result, undefined);
    assert_equals(cancelCount, 1);
    assert_equals(reason, passedReason, 'reason should equal the passed reason');
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = not BYOB)');

promise_test(t => {
  let cancelCount = 0;
  let reason;

  const passedReason = new TypeError('foo');

  const stream = new ReadableStream({
    start(c) {
      c.enqueue(new Uint8Array(16));
    },
    pull: t.unreached_func('pull() should not be called'),
    cancel(r) {
      if (cancelCount === 0) {
        reason = r;
      }

      ++cancelCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.cancel(passedReason).then(result => {
    assert_equals(result, undefined);
    assert_equals(cancelCount, 1);
    assert_equals(reason, passedReason, 'reason should equal the passed reason');
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = BYOB)');

promise_test(t => {
  let cancelCount = 0;
  let reason;

  const passedReason = new TypeError('foo');

  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    cancel(r) {
      if (cancelCount === 0) {
        reason = r;
      }

      ++cancelCount;

      return 'bar';
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const readPromise = reader.read(new Uint8Array(1)).then(result => {
    assert_true(result.done, 'result.done');
    assert_equals(result.value, undefined, 'result.value');
  });

  const cancelPromise = reader.cancel(passedReason).then(result => {
    assert_equals(result, undefined, 'cancel() return value should be fulfilled with undefined');
    assert_equals(cancelCount, 1, 'cancel() should be called only once');
    assert_equals(reason, passedReason, 'reason should equal the passed reason');
  });

  return Promise.all([readPromise, cancelPromise]);
}, 'ReadableStream with byte source: getReader(), read(view), then cancel()');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let byobRequest;
  const viewInfos = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;

      viewInfos.push(extractViewInfo(controller.byobRequest.view));
      controller.enqueue(new Uint8Array(1));
      viewInfos.push(extractViewInfo(controller.byobRequest.view));

      ++pullCount;
    },
    type: 'bytes'
  });

  return Promise.resolve().then(() => {
    assert_equals(pullCount, 0, 'No pull() as no read(view) yet');

    const reader = stream.getReader({ mode: 'byob' });

    const promise = reader.read(new Uint16Array(1)).then(result => {
      assert_true(result.done, 'result.done');
      assert_equals(result.value, undefined, 'result.value');
    });

    assert_equals(pullCount, 1, '1 pull() should have been made in response to partial fill by enqueue()');
    assert_not_equals(byobRequest, null, 'byobRequest should not be null');
    assert_equals(viewInfos[0].byteLength, 2, 'byteLength before enqueue() should be 2');
    assert_equals(viewInfos[1].byteLength, 1, 'byteLength after enqueue() should be 1');

    reader.cancel();

    assert_equals(pullCount, 1, 'pull() should only be called once');
    return promise;
  });
}, 'ReadableStream with byte source: cancel() with partially filled pending pull() request');

promise_test(() => {
  let controller;
  let pullCalled = false;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(8);
      view[7] = 0x01;
      c.enqueue(view);

      controller = c;
    },
    pull() {
      pullCalled = true;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const buffer = new ArrayBuffer(16);

  return reader.read(new Uint8Array(buffer, 8, 8)).then(result => {
    assert_false(result.done);

    assert_false(pullCalled, 'pull() must not have been called');

    const view = result.value;
    assert_equals(view.constructor, Uint8Array);
    assert_equals(view.buffer.byteLength, 16);
    assert_equals(view.byteOffset, 8);
    assert_equals(view.byteLength, 8);
    assert_equals(view[7], 0x01);
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then read(view) where view.buffer is not fully ' +
   'covered by view');

promise_test(() => {
  let controller;
  let pullCalled = false;

  const stream = new ReadableStream({
    start(c) {
      let view;

      view = new Uint8Array(16);
      view[15] = 123;
      c.enqueue(view);

      view = new Uint8Array(8);
      view[7] = 111;
      c.enqueue(view);

      controller = c;
    },
    pull() {
      pullCalled = true;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(24)).then(result => {
    assert_false(result.done, 'done');

    assert_false(pullCalled, 'pull() must not have been called');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'byteOffset');
    assert_equals(view.byteLength, 24, 'byteLength');
    assert_equals(view[15], 123, 'Contents are set from the first chunk');
    assert_equals(view[23], 111, 'Contents are set from the second chunk');
  });
}, 'ReadableStream with byte source: Multiple enqueue(), getReader(), then read(view)');

promise_test(() => {
  let pullCalled = false;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(16);
      view[15] = 0x01;
      c.enqueue(view);
    },
    pull() {
      pullCalled = true;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(24)).then(result => {
    assert_false(result.done);

    assert_false(pullCalled, 'pull() must not have been called');

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 16);
    assert_equals(view[15], 0x01);
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then read(view) with a bigger view');

promise_test(() => {
  let pullCalled = false;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(16);
      view[7] = 0x01;
      view[15] = 0x02;
      c.enqueue(view);
    },
    pull() {
      pullCalled = true;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(8)).then(result => {
    assert_false(result.done, 'done');

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 8);
    assert_equals(view[7], 0x01);

    return reader.read(new Uint8Array(8));
  }).then(result => {
    assert_false(result.done, 'done');

    assert_false(pullCalled, 'pull() must not have been called');

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 8);
    assert_equals(view[7], 0x02);
  });
}, 'ReadableStream with byte source: enqueue(), getReader(), then read(view) with smaller views');

promise_test(() => {
  let controller;
  let viewInfo;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(1);
      view[0] = 0xff;
      c.enqueue(view);

      controller = c;
    },
    pull() {
      if (controller.byobRequest === null) {
        return;
      }

      const view = controller.byobRequest.view;
      viewInfo = extractViewInfo(view);

      view[0] = 0xaa;
      controller.byobRequest.respond(1);
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint16Array(1)).then(result => {
    assert_false(result.done);

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 2);

    const dataView = new DataView(view.buffer, view.byteOffset, view.byteLength);
    assert_equals(dataView.getUint16(0), 0xffaa);

    assert_equals(viewInfo.constructor, Uint8Array, 'view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 2, 'view.buffer.byteLength should be 2');
    assert_equals(viewInfo.byteOffset, 1, 'view.byteOffset should be 1');
    assert_equals(viewInfo.byteLength, 1, 'view.byteLength should be 1');
  });
}, 'ReadableStream with byte source: enqueue() 1 byte, getReader(), then read(view) with Uint16Array');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let byobRequest;
  let viewInfo;
  let desiredSize;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(3);
      view[0] = 0x01;
      view[2] = 0x02;
      c.enqueue(view);

      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;

      const view = controller.byobRequest.view;

      viewInfo = extractViewInfo(view);

      view[0] = 0x03;
      controller.byobRequest.respond(1);

      desiredSize = controller.desiredSize;

      ++pullCount;
    },
    type: 'bytes'
  });

  // Wait for completion of the start method to be reflected.
  return Promise.resolve().then(() => {
    const reader = stream.getReader({ mode: 'byob' });

    const promise = reader.read(new Uint16Array(2)).then(result => {
      assert_false(result.done, 'done');

      const view = result.value;
      assert_equals(view.constructor, Uint16Array, 'constructor');
      assert_equals(view.buffer.byteLength, 4, 'buffer.byteLength');
      assert_equals(view.byteOffset, 0, 'byteOffset');
      assert_equals(view.byteLength, 2, 'byteLength');

      const dataView = new DataView(view.buffer, view.byteOffset, view.byteLength);
      assert_equals(dataView.getUint16(0), 0x0100, 'contents are set');

      const p = reader.read(new Uint16Array(1));

      assert_equals(pullCount, 1);

      return p;
    }).then(result => {
      assert_false(result.done, 'done');

      const view = result.value;
      assert_equals(view.buffer.byteLength, 2, 'buffer.byteLength');
      assert_equals(view.byteOffset, 0, 'byteOffset');
      assert_equals(view.byteLength, 2, 'byteLength');

      const dataView = new DataView(view.buffer, view.byteOffset, view.byteLength);
      assert_equals(dataView.getUint16(0), 0x0203, 'contents are set');

      assert_not_equals(byobRequest, null, 'byobRequest must not be null');
      assert_equals(viewInfo.constructor, Uint8Array, 'view.constructor should be Uint8Array');
      assert_equals(viewInfo.bufferByteLength, 2, 'view.buffer.byteLength should be 2');
      assert_equals(viewInfo.byteOffset, 1, 'view.byteOffset should be 1');
      assert_equals(viewInfo.byteLength, 1, 'view.byteLength should be 1');
      assert_equals(desiredSize, 0, 'desiredSize should be zero');
    });

    assert_equals(pullCount, 0);

    return promise;
  });
}, 'ReadableStream with byte source: enqueue() 3 byte, getReader(), then read(view) with 2-element Uint16Array');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(1);
      view[0] = 0xff;
      c.enqueue(view);
      c.close();
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });


  return promise_rejects_js(t, TypeError, reader.read(new Uint16Array(1)), 'read(view) must fail')
      .then(() => promise_rejects_js(t, TypeError, reader.closed, 'reader.closed should reject'));
}, 'ReadableStream with byte source: read(view) with Uint16Array on close()-d stream with 1 byte enqueue()-d must ' +
   'fail');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      const view = new Uint8Array(1);
      view[0] = 0xff;
      c.enqueue(view);

      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const readPromise = reader.read(new Uint16Array(1));

  assert_throws_js(TypeError, () => controller.close(), 'controller.close() must throw');

  return promise_rejects_js(t, TypeError, readPromise, 'read(view) must fail')
      .then(() => promise_rejects_js(t, TypeError, reader.closed, 'reader.closed must reject'));
}, 'ReadableStream with byte source: A stream must be errored if close()-d before fulfilling read(view) with ' +
   'Uint16Array');

test(() => {
  let controller;

  new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  // Enqueue a chunk so that the stream doesn't get closed. This is to check duplicate close() calls are rejected
  // even if the stream has not yet entered the closed state.
  const view = new Uint8Array(1);
  controller.enqueue(view);
  controller.close();

  assert_throws_js(TypeError, () => controller.close(), 'controller.close() must throw');
}, 'ReadableStream with byte source: Throw if close()-ed more than once');

test(() => {
  let controller;

  new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  // Enqueue a chunk so that the stream doesn't get closed. This is to check enqueue() after close() is  rejected
  // even if the stream has not yet entered the closed state.
  const view = new Uint8Array(1);
  controller.enqueue(view);
  controller.close();

  assert_throws_js(TypeError, () => controller.enqueue(view), 'controller.close() must throw');
}, 'ReadableStream with byte source: Throw on enqueue() after close()');

promise_test(() => {
  let controller;
  let byobRequest;
  let viewInfo;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;
      const view = controller.byobRequest.view;
      viewInfo = extractViewInfo(view);

      view[15] = 0x01;
      controller.byobRequest.respond(16);
      controller.close();
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint8Array(16)).then(result => {
    assert_false(result.done);

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 16);
    assert_equals(view[15], 0x01);

    return reader.read(new Uint8Array(16));
  }).then(result => {
    assert_true(result.done);

    const view = result.value;
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 0);

    assert_not_equals(byobRequest, null, 'byobRequest must not be null');
    assert_equals(viewInfo.constructor, Uint8Array, 'view.constructor should be Uint8Array');
    assert_equals(viewInfo.bufferByteLength, 16, 'view.buffer.byteLength should be 16');
    assert_equals(viewInfo.byteOffset, 0, 'view.byteOffset should be 0');
    assert_equals(viewInfo.byteLength, 16, 'view.byteLength should be 16');
  });
}, 'ReadableStream with byte source: read(view), then respond() and close() in pull()');

promise_test(() => {
  let pullCount = 0;

  let controller;
  const viewInfos = [];
  const viewInfosAfterRespond = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      if (controller.byobRequest === null) {
        return;
      }

      for (let i = 0; i < 4; ++i) {
        const view = controller.byobRequest.view;
        viewInfos.push(extractViewInfo(view));

        view[0] = 0x01;
        controller.byobRequest.respond(1);
        viewInfosAfterRespond.push(extractViewInfo(view));
      }

      ++pullCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint32Array(1)).then(result => {
    assert_false(result.done, 'result.done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
    assert_equals(view.byteLength, 4, 'result.value.byteLength');
    assert_equals(view[0], 0x01010101, 'result.value[0]');

    assert_equals(pullCount, 1, 'pull() should only be called once');

    for (let i = 0; i < 4; ++i) {
      assert_equals(viewInfos[i].constructor, Uint8Array, 'view.constructor should be Uint8Array');
      assert_equals(viewInfos[i].bufferByteLength, 4, 'view.buffer.byteLength should be 4');

      assert_equals(viewInfos[i].byteOffset, i, 'view.byteOffset should be i');
      assert_equals(viewInfos[i].byteLength, 4 - i, 'view.byteLength should be 4 - i');

      assert_equals(viewInfosAfterRespond[i].bufferByteLength, 0, 'view.buffer should be transferred after respond()');
    }
  });
}, 'ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple respond() calls');

promise_test(() => {
  let pullCount = 0;

  let controller;
  const viewInfos = [];
  const viewInfosAfterEnqueue = [];

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      if (controller.byobRequest === null) {
        return;
      }

      for (let i = 0; i < 4; ++i) {
        const view = controller.byobRequest.view;
        viewInfos.push(extractViewInfo(view));

        controller.enqueue(new Uint8Array([0x01]));
        viewInfosAfterEnqueue.push(extractViewInfo(view));
      }

      ++pullCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return reader.read(new Uint32Array(1)).then(result => {
    assert_false(result.done, 'result.done');

    const view = result.value;
    assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
    assert_equals(view.byteLength, 4, 'result.value.byteLength');
    assert_equals(view[0], 0x01010101, 'result.value[0]');

    assert_equals(pullCount, 1, 'pull() should only be called once');

    for (let i = 0; i < 4; ++i) {
      assert_equals(viewInfos[i].constructor, Uint8Array, 'view.constructor should be Uint8Array');
      assert_equals(viewInfos[i].bufferByteLength, 4, 'view.buffer.byteLength should be 4');

      assert_equals(viewInfos[i].byteOffset, i, 'view.byteOffset should be i');
      assert_equals(viewInfos[i].byteLength, 4 - i, 'view.byteLength should be 4 - i');

      assert_equals(viewInfosAfterEnqueue[i].bufferByteLength, 0, 'view.buffer should be transferred after enqueue()');
    }
  });
}, 'ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple enqueue() calls');

promise_test(() => {
  let pullCount = 0;

  let controller;
  let byobRequest;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;

      ++pullCount;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  const p0 = reader.read().then(result => {
    assert_equals(pullCount, 1);

    controller.enqueue(new Uint8Array(2));

    // Since the queue has data no less than HWM, no more pull.
    assert_equals(pullCount, 1);

    assert_false(result.done);

    const view = result.value;
    assert_equals(view.constructor, Uint8Array);
    assert_equals(view.buffer.byteLength, 1);
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 1);
  });

  assert_equals(pullCount, 0, 'No pull should have been made since the startPromise has not yet been handled');

  const p1 = reader.read().then(result => {
    assert_equals(pullCount, 1);

    assert_false(result.done);

    const view = result.value;
    assert_equals(view.constructor, Uint8Array);
    assert_equals(view.buffer.byteLength, 2);
    assert_equals(view.byteOffset, 0);
    assert_equals(view.byteLength, 2);

    assert_equals(byobRequest, null, 'byobRequest must be null');
  });

  assert_equals(pullCount, 0, 'No pull should have been made since the startPromise has not yet been handled');

  controller.enqueue(new Uint8Array(1));

  assert_equals(pullCount, 0, 'No pull should have been made since the startPromise has not yet been handled');

  return Promise.all([p0, p1]);
}, 'ReadableStream with byte source: read() twice, then enqueue() twice');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const p0 = reader.read(new Uint8Array(16)).then(result => {
    assert_true(result.done, '1st read: done');

    const view = result.value;
    assert_equals(view.buffer.byteLength, 16, '1st read: buffer.byteLength');
    assert_equals(view.byteOffset, 0, '1st read: byteOffset');
    assert_equals(view.byteLength, 0, '1st read: byteLength');
  });

  const p1 = reader.read(new Uint8Array(32)).then(result => {
    assert_true(result.done, '2nd read: done');

    const view = result.value;
    assert_equals(view.buffer.byteLength, 32, '2nd read: buffer.byteLength');
    assert_equals(view.byteOffset, 0, '2nd read: byteOffset');
    assert_equals(view.byteLength, 0, '2nd read: byteLength');
  });

  controller.close();
  controller.byobRequest.respond(0);

  return Promise.all([p0, p1]);
}, 'ReadableStream with byte source: Multiple read(view), close() and respond()');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const p0 = reader.read(new Uint8Array(16)).then(result => {
    assert_false(result.done, '1st read: done');

    const view = result.value;
    assert_equals(view.buffer.byteLength, 16, '1st read: buffer.byteLength');
    assert_equals(view.byteOffset, 0, '1st read: byteOffset');
    assert_equals(view.byteLength, 16, '1st read: byteLength');
  });

  const p1 = reader.read(new Uint8Array(16)).then(result => {
    assert_false(result.done, '2nd read: done');

    const view = result.value;
    assert_equals(view.buffer.byteLength, 16, '2nd read: buffer.byteLength');
    assert_equals(view.byteOffset, 0, '2nd read: byteOffset');
    assert_equals(view.byteLength, 8, '2nd read: byteLength');
  });

  controller.enqueue(new Uint8Array(24));

  return Promise.all([p0, p1]);
}, 'ReadableStream with byte source: Multiple read(view), big enqueue()');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  let bytesRead = 0;

  function pump() {
    return reader.read(new Uint8Array(7)).then(result => {
      if (result.done) {
        assert_equals(bytesRead, 1024);
        return undefined;
      }

      bytesRead += result.value.byteLength;

      return pump();
    });
  }
  const promise = pump();

  controller.enqueue(new Uint8Array(512));
  controller.enqueue(new Uint8Array(512));
  controller.close();

  return promise;
}, 'ReadableStream with byte source: Multiple read(view) and multiple enqueue()');

promise_test(t => {
  let pullCalled = false;
  const stream = new ReadableStream({
    pull(controller) {
      pullCalled = true;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_js(t, TypeError, reader.read(), 'read() must fail')
      .then(() => assert_false(pullCalled, 'pull() must not have been called'));
}, 'ReadableStream with byte source: read(view) with passing undefined as view must fail');

promise_test(t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_js(t, TypeError, reader.read({}), 'read(view) must fail');
}, 'ReadableStream with byte source: read(view) with passing an empty object as view must fail');

promise_test(t => {
  const stream = new ReadableStream({
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_js(t, TypeError,
                         reader.read({ buffer: new ArrayBuffer(10), byteOffset: 0, byteLength: 10 }),
                         'read(view) must fail');
}, 'ReadableStream with byte source: Even read(view) with passing ArrayBufferView like object as view must fail');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.error(error1);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader();

  return promise_rejects_exactly(t, error1, reader.read(), 'read() must fail');
}, 'ReadableStream with byte source: read() on an errored stream');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  const promise = promise_rejects_exactly(t, error1, reader.read(), 'read() must fail');

  controller.error(error1);

  return promise;
}, 'ReadableStream with byte source: read(), then error()');

promise_test(t => {
  const stream = new ReadableStream({
    start(c) {
      c.error(error1);
    },
    pull: t.unreached_func('pull() should not be called'),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_exactly(t, error1, reader.read(new Uint8Array(1)), 'read() must fail');
}, 'ReadableStream with byte source: read(view) on an errored stream');

promise_test(t => {
  let controller;

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  const promise = promise_rejects_exactly(t, error1, reader.read(new Uint8Array(1)), 'read() must fail');

  controller.error(error1);

  return promise;
}, 'ReadableStream with byte source: read(view), then error()');

promise_test(t => {
  let controller;
  let byobRequest;

  const testError = new TypeError('foo');

  const stream = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull() {
      byobRequest = controller.byobRequest;
      throw testError;
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  const promise = promise_rejects_exactly(t, testError, reader.read(), 'read() must fail');
  return promise_rejects_exactly(t, testError, promise.then(() => reader.closed))
      .then(() => assert_equals(byobRequest, null, 'byobRequest must be null'));
}, 'ReadableStream with byte source: Throwing in pull function must error the stream');

promise_test(t => {
  let byobRequest;

  const stream = new ReadableStream({
    pull(controller) {
      byobRequest = controller.byobRequest;
      controller.error(error1);
      throw new TypeError('foo');
    },
    type: 'bytes'
  });

  const reader = stream.getReader();

  return promise_rejects_exactly(t, error1, reader.read(), 'read() must fail')
      .then(() => promise_rejects_exactly(t, error1, reader.closed, 'closed must fail'))
      .then(() => assert_equals(byobRequest, null, 'byobRequest must be null'));
}, 'ReadableStream with byte source: Throwing in pull in response to read() must be ignored if the stream is ' +
   'errored in it');

promise_test(t => {
  let byobRequest;

  const testError = new TypeError('foo');

  const stream = new ReadableStream({
    pull(controller) {
      byobRequest = controller.byobRequest;
      throw testError;
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_exactly(t, testError, reader.read(new Uint8Array(1)), 'read(view) must fail')
      .then(() => promise_rejects_exactly(t, testError, reader.closed, 'reader.closed must reject'))
      .then(() => assert_not_equals(byobRequest, null, 'byobRequest must not be null'));
}, 'ReadableStream with byte source: Throwing in pull in response to read(view) function must error the stream');

promise_test(t => {
  let byobRequest;

  const stream = new ReadableStream({
    pull(controller) {
      byobRequest = controller.byobRequest;
      controller.error(error1);
      throw new TypeError('foo');
    },
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });

  return promise_rejects_exactly(t, error1, reader.read(new Uint8Array(1)), 'read(view) must fail')
      .then(() => promise_rejects_exactly(t, error1, reader.closed, 'closed must fail'))
      .then(() => assert_not_equals(byobRequest, null, 'byobRequest must not be null'));
}, 'ReadableStream with byte source: Throwing in pull in response to read(view) must be ignored if the stream is ' +
   'errored in it');

promise_test(() => {
  let byobRequest;
  const rs = new ReadableStream({
    pull(controller) {
      byobRequest = controller.byobRequest;
      byobRequest.respond(4);
    },
    type: 'bytes'
  });
  const reader = rs.getReader({ mode: 'byob' });
  const view = new Uint8Array(16);
  return reader.read(view).then(() => {
    assert_throws_js(TypeError, () => byobRequest.respond(4), 'respond() should throw a TypeError');
  });
}, 'calling respond() twice on the same byobRequest should throw');

promise_test(() => {
  let byobRequest;
  const newView = () => new Uint8Array(16);
  const rs = new ReadableStream({
    pull(controller) {
      byobRequest = controller.byobRequest;
      byobRequest.respondWithNewView(newView());
    },
    type: 'bytes'
  });
  const reader = rs.getReader({ mode: 'byob' });
  return reader.read(newView()).then(() => {
    assert_throws_js(TypeError, () => byobRequest.respondWithNewView(newView()),
                     'respondWithNewView() should throw a TypeError');
  });
}, 'calling respondWithNewView() twice on the same byobRequest should throw');

promise_test(() => {
  let controller;
  let byobRequest;
  let resolvePullCalledPromise;
  const pullCalledPromise = new Promise(resolve => {
    resolvePullCalledPromise = resolve;
  });
  let resolvePull;
  const rs = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull(c) {
      byobRequest = c.byobRequest;
      resolvePullCalledPromise();
      return new Promise(resolve => {
        resolvePull = resolve;
      });
    },
    type: 'bytes'
  });
  const reader = rs.getReader({ mode: 'byob' });
  const readPromise = reader.read(new Uint8Array(16));
  return pullCalledPromise.then(() => {
    controller.close();
    byobRequest.respond(0);
    resolvePull();
    return readPromise.then(() => {
      assert_throws_js(TypeError, () => byobRequest.respond(0), 'respond() should throw');
    });
  });
}, 'calling respond(0) twice on the same byobRequest should throw even when closed');

promise_test(() => {
  let controller;
  let byobRequest;
  let resolvePullCalledPromise;
  const pullCalledPromise = new Promise(resolve => {
    resolvePullCalledPromise = resolve;
  });
  let resolvePull;
  const rs = new ReadableStream({
    start(c) {
      controller = c;
    },
    pull(c) {
      byobRequest = c.byobRequest;
      resolvePullCalledPromise();
      return new Promise(resolve => {
        resolvePull = resolve;
      });
    },
    type: 'bytes'
  });
  const reader = rs.getReader({ mode: 'byob' });
  const readPromise = reader.read(new Uint8Array(16));
  return pullCalledPromise.then(() => {
    const cancelPromise = reader.cancel('meh');
    assert_throws_js(TypeError, () => byobRequest.respond(0), 'respond() should throw');
    resolvePull();
    return Promise.all([readPromise, cancelPromise]);
  });
}, 'calling respond() should throw when canceled');

promise_test(async t => {
  let resolvePullCalledPromise;
  const pullCalledPromise = new Promise(resolve => {
    resolvePullCalledPromise = resolve;
  });
  let resolvePull;
  const rs = new ReadableStream({
    pull() {
      resolvePullCalledPromise();
      return new Promise(resolve => {
        resolvePull = resolve;
      });
    },
    type: 'bytes'
  });
  const reader = rs.getReader({ mode: 'byob' });
  const read = reader.read(new Uint8Array(16));
  await pullCalledPromise;
  resolvePull();
  await delay(0);
  reader.releaseLock();
  await promise_rejects_js(t, TypeError, read, 'pending read should reject');
}, 'pull() resolving should not resolve read()');

promise_test(() => {
  // Tests https://github.com/whatwg/streams/issues/686

  let controller;
  const rs = new ReadableStream({
    autoAllocateChunkSize: 128,
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });

  const readPromise = rs.getReader().read();

  const br = controller.byobRequest;
  controller.close();

  br.respond(0);

  return readPromise;
}, 'ReadableStream with byte source: default reader + autoAllocateChunkSize + byobRequest interaction');

test(() => {
  assert_throws_js(TypeError, () => new ReadableStream({ autoAllocateChunkSize: 0, type: 'bytes' }),
      'controller cannot be setup with autoAllocateChunkSize = 0');
}, 'ReadableStream with byte source: autoAllocateChunkSize cannot be 0');

test(() => {
  const ReadableStreamBYOBReader = new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' }).constructor;
  const stream = new ReadableStream({ type: 'bytes' });
  new ReadableStreamBYOBReader(stream);
}, 'ReadableStreamBYOBReader can be constructed directly');

test(() => {
  const ReadableStreamBYOBReader = new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' }).constructor;
  assert_throws_js(TypeError, () => new ReadableStreamBYOBReader({}), 'constructor must throw');
}, 'ReadableStreamBYOBReader constructor requires a ReadableStream argument');

test(() => {
  const ReadableStreamBYOBReader = new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' }).constructor;
  const stream = new ReadableStream({ type: 'bytes' });
  stream.getReader();
  assert_throws_js(TypeError, () => new ReadableStreamBYOBReader(stream), 'constructor must throw');
}, 'ReadableStreamBYOBReader constructor requires an unlocked ReadableStream');

test(() => {
  const ReadableStreamBYOBReader = new ReadableStream({ type: 'bytes' }).getReader({ mode: 'byob' }).constructor;
  const stream = new ReadableStream();
  assert_throws_js(TypeError, () => new ReadableStreamBYOBReader(stream), 'constructor must throw');
}, 'ReadableStreamBYOBReader constructor requires a ReadableStream with type "bytes"');

test(() => {
  assert_throws_js(RangeError, () => new ReadableStream({ type: 'bytes' }, {
    size() {
      return 1;
    }
  }), 'constructor should throw for size function');

  assert_throws_js(RangeError,
                   () => new ReadableStream({ type: 'bytes' }, new CountQueuingStrategy({ highWaterMark: 1 })),
                   'constructor should throw when strategy is CountQueuingStrategy');

  assert_throws_js(RangeError,
                   () => new ReadableStream({ type: 'bytes' }, new ByteLengthQueuingStrategy({ highWaterMark: 512 })),
                   'constructor should throw when strategy is ByteLengthQueuingStrategy');

  class HasSizeMethod {
    size() {}
 }

  assert_throws_js(RangeError, () => new ReadableStream({ type: 'bytes' }, new HasSizeMethod()),
                   'constructor should throw when size on the prototype chain');
}, 'ReadableStream constructor should not accept a strategy with a size defined if type is "bytes"');

promise_test(async t => {
  const stream = new ReadableStream({
    pull: t.step_func(c => {
      const view = new Uint8Array(c.byobRequest.view.buffer, 0, 1);
      view[0] = 1;

      c.byobRequest.respondWithNewView(view);
    }),
    type: 'bytes'
  });
  const reader = stream.getReader({ mode: 'byob' });

  const result = await reader.read(new Uint8Array([4, 5, 6]));
  assert_false(result.done, 'result.done');

  const view = result.value;
  assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
  assert_equals(view.byteLength, 1, 'result.value.byteLength');
  assert_equals(view[0], 1, 'result.value[0]');
  assert_equals(view.buffer.byteLength, 3, 'result.value.buffer.byteLength');
  assert_array_equals([...new Uint8Array(view.buffer)], [1, 5, 6], 'result.value.buffer');
}, 'ReadableStream with byte source: respondWithNewView() with a smaller view');

promise_test(async t => {
  const stream = new ReadableStream({
    pull: t.step_func(c => {
      const view = new Uint8Array(c.byobRequest.view.buffer, 0, 0);

      c.close();

      c.byobRequest.respondWithNewView(view);
    }),
    type: 'bytes'
  });
  const reader = stream.getReader({ mode: 'byob' });

  const result = await reader.read(new Uint8Array([4, 5, 6]));
  assert_true(result.done, 'result.done');

  const view = result.value;
  assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
  assert_equals(view.byteLength, 0, 'result.value.byteLength');
  assert_equals(view.buffer.byteLength, 3, 'result.value.buffer.byteLength');
  assert_array_equals([...new Uint8Array(view.buffer)], [4, 5, 6], 'result.value.buffer');
}, 'ReadableStream with byte source: respondWithNewView() with a zero-length view (in the closed state)');

promise_test(async t => {
  let controller;
  let resolvePullCalledPromise;
  const pullCalledPromise = new Promise(resolve => {
    resolvePullCalledPromise = resolve;
  });
  const stream = new ReadableStream({
    start: t.step_func((c) => {
      controller = c;
    }),
    pull: t.step_func(() => {
      resolvePullCalledPromise();
    }),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });
  const readPromise = reader.read(new Uint8Array([4, 5, 6]));
  await pullCalledPromise;

  // Transfer the original BYOB request's buffer, and respond with a new view on that buffer
  const transferredView = await transferArrayBufferView(controller.byobRequest.view);
  const newView = transferredView.subarray(0, 1);
  newView[0] = 42;

  controller.byobRequest.respondWithNewView(newView);

  const result = await readPromise;
  assert_false(result.done, 'result.done');

  const view = result.value;
  assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
  assert_equals(view.byteLength, 1, 'result.value.byteLength');
  assert_equals(view[0], 42, 'result.value[0]');
  assert_equals(view.buffer.byteLength, 3, 'result.value.buffer.byteLength');
  assert_array_equals([...new Uint8Array(view.buffer)], [42, 5, 6], 'result.value.buffer');

}, 'ReadableStream with byte source: respondWithNewView() with a transferred non-zero-length view ' +
   '(in the readable state)');

promise_test(async t => {
  let controller;
  let resolvePullCalledPromise;
  const pullCalledPromise = new Promise(resolve => {
    resolvePullCalledPromise = resolve;
  });
  const stream = new ReadableStream({
    start: t.step_func((c) => {
      controller = c;
    }),
    pull: t.step_func(() => {
      resolvePullCalledPromise();
    }),
    type: 'bytes'
  });

  const reader = stream.getReader({ mode: 'byob' });
  const readPromise = reader.read(new Uint8Array([4, 5, 6]));
  await pullCalledPromise;

  // Transfer the original BYOB request's buffer, and respond with an empty view on that buffer
  const transferredView = await transferArrayBufferView(controller.byobRequest.view);
  const newView = transferredView.subarray(0, 0);

  controller.close();
  controller.byobRequest.respondWithNewView(newView);

  const result = await readPromise;
  assert_true(result.done, 'result.done');

  const view = result.value;
  assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
  assert_equals(view.byteLength, 0, 'result.value.byteLength');
  assert_equals(view.buffer.byteLength, 3, 'result.value.buffer.byteLength');
  assert_array_equals([...new Uint8Array(view.buffer)], [4, 5, 6], 'result.value.buffer');

}, 'ReadableStream with byte source: respondWithNewView() with a transferred zero-length view ' +
   '(in the closed state)');

promise_test(async t => {
  let controller;
  let pullCount = 0;
  const rs = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 10,
    start: t.step_func((c) => {
      controller = c;
    }),
    pull: t.step_func(() => {
      ++pullCount;
    })
  });

  await flushAsyncEvents();
  assert_equals(pullCount, 0, 'pull() must not have been invoked yet');

  const reader1 = rs.getReader();
  const read1 = reader1.read();
  assert_equals(pullCount, 1, 'pull() must have been invoked once');
  const byobRequest1 = controller.byobRequest;
  assert_equals(byobRequest1.view.byteLength, 10, 'first byobRequest.view.byteLength');

  // enqueue() must discard the auto-allocated BYOB request
  controller.enqueue(new Uint8Array([1, 2, 3]));
  assert_equals(byobRequest1.view, null, 'first byobRequest must be invalidated after enqueue()');

  const result1 = await read1;
  assert_false(result1.done, 'first result.done');
  const view1 = result1.value;
  assert_equals(view1.byteOffset, 0, 'first result.value.byteOffset');
  assert_equals(view1.byteLength, 3, 'first result.value.byteLength');
  assert_array_equals([...new Uint8Array(view1.buffer)], [1, 2, 3], 'first result.value.buffer');

  reader1.releaseLock();

  // read(view) should work after discarding the auto-allocated BYOB request
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_equals(pullCount, 2, 'pull() must have been invoked twice');
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2.view.byteOffset, 0, 'second byobRequest.view.byteOffset');
  assert_equals(byobRequest2.view.byteLength, 3, 'second byobRequest.view.byteLength');
  assert_array_equals([...new Uint8Array(byobRequest2.view.buffer)], [4, 5, 6], 'second byobRequest.view.buffer');

  byobRequest2.respond(3);
  assert_equals(byobRequest2.view, null, 'second byobRequest must be invalidated after respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  const view2 = result2.value;
  assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset');
  assert_equals(view2.byteLength, 3, 'second result.value.byteLength');
  assert_array_equals([...new Uint8Array(view2.buffer)], [4, 5, 6], 'second result.value.buffer');

  reader2.releaseLock();
  assert_equals(pullCount, 2, 'pull() must only have been invoked twice');
}, 'ReadableStream with byte source: enqueue() discards auto-allocated BYOB request');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged');
  assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respond() should fulfill the *second* read() request
  byobRequest1.view[0] = 11;
  byobRequest1.respond(1);
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value');

}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respond()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint16Array(1));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged');
  assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respond(1) should partially fill the second read(), but not yet fulfill it
  byobRequest1.view[0] = 0x11;
  byobRequest1.respond(1);

  // second BYOB request should use remaining buffer from the second read()
  const byobRequest2 = controller.byobRequest;
  assert_not_equals(byobRequest2, null, 'second byobRequest should exist');
  assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view');

  // second respond(1) should fill the read request and fulfill it
  byobRequest2.view[0] = 0x22;
  byobRequest2.respond(1);
  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  const view2 = result2.value;
  assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset');
  assert_equals(view2.byteLength, 2, 'second result.value.byteLength');
  const dataView2 = new DataView(view2.buffer, view2.byteOffset, view2.byteLength);
  assert_equals(dataView2.getUint16(0), 0x1122, 'second result.value[0]');

}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with ' +
   '1 element Uint16Array, respond(1)');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged');
  assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respond(3) should fulfill the second read(), and put 1 remaining byte in the queue
  byobRequest1.view[0] = 6;
  byobRequest1.view[1] = 7;
  byobRequest1.view[2] = 8;
  byobRequest1.respond(3);
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([6, 7]), 'second result.value');

  // third read() should fulfill with the remaining byte
  const result3 = await reader2.read(new Uint8Array([0, 0, 0]));
  assert_false(result3.done, 'third result.done');
  assert_typed_array_equals(result3.value, new Uint8Array([8, 0, 0]).subarray(0, 1), 'third result.value');

}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with ' +
   '2 element Uint8Array, respond(3)');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respondWithNewView() should fulfill the *second* read() request
  byobRequest1.view[0] = 11;
  byobRequest1.view[1] = 12;
  byobRequest1.respondWithNewView(byobRequest1.view.subarray(0, 2));
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respondWithNewView()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 12, 6]).subarray(0, 2), 'second result.value');

}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respondWithNewView()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // enqueue() should fulfill the *second* read() request
  controller.enqueue(new Uint8Array([11, 12]));
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 12, 6]).subarray(0, 2), 'second result.value');

}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, enqueue()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint8Array([1, 2, 3]));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // close() followed by respond(0) should fulfill the second read()
  controller.close();
  byobRequest1.respond(0);
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respond()');

  const result2 = await read2;
  assert_true(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([4, 5, 6]).subarray(0, 0), 'second result.value');
}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, ' +
   'close(), respond(0)');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 4,
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader();
  const read1 = reader1.read();
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader();
  const read2 = reader2.read();
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respond() should fulfill the *second* read() request
  byobRequest1.view[0] = 11;
  byobRequest1.respond(1);
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 0, 0, 0]).subarray(0, 1), 'second result.value');

}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, respond()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 4,
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader();
  const read1 = reader1.read();
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader();
  const read2 = reader2.read();
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // enqueue() should fulfill the *second* read() request
  controller.enqueue(new Uint8Array([11]));
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11]), 'second result.value');

}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, enqueue()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 4,
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader();
  const read1 = reader1.read();
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // respond() should fulfill the *second* read() request
  byobRequest1.view[0] = 11;
  byobRequest1.respond(1);
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value');

}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, respond()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 4,
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader();
  const read1 = reader1.read();
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint8Array([4, 5, 6]));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // enqueue() should fulfill the *second* read() request
  controller.enqueue(new Uint8Array([11]));
  const byobRequest2 = controller.byobRequest;
  assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value');

}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, enqueue()');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint16Array(1));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([0, 0]), 'first byobRequest.view');

  // respond(1) should partially fill the first read(), but not yet fulfill it
  byobRequest1.view[0] = 0x11;
  byobRequest1.respond(1);
  const byobRequest2 = controller.byobRequest;
  assert_not_equals(byobRequest2, null, 'second byobRequest should exist');
  assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader({ mode: 'byob' });
  const read2 = reader2.read(new Uint16Array(1));
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  assert_equals(controller.byobRequest, byobRequest2, 'byobRequest should be unchanged');
  assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'byobRequest.view should be unchanged');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // second respond(1) should fill the read request and fulfill it
  byobRequest2.view[0] = 0x22;
  byobRequest2.respond(1);
  assert_equals(controller.byobRequest, null, 'byobRequest should be invalidated after second respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  const view2 = result2.value;
  assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset');
  assert_equals(view2.byteLength, 2, 'second result.value.byteLength');
  const dataView2 = new DataView(view2.buffer, view2.byteOffset, view2.byteLength);
  assert_equals(dataView2.getUint16(0), 0x1122, 'second result.value[0]');

}, 'ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read(view) on ' +
   'second reader with 1 element Uint16Array, respond(1)');

promise_test(async t => {
  let controller;
  const rs = new ReadableStream({
    type: 'bytes',
    start: t.step_func((c) => {
      controller = c;
    })
  });
  await flushAsyncEvents();

  const reader1 = rs.getReader({ mode: 'byob' });
  const read1 = reader1.read(new Uint16Array(1));
  const byobRequest1 = controller.byobRequest;
  assert_not_equals(byobRequest1, null, 'first byobRequest should exist');
  assert_typed_array_equals(byobRequest1.view, new Uint8Array([0, 0]), 'first byobRequest.view');

  // respond(1) should partially fill the first read(), but not yet fulfill it
  byobRequest1.view[0] = 0x11;
  byobRequest1.respond(1);
  const byobRequest2 = controller.byobRequest;
  assert_not_equals(byobRequest2, null, 'second byobRequest should exist');
  assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view');

  // releaseLock() should reject the pending read, but *not* invalidate the BYOB request
  reader1.releaseLock();
  const reader2 = rs.getReader();
  const read2 = reader2.read();
  assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()');
  assert_equals(controller.byobRequest, byobRequest2, 'byobRequest should be unchanged');
  assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'byobRequest.view should be unchanged');
  await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()');

  // enqueue() should fulfill the read request and put remaining byte in the queue
  controller.enqueue(new Uint8Array([0x22]));
  assert_equals(controller.byobRequest, null, 'byobRequest should be invalidated after second respond()');

  const result2 = await read2;
  assert_false(result2.done, 'second result.done');
  assert_typed_array_equals(result2.value, new Uint8Array([0x11]), 'second result.value');

  const result3 = await reader2.read();
  assert_false(result3.done, 'third result.done');
  assert_typed_array_equals(result3.value, new Uint8Array([0x22]), 'third result.value');

}, 'ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read() on ' +
   'second reader, enqueue()');

promise_test(async t => {
  // Tests https://github.com/nodejs/node/issues/41886
  const stream = new ReadableStream({
    type: 'bytes',
    autoAllocateChunkSize: 10,
    pull: t.step_func((c) => {
      const newView = new Uint8Array(c.byobRequest.view.buffer, 0, 3);
      newView.set([20, 21, 22]);
      c.byobRequest.respondWithNewView(newView);
    })
  });

  const reader = stream.getReader();
  const result = await reader.read();
  assert_false(result.done, 'result.done');

  const view = result.value;
  assert_equals(view.byteOffset, 0, 'result.value.byteOffset');
  assert_equals(view.byteLength, 3, 'result.value.byteLength');
  assert_equals(view.buffer.byteLength, 10, 'result.value.buffer.byteLength');
  assert_array_equals([...new Uint8Array(view)], [20, 21, 22], 'result.value');
}, 'ReadableStream with byte source: autoAllocateChunkSize, read(), respondWithNewView()');
