mozilla-central/testing/web-platform/tests/streams/writable-streams/write.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

// META: global=window,worker,shadowrealm
// META: script=../resources/test-utils.js
// META: script=../resources/recording-streams.js
'use strict';
const error1 = new Error('error1');
error1.name = 'error1';
const error2 = new Error('error2');
error2.name = 'error2';
function writeArrayToStream(array, writableStreamWriter) {
array.forEach(chunk => writableStreamWriter.write(chunk));
return writableStreamWriter.close();
}
promise_test(() => {
let storage;
const ws = new WritableStream({
start() {
storage = [];
},
write(chunk) {
return delay(0).then(() => storage.push(chunk));
},
close() {
return delay(0);
}
});
const writer = ws.getWriter();
const input = [1, 2, 3, 4, 5];
return writeArrayToStream(input, writer)
.then(() => assert_array_equals(storage, input, 'correct data should be relayed to underlying sink'));
}, 'WritableStream should complete asynchronous writes before close resolves');
promise_test(() => {
const ws = recordingWritableStream();
const writer = ws.getWriter();
const input = [1, 2, 3, 4, 5];
return writeArrayToStream(input, writer)
.then(() => assert_array_equals(ws.events, ['write', 1, 'write', 2, 'write', 3, 'write', 4, 'write', 5, 'close'],
'correct data should be relayed to underlying sink'));
}, 'WritableStream should complete synchronous writes before close resolves');
promise_test(() => {
const ws = new WritableStream({
write() {
return 'Hello';
}
});
const writer = ws.getWriter();
const writePromise = writer.write('a');
return writePromise
.then(value => assert_equals(value, undefined, 'fulfillment value must be undefined'));
}, 'fulfillment value of ws.write() call should be undefined even if the underlying sink returns a non-undefined ' +
'value');
promise_test(() => {
let resolveSinkWritePromise;
const ws = new WritableStream({
write() {
return new Promise(resolve => {
resolveSinkWritePromise = resolve;
});
}
});
const writer = ws.getWriter();
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
return writer.ready.then(() => {
const writePromise = writer.write('a');
let writePromiseResolved = false;
assert_not_equals(resolveSinkWritePromise, undefined, 'resolveSinkWritePromise should not be undefined');
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after writer.write()');
return Promise.all([
writePromise.then(value => {
writePromiseResolved = true;
assert_equals(resolveSinkWritePromise, undefined, 'sinkWritePromise should be fulfilled before writePromise');
assert_equals(value, undefined, 'writePromise should be fulfilled with undefined');
}),
writer.ready.then(value => {
assert_equals(resolveSinkWritePromise, undefined, 'sinkWritePromise should be fulfilled before writer.ready');
assert_true(writePromiseResolved, 'writePromise should be fulfilled before writer.ready');
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1 again');
assert_equals(value, undefined, 'writePromise should be fulfilled with undefined');
}),
flushAsyncEvents().then(() => {
resolveSinkWritePromise();
resolveSinkWritePromise = undefined;
})
]);
});
}, 'WritableStream should transition to waiting until write is acknowledged');
promise_test(t => {
let sinkWritePromiseRejectors = [];
const ws = new WritableStream({
write() {
const sinkWritePromise = new Promise((r, reject) => sinkWritePromiseRejectors.push(reject));
return sinkWritePromise;
}
});
const writer = ws.getWriter();
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
return writer.ready.then(() => {
const writePromise = writer.write('a');
assert_equals(sinkWritePromiseRejectors.length, 1, 'there should be 1 rejector');
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0');
const writePromise2 = writer.write('b');
assert_equals(sinkWritePromiseRejectors.length, 1, 'there should be still 1 rejector');
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1');
const closedPromise = writer.close();
assert_equals(writer.desiredSize, -1, 'desiredSize should still be -1');
return Promise.all([
promise_rejects_exactly(t, error1, closedPromise,
'closedPromise should reject with the error returned from the sink\'s write method')
.then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
'sinkWritePromise should reject before closedPromise')),
promise_rejects_exactly(t, error1, writePromise,
'writePromise should reject with the error returned from the sink\'s write method')
.then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
'sinkWritePromise should reject before writePromise')),
promise_rejects_exactly(t, error1, writePromise2,
'writePromise2 should reject with the error returned from the sink\'s write method')
.then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
'sinkWritePromise should reject before writePromise2')),
flushAsyncEvents().then(() => {
sinkWritePromiseRejectors[0](error1);
sinkWritePromiseRejectors = [];
})
]);
});
}, 'when write returns a rejected promise, queued writes and close should be cleared');
promise_test(t => {
const ws = new WritableStream({
write() {
throw error1;
}
});
const writer = ws.getWriter();
return promise_rejects_exactly(t, error1, writer.write('a'),
'write() should reject with the error returned from the sink\'s write method')
.then(() => promise_rejects_js(t, TypeError, writer.close(), 'close() should be rejected'));
}, 'when sink\'s write throws an error, the stream should become errored and the promise should reject');
promise_test(t => {
const ws = new WritableStream({
write(chunk, controller) {
controller.error(error1);
throw error2;
}
});
const writer = ws.getWriter();
return promise_rejects_exactly(t, error2, writer.write('a'),
'write() should reject with the error returned from the sink\'s write method ')
.then(() => {
return Promise.all([
promise_rejects_exactly(t, error1, writer.ready,
'writer.ready must reject with the error passed to the controller'),
promise_rejects_exactly(t, error1, writer.closed,
'writer.closed must reject with the error passed to the controller')
]);
});
}, 'writer.write(), ready and closed reject with the error passed to controller.error() made before sink.write' +
' rejection');
promise_test(() => {
const numberOfWrites = 1000;
let resolveFirstWritePromise;
let writeCount = 0;
const ws = new WritableStream({
write() {
++writeCount;
if (!resolveFirstWritePromise) {
return new Promise(resolve => {
resolveFirstWritePromise = resolve;
});
}
return Promise.resolve();
}
});
const writer = ws.getWriter();
return writer.ready.then(() => {
for (let i = 1; i < numberOfWrites; ++i) {
writer.write('a');
}
const writePromise = writer.write('a');
assert_equals(writeCount, 1, 'should have called sink\'s write once');
resolveFirstWritePromise();
return writePromise
.then(() =>
assert_equals(writeCount, numberOfWrites, `should have called sink's write ${numberOfWrites} times`));
});
}, 'a large queue of writes should be processed completely');
promise_test(() => {
const stream = recordingWritableStream();
const w = stream.getWriter();
const WritableStreamDefaultWriter = w.constructor;
w.releaseLock();
const writer = new WritableStreamDefaultWriter(stream);
return writer.ready.then(() => {
writer.write('a');
assert_array_equals(stream.events, ['write', 'a'], 'write() should be passed to sink');
});
}, 'WritableStreamDefaultWriter should work when manually constructed');
promise_test(() => {
let thenCalled = false;
const ws = new WritableStream({
write() {
return {
then(onFulfilled) {
thenCalled = true;
onFulfilled();
}
};
}
});
return ws.getWriter().write('a').then(() => assert_true(thenCalled, 'thenCalled should be true'));
}, 'returning a thenable from write() should work');
promise_test(() => {
const stream = new WritableStream();
const writer = stream.getWriter();
const WritableStreamDefaultWriter = writer.constructor;
assert_throws_js(TypeError, () => new WritableStreamDefaultWriter(stream),
'should not be able to construct on locked stream');
// If stream.[[writer]] no longer points to |writer| then the closed Promise
// won't work properly.
return Promise.all([writer.close(), writer.closed]);
}, 'failing DefaultWriter constructor should not release an existing writer');
promise_test(t => {
const ws = new WritableStream({
start() {
return Promise.reject(error1);
}
}, { highWaterMark: 0 });
const writer = ws.getWriter();
return Promise.all([
promise_rejects_exactly(t, error1, writer.ready, 'ready should be rejected'),
promise_rejects_exactly(t, error1, writer.write(), 'write() should be rejected')
]);
}, 'write() on a stream with HWM 0 should not cause the ready Promise to resolve');
promise_test(t => {
const ws = new WritableStream();
const writer = ws.getWriter();
writer.releaseLock();
return promise_rejects_js(t, TypeError, writer.write(), 'write should reject');
}, 'writing to a released writer should reject the returned promise');