mozilla-central/testing/web-platform/tests/streams/readable-byte-streams/read-min.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

// META: global=window,worker,shadowrealm
// META: script=../resources/rs-utils.js
// META: script=../resources/test-utils.js
'use strict';
// 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(async t => {
const rs = new ReadableStream({
type: 'bytes',
pull: t.unreached_func('pull() should not be called'),
});
const reader = rs.getReader({ mode: 'byob' });
await promise_rejects_js(t, TypeError, reader.read(new Uint8Array(1), { min: 0 }));
}, 'ReadableStream with byte source: read({ min }) rejects if min is 0');
promise_test(async t => {
const rs = new ReadableStream({
type: 'bytes',
pull: t.unreached_func('pull() should not be called'),
});
const reader = rs.getReader({ mode: 'byob' });
await promise_rejects_js(t, TypeError, reader.read(new Uint8Array(1), { min: -1 }));
}, 'ReadableStream with byte source: read({ min }) rejects if min is negative');
promise_test(async t => {
const rs = new ReadableStream({
type: 'bytes',
pull: t.unreached_func('pull() should not be called'),
});
const reader = rs.getReader({ mode: 'byob' });
await promise_rejects_js(t, RangeError, reader.read(new Uint8Array(1), { min: 2 }));
}, 'ReadableStream with byte source: read({ min }) rejects if min is larger than view\'s length (Uint8Array)');
promise_test(async t => {
const rs = new ReadableStream({
type: 'bytes',
pull: t.unreached_func('pull() should not be called'),
});
const reader = rs.getReader({ mode: 'byob' });
await promise_rejects_js(t, RangeError, reader.read(new Uint16Array(1), { min: 2 }));
}, 'ReadableStream with byte source: read({ min }) rejects if min is larger than view\'s length (Uint16Array)');
promise_test(async t => {
const rs = new ReadableStream({
type: 'bytes',
pull: t.unreached_func('pull() should not be called'),
});
const reader = rs.getReader({ mode: 'byob' });
await promise_rejects_js(t, RangeError, reader.read(new DataView(new ArrayBuffer(1)), { min: 2 }));
}, 'ReadableStream with byte source: read({ min }) rejects if min is larger than view\'s length (DataView)');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
view[0] = 0x01;
view[1] = 0x02;
byobRequest.respond(2);
} else if (pullCount === 1) {
view[0] = 0x03;
byobRequest.respond(1);
} else if (pullCount === 2) {
view[0] = 0x04;
byobRequest.respond(1);
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const read1 = reader.read(new Uint8Array(3), { min: 3 });
const read2 = reader.read(new Uint8Array(1));
const result1 = await read1;
assert_false(result1.done, 'first result should not be done');
assert_typed_array_equals(result1.value, new Uint8Array([0x01, 0x02, 0x03]), 'first result value');
const result2 = await read2;
assert_false(result2.done, 'second result should not be done');
assert_typed_array_equals(result2.value, new Uint8Array([0x04]), 'second result value');
assert_equals(pullCount, 3, 'pull() must have been called 3 times');
{
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, 3, 'first view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 3, 'first view.byteLength should be 3');
}
{
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, 3, 'second view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 2, 'second view.byteOffset should be 2');
assert_equals(viewInfo.byteLength, 1, 'second view.byteLength should be 1');
}
{
const byobRequest = byobRequests[2];
assert_true(byobRequest.nonNull, 'third byobRequest must not be null');
assert_true(byobRequest.viewNonNull, 'third byobRequest.view must not be null');
const viewInfo = byobRequest.viewInfo;
assert_equals(viewInfo.constructor, Uint8Array, 'third view.constructor should be Uint8Array');
assert_equals(viewInfo.bufferByteLength, 1, 'third view.buffer.byteLength should be 1');
assert_equals(viewInfo.byteOffset, 0, 'third view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 1, 'third view.byteLength should be 1');
}
}, 'ReadableStream with byte source: read({ min }), then read()');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
view[0] = 0x01;
view[1] = 0x02;
byobRequest.respond(2);
} else if (pullCount === 1) {
view[0] = 0x03;
byobRequest.respond(1);
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new DataView(new ArrayBuffer(3)), { min: 3 });
assert_false(result.done, 'result should not be done');
assert_equals(result.value.constructor, DataView, 'result.value must be a DataView');
assert_equals(result.value.byteOffset, 0, 'result.value.byteOffset');
assert_equals(result.value.byteLength, 3, 'result.value.byteLength');
assert_equals(result.value.buffer.byteLength, 3, 'result.value.buffer.byteLength');
assert_array_equals([...new Uint8Array(result.value.buffer)], [0x01, 0x02, 0x03], `result.value.buffer contents`);
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
{
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, 3, 'first view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 3, 'first view.byteLength should be 3');
}
{
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, 3, 'second view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 2, 'second view.byteOffset should be 2');
assert_equals(viewInfo.byteLength, 1, 'second view.byteLength should be 1');
}
}, 'ReadableStream with byte source: read({ min }) with a DataView');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
start: t.step_func((c) => {
c.enqueue(new Uint8Array([0x01]));
}),
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
view[0] = 0x02;
view[1] = 0x03;
byobRequest.respond(2);
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(3), { min: 3 });
assert_false(result.done, 'first result should not be done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0x02, 0x03]), 'first result value');
assert_equals(pullCount, 1, 'pull() must have only been called 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, 3, 'first view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 1, 'first view.byteOffset should be 1');
assert_equals(viewInfo.byteLength, 2, 'first view.byteLength should be 2');
}, 'ReadableStream with byte source: enqueue(), then read({ min })');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
c.enqueue(new Uint8Array([0x01, 0x02]));
} else if (pullCount === 1) {
c.enqueue(new Uint8Array([0x03]));
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(3), { min: 3 });
assert_false(result.done, 'first result should not be done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0x02, 0x03]), 'first result value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
{
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, 3, 'first view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 3, 'first view.byteLength should be 3');
}
{
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, 3, 'second view.buffer.byteLength should be 3');
assert_equals(viewInfo.byteOffset, 2, 'second view.byteOffset should be 2');
assert_equals(viewInfo.byteLength, 1, 'second view.byteLength should be 1');
}
}, 'ReadableStream with byte source: read({ min: 3 }) on a 3-byte Uint8Array, then multiple enqueue() up to 3 bytes');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
c.enqueue(new Uint8Array([0x01, 0x02]));
} else if (pullCount === 1) {
c.enqueue(new Uint8Array([0x03]));
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(5), { min: 3 });
assert_false(result.done, 'first result should not be done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0x02, 0x03, 0, 0]).subarray(0, 3), 'first result value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
{
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, 5, 'first view.buffer.byteLength should be 5');
assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 5, 'first view.byteLength should be 5');
}
{
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, 5, 'second view.buffer.byteLength should be 5');
assert_equals(viewInfo.byteOffset, 2, 'second view.byteOffset should be 2');
assert_equals(viewInfo.byteLength, 3, 'second view.byteLength should be 3');
}
}, 'ReadableStream with byte source: read({ min: 3 }) on a 5-byte Uint8Array, then multiple enqueue() up to 3 bytes');
promise_test(async t => {
let pullCount = 0;
const byobRequests = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
const byobRequest = c.byobRequest;
const view = byobRequest.view;
byobRequests[pullCount] = {
nonNull: byobRequest !== null,
viewNonNull: view !== null,
viewInfo: extractViewInfo(view)
};
if (pullCount === 0) {
c.enqueue(new Uint8Array([0x01, 0x02]));
} else if (pullCount === 1) {
c.enqueue(new Uint8Array([0x03, 0x04]));
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(5), { min: 3 });
assert_false(result.done, 'first result should not be done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0x02, 0x03, 0x04, 0]).subarray(0, 4), 'first result value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
{
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, 5, 'first view.buffer.byteLength should be 5');
assert_equals(viewInfo.byteOffset, 0, 'first view.byteOffset should be 0');
assert_equals(viewInfo.byteLength, 5, 'first view.byteLength should be 5');
}
{
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, 5, 'second view.buffer.byteLength should be 5');
assert_equals(viewInfo.byteOffset, 2, 'second view.byteOffset should be 2');
assert_equals(viewInfo.byteLength, 3, 'second view.byteLength should be 3');
}
}, 'ReadableStream with byte source: read({ min: 3 }) on a 5-byte Uint8Array, then multiple enqueue() up to 4 bytes');
promise_test(async 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' });
const result1 = await byobReader.read(new Uint8Array(8), { min: 8 });
assert_false(result1.done, 'result1.done');
const view1 = result1.value;
assert_equals(view1.constructor, Uint8Array, 'result1.value.constructor');
assert_equals(view1.buffer.byteLength, 8, 'result1.value.buffer.byteLength');
assert_equals(view1.byteOffset, 0, 'result1.value.byteOffset');
assert_equals(view1.byteLength, 8, 'result1.value.byteLength');
assert_equals(view1[0], 0x01, 'result1.value[0]');
byobReader.releaseLock();
const reader = stream.getReader();
const result2 = await reader.read();
assert_false(result2.done, 'result2.done');
const view2 = result2.value;
assert_equals(view2.constructor, Uint8Array, 'result2.value.constructor');
assert_equals(view2.buffer.byteLength, 16, 'result2.value.buffer.byteLength');
assert_equals(view2.byteOffset, 8, 'result2.value.byteOffset');
assert_equals(view2.byteLength, 8, 'result2.value.byteLength');
assert_equals(view2[0], 0x02, 'result2.value[0]');
}, 'ReadableStream with byte source: enqueue(), read({ min }) partially, then read()');
promise_test(async () => {
let pullCount = 0;
const byobRequestDefined = [];
let byobRequestViewDefined;
const stream = new ReadableStream({
async pull(c) {
byobRequestDefined.push(c.byobRequest !== null);
const initialByobRequest = c.byobRequest;
const transferredView = await transferArrayBufferView(c.byobRequest.view);
transferredView[0] = 0x01;
c.byobRequest.respondWithNewView(transferredView);
byobRequestDefined.push(c.byobRequest !== null);
byobRequestViewDefined = initialByobRequest.view !== null;
++pullCount;
},
type: 'bytes'
});
const reader = stream.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(1), { min: 1 });
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({ min }), then respondWithNewView() with a transferred ArrayBuffer');
promise_test(async 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' });
const result = await reader.read(new Uint8Array([0x01]), { min: 1 });
assert_true(result.done, 'result.done');
assert_typed_array_equals(result.value, new Uint8Array([0x01]).subarray(0, 0), 'result.value');
await reader.closed;
}, 'ReadableStream with byte source: read({ min }) on a closed stream');
promise_test(async t => {
let pullCount = 0;
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
if (pullCount === 0) {
c.byobRequest.view[0] = 0x01;
c.byobRequest.respond(1);
} else if (pullCount === 1) {
c.close();
c.byobRequest.respond(0);
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(3), { min: 3 });
assert_true(result.done, 'result.done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0, 0]).subarray(0, 1), 'result.value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
await reader.closed;
}, 'ReadableStream with byte source: read({ min }) when closed before view is filled');
promise_test(async t => {
let pullCount = 0;
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
if (pullCount === 0) {
c.byobRequest.view[0] = 0x01;
c.byobRequest.view[1] = 0x02;
c.byobRequest.respond(2);
} else if (pullCount === 1) {
c.byobRequest.view[0] = 0x03;
c.byobRequest.respond(1);
c.close();
}
++pullCount;
})
});
const reader = rs.getReader({ mode: 'byob' });
const result = await reader.read(new Uint8Array(3), { min: 3 });
assert_false(result.done, 'result.done');
assert_typed_array_equals(result.value, new Uint8Array([0x01, 0x02, 0x03]), 'result.value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
await reader.closed;
}, 'ReadableStream with byte source: read({ min }) when closed immediately after view is filled');
promise_test(async t => {
const error1 = new Error('error1');
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' });
const read = reader.read(new Uint8Array(1), { min: 1 });
await Promise.all([
promise_rejects_exactly(t, error1, read, 'read() must fail'),
promise_rejects_exactly(t, error1, reader.closed, 'closed must fail')
]);
}, 'ReadableStream with byte source: read({ min }) on an errored stream');
promise_test(async t => {
const error1 = new Error('error1');
let controller;
const stream = new ReadableStream({
start(c) {
controller = c;
},
type: 'bytes'
});
const reader = stream.getReader({ mode: 'byob' });
const read = reader.read(new Uint8Array(1), { min: 1 });
controller.error(error1);
await Promise.all([
promise_rejects_exactly(t, error1, read, 'read() must fail'),
promise_rejects_exactly(t, error1, reader.closed, 'closed must fail')
]);
}, 'ReadableStream with byte source: read({ min }), then error()');
promise_test(t => {
let cancelCount = 0;
let reason;
const passedReason = new TypeError('foo');
const stream = new ReadableStream({
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), { min: 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({ min }), then cancel()');
promise_test(async t => {
let pullCount = 0;
let byobRequest;
const viewInfos = [];
const rs = new ReadableStream({
type: 'bytes',
pull: t.step_func((c) => {
byobRequest = c.byobRequest;
viewInfos.push(extractViewInfo(c.byobRequest.view));
c.byobRequest.view[0] = 0x01;
c.byobRequest.respond(1);
viewInfos.push(extractViewInfo(c.byobRequest.view));
++pullCount;
})
});
await Promise.resolve();
assert_equals(pullCount, 0, 'pull() must not have been called yet');
const reader = rs.getReader({ mode: 'byob' });
const read = reader.read(new Uint8Array(3), { min: 3 });
assert_equals(pullCount, 1, 'pull() must have been called once');
assert_not_equals(byobRequest, null, 'byobRequest should not be null');
assert_equals(viewInfos[0].byteLength, 3, 'byteLength before respond() should be 3');
assert_equals(viewInfos[1].byteLength, 2, 'byteLength after respond() should be 2');
reader.cancel().catch(t.unreached_func('cancel() should not reject'));
const result = await read;
assert_true(result.done, 'result.done');
assert_equals(result.value, undefined, 'result.value');
assert_equals(pullCount, 1, 'pull() must only be called once');
await reader.closed;
}, 'ReadableStream with byte source: cancel() with partially filled pending read({ min }) request');
promise_test(async () => {
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' });
const result1 = await reader.read(new Uint8Array(8), { min: 8 });
assert_false(result1.done, 'result1.done');
const view1 = result1.value;
assert_equals(view1.byteOffset, 0, 'result1.value.byteOffset');
assert_equals(view1.byteLength, 8, 'result1.value.byteLength');
assert_equals(view1[7], 0x01, 'result1.value[7]');
const result2 = await reader.read(new Uint8Array(8), { min: 8 });
assert_false(pullCalled, 'pull() must not have been called');
assert_false(result2.done, 'result2.done');
const view2 = result2.value;
assert_equals(view2.byteOffset, 0, 'result2.value.byteOffset');
assert_equals(view2.byteLength, 8, 'result2.value.byteLength');
assert_equals(view2[7], 0x02, 'result2.value[7]');
}, 'ReadableStream with byte source: enqueue(), then read({ min }) with smaller views');
promise_test(async t => {
const stream = new ReadableStream({
start(c) {
c.enqueue(new Uint8Array([0xaa, 0xbb, 0xcc]));
c.close();
},
pull: t.unreached_func('pull() should not be called'),
type: 'bytes'
});
const reader = stream.getReader({ mode: 'byob' });
await promise_rejects_js(t, TypeError, reader.read(new Uint16Array(2), { min: 2 }), 'read() must fail');
await promise_rejects_js(t, TypeError, reader.closed, 'reader.closed should reject');
}, 'ReadableStream with byte source: 3 byte enqueue(), then close(), then read({ min }) with 2-element Uint16Array must fail');
promise_test(async 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 readPromise = reader.read(new Uint16Array(2), { min: 2 });
controller.enqueue(new Uint8Array([0xaa, 0xbb, 0xcc]));
assert_throws_js(TypeError, () => controller.close(), 'controller.close() must throw');
await promise_rejects_js(t, TypeError, readPromise, 'read() must fail');
await promise_rejects_js(t, TypeError, reader.closed, 'reader.closed must reject');
}, 'ReadableStream with byte source: read({ min }) with 2-element Uint16Array, then 3 byte enqueue(), then close() must fail');
promise_test(async t => {
let pullCount = 0;
let controller;
const rs = new ReadableStream({
type: 'bytes',
start: t.step_func((c) => {
controller = c;
}),
pull: t.step_func((c) => {
++pullCount;
})
});
const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' }));
await Promise.resolve();
assert_equals(pullCount, 0, 'pull() must not have been called yet');
const read1 = reader1.read(new Uint8Array(3), { min: 3 });
const read2 = reader2.read(new Uint8Array(1));
assert_equals(pullCount, 1, 'pull() must have been called once');
const byobRequest1 = controller.byobRequest;
assert_equals(byobRequest1.view.byteLength, 3, 'first byobRequest.view.byteLength should be 3');
byobRequest1.view[0] = 0x01;
byobRequest1.respond(1);
const result2 = await read2;
assert_false(result2.done, 'branch2 first read() should not be done');
assert_typed_array_equals(result2.value, new Uint8Array([0x01]), 'branch2 first read() value');
assert_equals(pullCount, 2, 'pull() must have been called 2 times');
const byobRequest2 = controller.byobRequest;
assert_equals(byobRequest2.view.byteLength, 2, 'second byobRequest.view.byteLength should be 2');
byobRequest2.view[0] = 0x02;
byobRequest2.view[1] = 0x03;
byobRequest2.respond(2);
const result1 = await read1;
assert_false(result1.done, 'branch1 read() should not be done');
assert_typed_array_equals(result1.value, new Uint8Array([0x01, 0x02, 0x03]), 'branch1 read() value');
const result3 = await reader2.read(new Uint8Array(2));
assert_equals(pullCount, 2, 'pull() must only be called 2 times');
assert_false(result3.done, 'branch2 second read() should not be done');
assert_typed_array_equals(result3.value, new Uint8Array([0x02, 0x03]), 'branch2 second read() value');
}, 'ReadableStream with byte source: tee() with read({ min }) from branch1 and read() from branch2');