mirror of
https://github.com/servo/servo.git
synced 2025-09-12 07:58:20 +01:00
Update web-platform-tests and CSS tests.
- Update CSS tests to revision e05bfd5e30ed662c2f8a353577003f8eed230180. - Update web-platform-tests to revision a052787dd5c069a340031011196b73affbd68cd9.
This commit is contained in:
Ms2ger
parent
fb4f421c8b
commit
296fa2512b
21852 changed files with 2080936 additions and 892894 deletions
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>aborting.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('aborting.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>aborting.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script src="../resources/test-utils.js"></script>
|
||||
<script src="../resources/recording-streams.js"></script>
|
||||
|
||||
<script src="aborting.js"></script>
|
||||
|
|
@ -0,0 +1,875 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
self.importScripts('../resources/test-utils.js');
|
||||
self.importScripts('../resources/recording-streams.js');
|
||||
}
|
||||
|
||||
const error1 = new Error('error1');
|
||||
error1.name = 'error1';
|
||||
|
||||
const error2 = new Error('error2');
|
||||
error2.name = 'error2';
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(() => { }); // forever-pending, so normally .ready would not fulfill.
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
const writePromise = writer.write('a');
|
||||
|
||||
const readyPromise = writer.ready;
|
||||
|
||||
writer.abort(error1);
|
||||
|
||||
assert_equals(writer.ready, readyPromise, 'the ready promise property should not change');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writePromise, 'the write() promise should reject with a TypeError')
|
||||
]);
|
||||
}, 'Aborting a WritableStream before it starts should cause the writer\'s unsettled ready promise to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.write('a');
|
||||
|
||||
const readyPromise = writer.ready;
|
||||
|
||||
return readyPromise.then(() => {
|
||||
writer.abort(error1);
|
||||
|
||||
assert_not_equals(writer.ready, readyPromise, 'the ready promise property should change');
|
||||
return promise_rejects(t, new TypeError(), writer.ready, 'the ready promise should reject with a TypeError');
|
||||
});
|
||||
}, 'Aborting a WritableStream should cause the writer\'s fulfilled ready promise to reset to a rejected one');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.releaseLock();
|
||||
|
||||
return promise_rejects(t, new TypeError(), writer.abort(), 'abort() should reject with a TypeError');
|
||||
}, 'abort() on a released writer rejects');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = recordingWritableStream();
|
||||
|
||||
return delay(0)
|
||||
.then(() => {
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.abort();
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.write(1), 'write(1) must reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError')
|
||||
]);
|
||||
})
|
||||
.then(() => {
|
||||
assert_array_equals(ws.events, ['abort', undefined]);
|
||||
});
|
||||
}, 'Aborting a WritableStream immediately prevents future writes');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = recordingWritableStream();
|
||||
const results = [];
|
||||
|
||||
return delay(0)
|
||||
.then(() => {
|
||||
const writer = ws.getWriter();
|
||||
|
||||
results.push(
|
||||
writer.write(1),
|
||||
promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.write(3), 'write(3) must reject with a TypeError')
|
||||
);
|
||||
|
||||
const abortPromise = writer.abort();
|
||||
|
||||
results.push(
|
||||
promise_rejects(t, new TypeError(), writer.write(4), 'write(4) must reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.write(5), 'write(5) must reject with a TypeError')
|
||||
);
|
||||
|
||||
return abortPromise;
|
||||
}).then(() => {
|
||||
assert_array_equals(ws.events, ['write', 1, 'abort', undefined]);
|
||||
|
||||
return Promise.all(results);
|
||||
});
|
||||
}, 'Aborting a WritableStream prevents further writes after any that are in progress');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({
|
||||
abort() {
|
||||
return 'Hello';
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return writer.abort('a').then(value => {
|
||||
assert_equals(value, undefined, 'fulfillment value must be undefined');
|
||||
});
|
||||
}, 'Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
abort() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.abort(undefined),
|
||||
'rejection reason of abortPromise must be the error thrown by abort');
|
||||
}, 'WritableStream if sink\'s abort throws, the promise returned by writer.abort() rejects');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
abort() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
return promise_rejects(t, error1, ws.abort(undefined),
|
||||
'rejection reason of abortPromise must be the error thrown by abort');
|
||||
}, 'WritableStream if sink\'s abort throws, the promise returned by ws.abort() rejects');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWritePromise;
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
resolveWritePromise = resolve;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.write().catch(() => {});
|
||||
return flushAsyncEvents().then(() => {
|
||||
const abortPromise = writer.abort(undefined);
|
||||
|
||||
resolveWritePromise();
|
||||
return promise_rejects(t, error1, abortPromise,
|
||||
'rejection reason of abortPromise must be the error thrown by abort');
|
||||
});
|
||||
}, 'WritableStream if sink\'s abort throws, for an abort performed during a write, the promise returned by ' +
|
||||
'ws.abort() rejects');
|
||||
|
||||
test(() => {
|
||||
const ws = recordingWritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.abort(error1);
|
||||
|
||||
assert_array_equals(ws.events, ['abort', error1]);
|
||||
}, 'Aborting a WritableStream passes through the given reason');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.abort(error1);
|
||||
|
||||
const events = [];
|
||||
writer.ready.catch(() => {
|
||||
events.push('ready');
|
||||
});
|
||||
writer.closed.catch(() => {
|
||||
events.push('closed');
|
||||
});
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.write(), 'writing should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.close(), 'closing should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.abort(), 'aborting should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.ready, 'ready should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError')
|
||||
]).then(() => {
|
||||
assert_array_equals(['ready', 'closed'], events, 'ready should reject before closed');
|
||||
});
|
||||
}, 'Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const writePromise = promise_rejects(t, new TypeError(), writer.write('a'),
|
||||
'writing should reject with a TypeError');
|
||||
|
||||
writer.abort(error1);
|
||||
|
||||
return writePromise;
|
||||
}, 'Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
writer.abort(error1);
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),
|
||||
promise_rejects(t, new TypeError(), closePromise, 'close() should reject with a TypeError')
|
||||
]);
|
||||
}, 'Closing but then immediately aborting a WritableStream causes the stream to error');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveClose;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return new Promise(resolve => {
|
||||
resolveClose = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
|
||||
return delay(0).then(() => {
|
||||
const abortPromise = writer.abort(error1);
|
||||
resolveClose();
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),
|
||||
abortPromise,
|
||||
closePromise
|
||||
]);
|
||||
});
|
||||
}, 'Closing a WritableStream and aborting it while it closes causes the stream to error');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.close();
|
||||
|
||||
return delay(0).then(() => writer.abort());
|
||||
}, 'Aborting a WritableStream after it is closed is a no-op');
|
||||
|
||||
promise_test(t => {
|
||||
// Testing that per https://github.com/whatwg/streams/issues/620#issuecomment-263483953 the fallback to close was
|
||||
// removed.
|
||||
|
||||
// Cannot use recordingWritableStream since it always has an abort
|
||||
let closeCalled = false;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
closeCalled = true;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.abort();
|
||||
|
||||
return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError').then(() => {
|
||||
assert_false(closeCalled, 'close must not have been called');
|
||||
});
|
||||
}, 'WritableStream should NOT call underlying sink\'s close if no abort is supplied (historical)');
|
||||
|
||||
promise_test(() => {
|
||||
let thenCalled = false;
|
||||
const ws = new WritableStream({
|
||||
abort() {
|
||||
return {
|
||||
then(onFulfilled) {
|
||||
thenCalled = true;
|
||||
onFulfilled();
|
||||
}
|
||||
};
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.abort().then(() => assert_true(thenCalled, 'then() should be called'));
|
||||
}, 'returning a thenable from abort() should work');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return flushAsyncEvents();
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const writePromise = writer.write('a');
|
||||
writer.abort(error1);
|
||||
let closedResolved = false;
|
||||
return Promise.all([
|
||||
writePromise.then(() => assert_false(closedResolved, '.closed should not resolve before write()')),
|
||||
promise_rejects(t, new TypeError(), writer.closed, '.closed should reject').then(() => {
|
||||
closedResolved = true;
|
||||
})
|
||||
]);
|
||||
});
|
||||
}, '.closed should not resolve before fulfilled write()');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const writePromise = writer.write('a');
|
||||
const abortPromise = writer.abort(error2);
|
||||
let closedResolved = false;
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, writePromise, 'write() should reject')
|
||||
.then(() => assert_false(closedResolved, '.closed should not resolve before write()')),
|
||||
promise_rejects(t, error1, writer.closed, '.closed should reject')
|
||||
.then(() => {
|
||||
closedResolved = true;
|
||||
}),
|
||||
promise_rejects(t, error1, abortPromise, 'abort() should reject')]);
|
||||
});
|
||||
}, '.closed should not resolve before rejected write(); write() error should overwrite abort() error');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return flushAsyncEvents();
|
||||
}
|
||||
}, new CountQueuingStrategy(4));
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const settlementOrder = [];
|
||||
return Promise.all([
|
||||
writer.write('1').then(() => settlementOrder.push(1)),
|
||||
promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')
|
||||
.then(() => settlementOrder.push(2)),
|
||||
promise_rejects(t, new TypeError(), writer.write('3'), 'second queued write should be rejected')
|
||||
.then(() => settlementOrder.push(3)),
|
||||
writer.abort(error1)
|
||||
]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
|
||||
});
|
||||
}, 'writes should be satisfied in order when aborting');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
}, new CountQueuingStrategy(4));
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const settlementOrder = [];
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, writer.write('1'), 'pending write should be rejected')
|
||||
.then(() => settlementOrder.push(1)),
|
||||
promise_rejects(t, error1, writer.write('2'), 'first queued write should be rejected')
|
||||
.then(() => settlementOrder.push(2)),
|
||||
promise_rejects(t, error1, writer.write('3'), 'second queued write should be rejected')
|
||||
.then(() => settlementOrder.push(3)),
|
||||
promise_rejects(t, error1, writer.abort(error1), 'abort should be rejected')
|
||||
]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
|
||||
});
|
||||
}, 'writes should be satisfied in order after rejected write when aborting');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, writer.write('a'), 'writer.write() should reject with error from underlying write()'),
|
||||
promise_rejects(t, error1, writer.close(), 'writer.close() should reject with error from underlying write()'),
|
||||
promise_rejects(t, error1, writer.abort(), 'writer.abort() should reject with error from underlying write()')
|
||||
]);
|
||||
});
|
||||
}, 'close() should use error from underlying write() on abort');
|
||||
|
||||
promise_test(() => {
|
||||
let resolveWrite;
|
||||
let abortCalled = false;
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
abortCalled = true;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
writer.write('a');
|
||||
const abortPromise = writer.abort();
|
||||
return flushAsyncEvents().then(() => {
|
||||
assert_false(abortCalled, 'abort should not be called while write is pending');
|
||||
resolveWrite();
|
||||
return abortPromise.then(() => assert_true(abortCalled, 'abort should be called'));
|
||||
});
|
||||
});
|
||||
}, 'underlying abort() should not be called until underlying write() completes');
|
||||
|
||||
promise_test(() => {
|
||||
let resolveClose;
|
||||
let abortCalled = false;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return new Promise(resolve => {
|
||||
resolveClose = resolve;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
abortCalled = true;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
writer.close();
|
||||
const abortPromise = writer.abort();
|
||||
return flushAsyncEvents().then(() => {
|
||||
assert_false(abortCalled, 'underlying abort should not be called while close is pending');
|
||||
resolveClose();
|
||||
return abortPromise.then(() => {
|
||||
assert_false(abortCalled, 'underlying abort should not be called after close completes');
|
||||
});
|
||||
});
|
||||
});
|
||||
}, 'underlying abort() should not be called if underlying close() has started');
|
||||
|
||||
promise_test(t => {
|
||||
let rejectClose;
|
||||
let abortCalled = false;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return new Promise((resolve, reject) => {
|
||||
rejectClose = reject;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
abortCalled = true;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const closePromise = writer.close();
|
||||
const abortPromise = writer.abort();
|
||||
return flushAsyncEvents().then(() => {
|
||||
assert_false(abortCalled, 'underlying abort should not be called while close is pending');
|
||||
rejectClose(error1);
|
||||
return promise_rejects(t, error1, abortPromise, 'abort should reject with the same reason').then(() => {
|
||||
return promise_rejects(t, error1, closePromise, 'close should reject with the same reason');
|
||||
}).then(() => {
|
||||
assert_false(abortCalled, 'underlying abort should not be called after close completes');
|
||||
});
|
||||
});
|
||||
});
|
||||
}, 'if underlying close() has started and then rejects, the abort() and close() promises should reject with the ' +
|
||||
'underlying close rejection reason');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWrite;
|
||||
let abortCalled = false;
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
abortCalled = true;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
writer.write('a');
|
||||
const closePromise = writer.close();
|
||||
const abortPromise = writer.abort();
|
||||
return flushAsyncEvents().then(() => {
|
||||
assert_false(abortCalled, 'abort should not be called while write is pending');
|
||||
resolveWrite();
|
||||
return abortPromise.then(() => {
|
||||
assert_true(abortCalled, 'abort should be called after write completes');
|
||||
return promise_rejects(t, new TypeError(), closePromise, 'promise returned by close() should be rejected');
|
||||
});
|
||||
});
|
||||
});
|
||||
}, 'underlying abort() should be called while closing if underlying close() has not started yet');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const closePromise = writer.close();
|
||||
const abortPromise = writer.abort();
|
||||
let closeResolved = false;
|
||||
Promise.all([
|
||||
closePromise.then(() => { closeResolved = true; }),
|
||||
abortPromise.then(() => { assert_true(closeResolved, 'close() promise should resolve before abort() promise'); })
|
||||
]);
|
||||
});
|
||||
}, 'writer close() promise should resolve before abort() promise');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write(chunk, controller) {
|
||||
controller.error(error1);
|
||||
return new Promise(() => {});
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
writer.write('a');
|
||||
return promise_rejects(t, error1, writer.ready, 'writer.ready should reject');
|
||||
});
|
||||
}, 'writer.ready should reject on controller error without waiting for underlying write');
|
||||
|
||||
promise_test(t => {
|
||||
let rejectWrite;
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise((resolve, reject) => {
|
||||
rejectWrite = reject;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
let writePromise;
|
||||
let abortPromise;
|
||||
|
||||
const events = [];
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.closed.catch(() => {
|
||||
events.push('closed');
|
||||
});
|
||||
|
||||
// Wait for ws to start
|
||||
return flushAsyncEvents().then(() => {
|
||||
writePromise = writer.write('a');
|
||||
writePromise.catch(() => {
|
||||
events.push('writePromise');
|
||||
});
|
||||
|
||||
abortPromise = writer.abort(error1);
|
||||
abortPromise.catch(() => {
|
||||
events.push('abortPromise');
|
||||
});
|
||||
|
||||
const writePromise2 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),
|
||||
promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be rejected yet');
|
||||
|
||||
rejectWrite(error2);
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, error2, writePromise,
|
||||
'writePromise must reject with the error returned from the sink\'s write method'),
|
||||
promise_rejects(t, error2, abortPromise,
|
||||
'abortPromise must reject with the error returned from the sink\'s write method'),
|
||||
promise_rejects(t, error2, writer.closed,
|
||||
'writer.closed must reject with the error returned from the sink\'s write method'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],
|
||||
'writePromise, abortPromise and writer.closed must reject');
|
||||
|
||||
const writePromise3 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writePromise3,
|
||||
'writePromise3 must reject with an error indicating the stream has already been errored'),
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be still rejected with the error indicating abort')
|
||||
]);
|
||||
}).then(() => {
|
||||
writer.releaseLock();
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be rejected with an error indicating release'),
|
||||
promise_rejects(t, new TypeError(), writer.closed,
|
||||
'writer.closed must be rejected with an error indicating release')
|
||||
]);
|
||||
});
|
||||
}, 'writer.abort() while there is a pending write, and then finish the write with rejection');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWrite;
|
||||
let controller;
|
||||
const ws = new WritableStream({
|
||||
write(chunk, c) {
|
||||
controller = c;
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
let writePromise;
|
||||
let abortPromise;
|
||||
|
||||
const events = [];
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.closed.catch(() => {
|
||||
events.push('closed');
|
||||
});
|
||||
|
||||
// Wait for ws to start
|
||||
return flushAsyncEvents().then(() => {
|
||||
writePromise = writer.write('a');
|
||||
writePromise.then(() => {
|
||||
events.push('writePromise');
|
||||
});
|
||||
|
||||
abortPromise = writer.abort(error1);
|
||||
abortPromise.catch(() => {
|
||||
events.push('abortPromise');
|
||||
});
|
||||
|
||||
const writePromise2 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),
|
||||
promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet');
|
||||
|
||||
controller.error(error2);
|
||||
|
||||
const writePromise3 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writePromise3,
|
||||
'writePromise3 must reject with an error indicating the stream has already been errored'),
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be still rejected with the error indicating abort'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(
|
||||
events, [],
|
||||
'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet even after '
|
||||
+ 'controller.error() call');
|
||||
|
||||
resolveWrite();
|
||||
|
||||
return Promise.all([
|
||||
writePromise,
|
||||
promise_rejects(t, error2, abortPromise,
|
||||
'abortPromise must reject with the error passed to the controller\'s error method'),
|
||||
promise_rejects(t, error2, writer.closed,
|
||||
'writer.closed must reject with the error passed to the controller\'s error method'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],
|
||||
'writePromise, abortPromise and writer.closed must reject');
|
||||
|
||||
const writePromise4 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
writePromise,
|
||||
promise_rejects(t, new TypeError(), writePromise4,
|
||||
'writePromise4 must reject with an error indicating that the stream has already been errored'),
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be still rejected with the error indicating abort')
|
||||
]);
|
||||
}).then(() => {
|
||||
writer.releaseLock();
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be rejected with an error indicating release'),
|
||||
promise_rejects(t, new TypeError(), writer.closed,
|
||||
'writer.closed must be rejected with an error indicating release')
|
||||
]);
|
||||
});
|
||||
}, 'writer.abort(), controller.error() while there is a pending write, and then finish the write');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWrite;
|
||||
let controller;
|
||||
const ws = new WritableStream({
|
||||
write(chunk, c) {
|
||||
controller = c;
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
let writePromise;
|
||||
let abortPromise;
|
||||
|
||||
const events = [];
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.closed.catch(() => {
|
||||
events.push('closed');
|
||||
});
|
||||
|
||||
// Wait for ws to start
|
||||
return flushAsyncEvents().then(() => {
|
||||
writePromise = writer.write('a');
|
||||
writePromise.then(() => {
|
||||
events.push('writePromise');
|
||||
});
|
||||
|
||||
controller.error(error2);
|
||||
|
||||
const writePromise2 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writePromise2,
|
||||
'writePromise2 must reject with an error indicating the stream has already been errored'),
|
||||
promise_rejects(t, error2, writer.ready,
|
||||
'writer.ready must reject with the error passed to the controller\'s error method'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, [], 'writePromise and writer.closed must not be fulfilled/rejected yet');
|
||||
|
||||
abortPromise = writer.abort(error1);
|
||||
abortPromise.catch(() => {
|
||||
events.push('abortPromise');
|
||||
});
|
||||
|
||||
const writePromise3 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, error2, abortPromise,
|
||||
'abortPromise must reject with the error passed to the controller\'s error method'),
|
||||
promise_rejects(t, new TypeError(), writePromise3,
|
||||
'writePromise3 must reject with an error indicating the stream has already been errored'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(
|
||||
events, ['abortPromise'],
|
||||
'writePromise and writer.closed must not be fulfilled/rejected yet even after writer.abort()');
|
||||
|
||||
resolveWrite();
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, error2, writer.closed,
|
||||
'writer.closed must reject with the error passed to the controller\'s error method'),
|
||||
flushAsyncEvents()
|
||||
]);
|
||||
}).then(() => {
|
||||
assert_array_equals(events, ['abortPromise', 'writePromise', 'closed'],
|
||||
'writePromise, abortPromise and writer.closed must fulfill/reject');
|
||||
|
||||
const writePromise4 = writer.write('a');
|
||||
|
||||
return Promise.all([
|
||||
writePromise,
|
||||
promise_rejects(t, new TypeError(), writePromise4,
|
||||
'writePromise4 must reject with an error indicating that the stream has already been errored'),
|
||||
promise_rejects(t, error2, writer.ready,
|
||||
'writer.ready must be still rejected with the error passed to the controller\'s error method')
|
||||
]);
|
||||
}).then(() => {
|
||||
writer.releaseLock();
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, new TypeError(), writer.ready,
|
||||
'writer.ready must be rejected with an error indicating release'),
|
||||
promise_rejects(t, new TypeError(), writer.closed,
|
||||
'writer.closed must be rejected with an error indicating release')
|
||||
]);
|
||||
});
|
||||
}, 'controller.error(), writer.abort() while there is a pending write, and then finish the write');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWrite;
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const writePromise = writer.write('a');
|
||||
const closed = writer.closed;
|
||||
const abortPromise = writer.abort();
|
||||
writer.releaseLock();
|
||||
resolveWrite();
|
||||
return Promise.all([
|
||||
writePromise,
|
||||
abortPromise,
|
||||
promise_rejects(t, new TypeError(), closed, 'closed should reject')]);
|
||||
});
|
||||
}, 'releaseLock() while aborting should reject the original closed promise');
|
||||
|
||||
promise_test(t => {
|
||||
let resolveWrite;
|
||||
let resolveAbort;
|
||||
let resolveAbortStarted;
|
||||
const abortStarted = new Promise(resolve => {
|
||||
resolveAbortStarted = resolve;
|
||||
});
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
resolveWrite = resolve;
|
||||
});
|
||||
},
|
||||
abort() {
|
||||
resolveAbortStarted();
|
||||
return new Promise(resolve => {
|
||||
resolveAbort = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const writePromise = writer.write('a');
|
||||
const closed = writer.closed;
|
||||
const abortPromise = writer.abort();
|
||||
resolveWrite();
|
||||
return abortStarted.then(() => {
|
||||
writer.releaseLock();
|
||||
assert_not_equals(writer.closed, closed, 'closed promise should have changed');
|
||||
resolveAbort();
|
||||
return Promise.all([
|
||||
writePromise,
|
||||
abortPromise,
|
||||
promise_rejects(t, new TypeError(), closed, 'original closed should reject'),
|
||||
promise_rejects(t, new TypeError(), writer.closed, 'new closed should reject')]);
|
||||
});
|
||||
});
|
||||
}, 'releaseLock() during delayed async abort() should create a new rejected closed promise');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>aborting.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('aborting.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>aborting.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('aborting.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-strategies.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('bad-strategies.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-strategies.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="bad-strategies.js"></script>
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
const error1 = new Error('a unique string');
|
||||
error1.name = 'error1';
|
||||
|
||||
test(() => {
|
||||
assert_throws(error1, () => {
|
||||
new WritableStream({}, {
|
||||
get size() {
|
||||
throw error1;
|
||||
},
|
||||
highWaterMark: 5
|
||||
});
|
||||
}, 'construction should re-throw the error');
|
||||
}, 'Writable stream: throwing strategy.size getter');
|
||||
|
||||
test(() => {
|
||||
assert_throws(new TypeError(), () => {
|
||||
new WritableStream({}, { size: 'a string' });
|
||||
});
|
||||
}, 'reject any non-function value for strategy.size');
|
||||
|
||||
test(() => {
|
||||
assert_throws(error1, () => {
|
||||
new WritableStream({}, {
|
||||
size() {
|
||||
return 1;
|
||||
},
|
||||
get highWaterMark() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
}, 'construction should re-throw the error');
|
||||
}, 'Writable stream: throwing strategy.highWaterMark getter');
|
||||
|
||||
test(() => {
|
||||
|
||||
for (const highWaterMark of [-1, -Infinity, NaN, 'foo', {}]) {
|
||||
assert_throws(new RangeError(), () => {
|
||||
new WritableStream({}, {
|
||||
size() {
|
||||
return 1;
|
||||
},
|
||||
highWaterMark
|
||||
});
|
||||
}, `construction should throw a RangeError for ${highWaterMark}`);
|
||||
}
|
||||
}, 'Writable stream: invalid strategy.highWaterMark');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({}, {
|
||||
size() {
|
||||
throw error1;
|
||||
},
|
||||
highWaterMark: 5
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const p1 = promise_rejects(t, error1, writer.write('a'), 'write should reject with the thrown error');
|
||||
|
||||
const p2 = promise_rejects(t, error1, writer.closed, 'closed should reject with the thrown error');
|
||||
|
||||
return Promise.all([p1, p2]);
|
||||
}, 'Writable stream: throwing strategy.size method');
|
||||
|
||||
promise_test(() => {
|
||||
const sizes = [NaN, -Infinity, Infinity, -1];
|
||||
return Promise.all(sizes.map(size => {
|
||||
const ws = new WritableStream({}, {
|
||||
size() {
|
||||
return size;
|
||||
},
|
||||
highWaterMark: 5
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return writer.write('a').then(() => assert_unreached('write must reject'), writeE => {
|
||||
assert_equals(writeE.name, 'RangeError', `write must reject with a RangeError for ${size}`);
|
||||
|
||||
return writer.closed.then(() => assert_unreached('write must reject'), closedE => {
|
||||
assert_equals(closedE, writeE, `closed should reject with the same error as write`);
|
||||
});
|
||||
});
|
||||
}));
|
||||
}, 'Writable stream: invalid strategy.size return value');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-strategies.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('bad-strategies.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-strategies.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('bad-strategies.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-underlying-sinks.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('bad-underlying-sinks.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-underlying-sinks.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script src="../resources/test-utils.js"></script>
|
||||
<script src="../resources/recording-streams.js"></script>
|
||||
|
||||
<script src="bad-underlying-sinks.js"></script>
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
self.importScripts('../resources/test-utils.js');
|
||||
self.importScripts('../resources/recording-streams.js');
|
||||
}
|
||||
|
||||
const error1 = new Error('error1');
|
||||
error1.name = 'error1';
|
||||
|
||||
test(() => {
|
||||
assert_throws(error1, () => {
|
||||
new WritableStream({
|
||||
get start() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
}, 'constructor should throw same error as throwing start getter');
|
||||
|
||||
assert_throws(error1, () => {
|
||||
new WritableStream({
|
||||
start() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
}, 'constructor should throw same error as throwing start method');
|
||||
|
||||
assert_throws(new TypeError(), () => {
|
||||
new WritableStream({
|
||||
start: 'not a function or undefined'
|
||||
});
|
||||
}, 'constructor should throw TypeError when passed a non-function start property');
|
||||
|
||||
assert_throws(new TypeError(), () => {
|
||||
new WritableStream({
|
||||
start: { apply() {} }
|
||||
});
|
||||
}, 'constructor should throw TypeError when passed a non-function start property with an .apply method');
|
||||
}, 'start: errors in start cause WritableStream constructor to throw');
|
||||
|
||||
promise_test(t => {
|
||||
|
||||
const ws = recordingWritableStream({
|
||||
close() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.close(), 'close() promise must reject with the thrown error')
|
||||
.then(() => promise_rejects(t, error1, writer.ready, 'ready promise must reject with the thrown error'))
|
||||
.then(() => promise_rejects(t, error1, writer.closed, 'closed promise must reject with the thrown error'))
|
||||
.then(() => {
|
||||
assert_array_equals(ws.events, ['close']);
|
||||
});
|
||||
|
||||
}, 'close: throwing method should cause writer close() and ready to reject');
|
||||
|
||||
promise_test(t => {
|
||||
|
||||
const ws = recordingWritableStream({
|
||||
close() {
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.close(), 'close() promise must reject with the same error')
|
||||
.then(() => promise_rejects(t, error1, writer.ready, 'ready promise must reject with the same error'))
|
||||
.then(() => assert_array_equals(ws.events, ['close']));
|
||||
|
||||
}, 'close: returning a rejected promise should cause writer close() and ready to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
get close() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.close(), 'close should reject with the thrown error');
|
||||
}, 'close: throwing getter should cause writer close() to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
get write() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.write('a'), 'write should reject with the thrown error')
|
||||
.then(() => promise_rejects(t, error1, writer.closed, 'closed should reject with the thrown error'));
|
||||
}, 'write: throwing getter should cause write() and closed to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.write('a'), 'write should reject with the thrown error')
|
||||
.then(() => promise_rejects(t, error1, writer.closed, 'closed should reject with the thrown error'));
|
||||
}, 'write: throwing method should cause write() and closed to reject');
|
||||
|
||||
promise_test(t => {
|
||||
|
||||
const startPromise = Promise.resolve();
|
||||
let rejectSinkWritePromise;
|
||||
const ws = recordingWritableStream({
|
||||
start() {
|
||||
return startPromise;
|
||||
},
|
||||
write() {
|
||||
return new Promise((r, reject) => {
|
||||
rejectSinkWritePromise = reject;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
return startPromise.then(() => {
|
||||
const writer = ws.getWriter();
|
||||
const writePromise = writer.write('a');
|
||||
rejectSinkWritePromise(error1);
|
||||
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, writePromise, 'writer write must reject with the same error'),
|
||||
promise_rejects(t, error1, writer.ready, 'ready promise must reject with the same error')
|
||||
]);
|
||||
})
|
||||
.then(() => {
|
||||
assert_array_equals(ws.events, ['write', 'a']);
|
||||
});
|
||||
|
||||
}, 'write: returning a promise that becomes rejected after the writer write() should cause writer write() and ready ' +
|
||||
'to reject');
|
||||
|
||||
promise_test(t => {
|
||||
|
||||
const ws = recordingWritableStream({
|
||||
write() {
|
||||
if (ws.events.length === 2) {
|
||||
return delay(0);
|
||||
}
|
||||
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
// Do not wait for this; we want to test the ready promise when the stream is "full" (desiredSize = 0), but if we wait
|
||||
// then the stream will transition back to "empty" (desiredSize = 1)
|
||||
writer.write('a');
|
||||
const readyPromise = writer.ready;
|
||||
|
||||
return promise_rejects(t, error1, writer.write('b'), 'second write must reject with the same error').then(() => {
|
||||
assert_equals(writer.ready, readyPromise,
|
||||
'the ready promise must not change, since the queue was full after the first write, so the pending one simply ' +
|
||||
'transitioned');
|
||||
return promise_rejects(t, error1, writer.ready, 'ready promise must reject with the same error');
|
||||
})
|
||||
.then(() => assert_array_equals(ws.events, ['write', 'a', 'write', 'b']));
|
||||
|
||||
}, 'write: returning a rejected promise (second write) should cause writer write() and ready to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
abort: { apply() {} }
|
||||
});
|
||||
|
||||
return promise_rejects(t, new TypeError(), ws.abort(error1), 'abort should reject with TypeError').then(() => {
|
||||
const writer = ws.getWriter();
|
||||
return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError');
|
||||
});
|
||||
}, 'abort: non-function abort method with .apply');
|
||||
|
||||
promise_test(t => {
|
||||
const abortReason = new Error('different string');
|
||||
const ws = new WritableStream({
|
||||
get abort() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.abort(abortReason), 'abort should reject with the thrown error')
|
||||
.then(() => promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'));
|
||||
}, 'abort: throwing getter should cause abort() and closed to reject');
|
||||
|
||||
promise_test(t => {
|
||||
const abortReason = new Error('different string');
|
||||
const ws = new WritableStream({
|
||||
abort() {
|
||||
throw error1;
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return promise_rejects(t, error1, writer.abort(abortReason), 'abort should reject with the thrown error')
|
||||
.then(() => promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'));
|
||||
}, 'abort: throwing method should cause abort() and closed to reject');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-underlying-sinks.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('bad-underlying-sinks.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>bad-underlying-sinks.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('bad-underlying-sinks.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>brand-checks.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('brand-checks.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>brand-checks.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="brand-checks.js"></script>
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
function fakeWritableStreamDefaultWriter() {
|
||||
return {
|
||||
get closed() { return Promise.resolve(); },
|
||||
get desiredSize() { return 1; },
|
||||
get ready() { return Promise.resolve(); },
|
||||
abort() { return Promise.resolve(); },
|
||||
close() { return Promise.resolve(); },
|
||||
write() { return Promise.resolve(); }
|
||||
};
|
||||
}
|
||||
|
||||
function realReadableStreamDefaultWriter() {
|
||||
const rs = new ReadableStream();
|
||||
return rs.getReader();
|
||||
}
|
||||
|
||||
function getterRejects(t, obj, getterName, target) {
|
||||
const getter = Object.getOwnPropertyDescriptor(obj, getterName).get;
|
||||
|
||||
return promise_rejects(t, new TypeError(), getter.call(target),
|
||||
getterName + ' should reject with a TypeError');
|
||||
}
|
||||
|
||||
function methodRejects(t, obj, methodName, target) {
|
||||
const method = obj[methodName];
|
||||
|
||||
return promise_rejects(t, new TypeError(), method.call(target),
|
||||
methodName + ' should reject with a TypeError');
|
||||
}
|
||||
|
||||
function getterThrows(obj, getterName, target) {
|
||||
const getter = Object.getOwnPropertyDescriptor(obj, getterName).get;
|
||||
|
||||
assert_throws(new TypeError(), () => getter.call(target), getterName + ' should throw a TypeError');
|
||||
}
|
||||
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
const WritableStreamDefaultWriter = writer.constructor;
|
||||
const WriterProto = WritableStreamDefaultWriter.prototype;
|
||||
|
||||
test(() => {
|
||||
getterThrows(WriterProto, 'desiredSize', fakeWritableStreamDefaultWriter());
|
||||
getterThrows(WriterProto, 'desiredSize', realReadableStreamDefaultWriter());
|
||||
}, 'WritableStreamDefaultWriter.prototype.desiredSize enforces a brand check');
|
||||
|
||||
promise_test(t => {
|
||||
return Promise.all([getterRejects(t, WriterProto, 'closed', fakeWritableStreamDefaultWriter()),
|
||||
getterRejects(t, WriterProto, 'closed', realReadableStreamDefaultWriter())]);
|
||||
}, 'WritableStreamDefaultWriter.prototype.closed enforces a brand check');
|
||||
|
||||
promise_test(t => {
|
||||
return Promise.all([getterRejects(t, WriterProto, 'ready', fakeWritableStreamDefaultWriter()),
|
||||
getterRejects(t, WriterProto, 'ready', realReadableStreamDefaultWriter())]);
|
||||
}, 'WritableStreamDefaultWriter.prototype.ready enforces a brand check');
|
||||
|
||||
test(t => {
|
||||
return Promise.all([methodRejects(t, WriterProto, 'abort', fakeWritableStreamDefaultWriter()),
|
||||
methodRejects(t, WriterProto, 'abort', realReadableStreamDefaultWriter())]);
|
||||
|
||||
}, 'WritableStreamDefaultWriter.prototype.abort enforces a brand check');
|
||||
|
||||
promise_test(t => {
|
||||
return Promise.all([methodRejects(t, WriterProto, 'write', fakeWritableStreamDefaultWriter()),
|
||||
methodRejects(t, WriterProto, 'write', realReadableStreamDefaultWriter())]);
|
||||
}, 'WritableStreamDefaultWriter.prototype.write enforces a brand check');
|
||||
|
||||
promise_test(t => {
|
||||
return Promise.all([methodRejects(t, WriterProto, 'close', fakeWritableStreamDefaultWriter()),
|
||||
methodRejects(t, WriterProto, 'close', realReadableStreamDefaultWriter())]);
|
||||
}, 'WritableStreamDefaultWriter.prototype.close enforces a brand check');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>brand-checks.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('brand-checks.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>brand-checks.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('brand-checks.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>byte-length-queuing-strategy.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('byte-length-queuing-strategy.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>byte-length-queuing-strategy.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="byte-length-queuing-strategy.js"></script>
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
promise_test(() => {
|
||||
let isDone = false;
|
||||
const ws = new WritableStream(
|
||||
{
|
||||
write() {
|
||||
return new Promise(resolve => {
|
||||
setTimeout(() => {
|
||||
isDone = true;
|
||||
resolve();
|
||||
}, 200);
|
||||
});
|
||||
},
|
||||
|
||||
close() {
|
||||
assert_true(isDone, 'close is only called once the promise has been resolved');
|
||||
}
|
||||
},
|
||||
new ByteLengthQueuingStrategy({ highWaterMark: 1024 * 16 })
|
||||
);
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.write({ byteLength: 1024 });
|
||||
|
||||
return writer.close();
|
||||
}, 'Closing a writable stream with in-flight writes below the high water mark delays the close call properly');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>byte-length-queuing-strategy.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('byte-length-queuing-strategy.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>byte-length-queuing-strategy.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('byte-length-queuing-strategy.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>close.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('close.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>close.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script src="../resources/test-utils.js"></script>
|
||||
<script src="../resources/recording-streams.js"></script>
|
||||
|
||||
<script src="close.js"></script>
|
||||
347
tests/wpt/web-platform-tests/streams/writable-streams/close.js
Normal file
347
tests/wpt/web-platform-tests/streams/writable-streams/close.js
Normal file
|
|
@ -0,0 +1,347 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
self.importScripts('../resources/test-utils.js');
|
||||
self.importScripts('../resources/recording-streams.js');
|
||||
}
|
||||
|
||||
const error1 = new Error('error1');
|
||||
error1.name = 'error1';
|
||||
|
||||
const error2 = new Error('error2');
|
||||
error2.name = 'error2';
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return 'Hello';
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
return closePromise.then(value => assert_equals(value, undefined, 'fulfillment value must be undefined'));
|
||||
}, 'fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined ' +
|
||||
'value');
|
||||
|
||||
promise_test(t => {
|
||||
const passedError = new Error('error me');
|
||||
let controller;
|
||||
const ws = new WritableStream({
|
||||
close(c) {
|
||||
controller = c;
|
||||
return delay(50);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return Promise.all([
|
||||
writer.close(),
|
||||
delay(10).then(() => controller.error(passedError)),
|
||||
promise_rejects(t, passedError, writer.closed,
|
||||
'closed promise should be rejected with the passed error'),
|
||||
delay(70).then(() => promise_rejects(t, passedError, writer.closed, 'closed should stay rejected'))
|
||||
]);
|
||||
}, 'when sink calls error asynchronously while closing, the stream should become errored');
|
||||
|
||||
promise_test(t => {
|
||||
const passedError = new Error('error me');
|
||||
const ws = new WritableStream({
|
||||
close(controller) {
|
||||
controller.error(passedError);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return writer.close().then(() => promise_rejects(t, passedError, writer.closed, 'closed should stay rejected'));
|
||||
}, 'when sink calls error synchronously while closing, the stream should become errored');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write(chunk, controller) {
|
||||
controller.error(error1);
|
||||
return new Promise(() => {});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.write('a');
|
||||
|
||||
return delay(0).then(() => {
|
||||
writer.releaseLock();
|
||||
});
|
||||
}, 'releaseLock on a stream with a pending write in which the stream has been errored');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
close(controller) {
|
||||
controller.error(error1);
|
||||
return new Promise(() => {});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.close();
|
||||
|
||||
return delay(0).then(() => {
|
||||
writer.releaseLock();
|
||||
});
|
||||
}, 'releaseLock on a stream with a pending close in which the stream has been errored');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = recordingWritableStream();
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return writer.ready.then(() => {
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
|
||||
|
||||
writer.close();
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be still 1');
|
||||
|
||||
return writer.ready.then(v => {
|
||||
assert_equals(v, undefined, 'ready promise should be fulfilled with undefined');
|
||||
assert_array_equals(ws.events, ['close'], 'write and abort should not be called');
|
||||
});
|
||||
});
|
||||
}, 'when close is called on a WritableStream in writable state, ready should return a fulfilled promise');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = recordingWritableStream({
|
||||
write() {
|
||||
return new Promise(() => {});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return writer.ready.then(() => {
|
||||
writer.write('a');
|
||||
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0');
|
||||
|
||||
let calledClose = false;
|
||||
return Promise.all([
|
||||
writer.ready.then(v => {
|
||||
assert_equals(v, undefined, 'ready promise should be fulfilled with undefined');
|
||||
assert_true(calledClose, 'ready should not be fulfilled before writer.close() is called');
|
||||
assert_array_equals(ws.events, ['write', 'a'], 'sink abort() should not be called');
|
||||
}),
|
||||
flushAsyncEvents().then(() => {
|
||||
writer.close();
|
||||
calledClose = true;
|
||||
})
|
||||
]);
|
||||
});
|
||||
}, 'when close is called on a WritableStream in waiting state, ready promise should be fulfilled');
|
||||
|
||||
promise_test(() => {
|
||||
let asyncCloseFinished = false;
|
||||
const ws = recordingWritableStream({
|
||||
close() {
|
||||
return flushAsyncEvents().then(() => {
|
||||
asyncCloseFinished = true;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
writer.write('a');
|
||||
|
||||
writer.close();
|
||||
|
||||
return writer.ready.then(v => {
|
||||
assert_false(asyncCloseFinished, 'ready promise should be fulfilled before async close completes');
|
||||
assert_equals(v, undefined, 'ready promise should be fulfilled with undefined');
|
||||
assert_array_equals(ws.events, ['write', 'a', 'close'], 'sink abort() should not be called');
|
||||
});
|
||||
});
|
||||
}, 'when close is called on a WritableStream in waiting state, ready should be fulfilled immediately even if close ' +
|
||||
'takes a long time');
|
||||
|
||||
promise_test(t => {
|
||||
const rejection = { name: 'letter' };
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return {
|
||||
then(onFulfilled, onRejected) { onRejected(rejection); }
|
||||
};
|
||||
}
|
||||
});
|
||||
return promise_rejects(t, rejection, ws.getWriter().close(), 'close() should return a rejection');
|
||||
}, 'returning a thenable from close() should work');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream();
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const closePromise = writer.close();
|
||||
const closedPromise = writer.closed;
|
||||
writer.releaseLock();
|
||||
return Promise.all([
|
||||
closePromise,
|
||||
promise_rejects(t, new TypeError(), closedPromise, '.closed promise should be rejected')
|
||||
]);
|
||||
});
|
||||
}, 'releaseLock() should not change the result of sync close()');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return flushAsyncEvents();
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
return writer.ready.then(() => {
|
||||
const closePromise = writer.close();
|
||||
const closedPromise = writer.closed;
|
||||
writer.releaseLock();
|
||||
return Promise.all([
|
||||
closePromise,
|
||||
promise_rejects(t, new TypeError(), closedPromise, '.closed promise should be rejected')
|
||||
]);
|
||||
});
|
||||
}, 'releaseLock() should not change the result of async close()');
|
||||
|
||||
promise_test(() => {
|
||||
let resolveClose;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
const promise = new Promise(resolve => {
|
||||
resolveClose = resolve;
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
const closePromise = writer.close();
|
||||
writer.releaseLock();
|
||||
return delay(0).then(() => {
|
||||
resolveClose();
|
||||
return closePromise.then(() => {
|
||||
assert_equals(ws.getWriter().desiredSize, 0, 'desiredSize should be 0');
|
||||
});
|
||||
});
|
||||
}, 'close() should set state to CLOSED even if writer has detached');
|
||||
|
||||
promise_test(() => {
|
||||
let resolveClose;
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
const promise = new Promise(resolve => {
|
||||
resolveClose = resolve;
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
});
|
||||
const writer = ws.getWriter();
|
||||
writer.close();
|
||||
writer.releaseLock();
|
||||
return delay(0).then(() => {
|
||||
const abortingWriter = ws.getWriter();
|
||||
const abortPromise = abortingWriter.abort();
|
||||
abortingWriter.releaseLock();
|
||||
resolveClose();
|
||||
return abortPromise;
|
||||
});
|
||||
}, 'the promise returned by async abort during close should resolve');
|
||||
|
||||
// Though the order in which the promises are fulfilled or rejected is arbitrary, we're checking it for
|
||||
// interoperability. We can change the order as long as we file bugs on all implementers to update to the latest tests
|
||||
// to keep them interoperable.
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
|
||||
const events = [];
|
||||
return Promise.all([
|
||||
closePromise.then(() => {
|
||||
events.push('closePromise');
|
||||
}),
|
||||
writer.closed.then(() => {
|
||||
events.push('closed');
|
||||
})
|
||||
]).then(() => {
|
||||
assert_array_equals(events, ['closePromise', 'closed'],
|
||||
'promises must fulfill/reject in the expected order');
|
||||
});
|
||||
}, 'promises must fulfill/reject in the expected order on closure');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
// Wait until the WritableStream starts so that the close() call gets processed. Otherwise, abort() will be
|
||||
// processed without waiting for completion of the close().
|
||||
return delay(0).then(() => {
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
const abortPromise = writer.abort(error1);
|
||||
|
||||
const events = [];
|
||||
return Promise.all([
|
||||
closePromise.then(() => {
|
||||
events.push('closePromise');
|
||||
}),
|
||||
abortPromise.then(() => {
|
||||
events.push('abortPromise');
|
||||
}),
|
||||
promise_rejects(t, new TypeError(), writer.closed, 'writer.closed must reject with an error indicating abort')
|
||||
.then(() => {
|
||||
events.push('closed');
|
||||
})
|
||||
]).then(() => {
|
||||
assert_array_equals(events, ['closePromise', 'abortPromise', 'closed'],
|
||||
'promises must fulfill/reject in the expected order');
|
||||
});
|
||||
});
|
||||
}, 'promises must fulfill/reject in the expected order on aborted closure');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
close() {
|
||||
return Promise.reject(error1);
|
||||
}
|
||||
});
|
||||
|
||||
// Wait until the WritableStream starts so that the close() call gets processed.
|
||||
return delay(0).then(() => {
|
||||
const writer = ws.getWriter();
|
||||
|
||||
const closePromise = writer.close();
|
||||
const abortPromise = writer.abort(error2);
|
||||
|
||||
const events = [];
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, closePromise,
|
||||
'closePromise must reject with the error returned from the sink\'s close method')
|
||||
.then(() => {
|
||||
events.push('closePromise');
|
||||
}),
|
||||
promise_rejects(t, error1, abortPromise,
|
||||
'abortPromise must reject with the error returned from the sink\'s close method')
|
||||
.then(() => {
|
||||
events.push('abortPromise');
|
||||
}),
|
||||
promise_rejects(t, error1, writer.closed,
|
||||
'writer.closed must reject with the error returned from the sink\'s close method')
|
||||
.then(() => {
|
||||
events.push('closed');
|
||||
})
|
||||
]).then(() => {
|
||||
assert_array_equals(events, ['closePromise', 'abortPromise', 'closed'],
|
||||
'promises must fulfill/reject in the expected order');
|
||||
});
|
||||
});
|
||||
}, 'promises must fulfill/reject in the expected order on aborted and errored closure');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>close.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('close.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>close.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('close.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>constructor.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('constructor.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>constructor.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="constructor.js"></script>
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
const error1 = new Error('error1');
|
||||
error1.name = 'error1';
|
||||
|
||||
promise_test(() => {
|
||||
let controller;
|
||||
const ws = new WritableStream({
|
||||
start(c) {
|
||||
controller = c;
|
||||
}
|
||||
});
|
||||
|
||||
// Now error the stream after its construction.
|
||||
controller.error(error1);
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(writer.desiredSize, null, 'desiredSize should be null');
|
||||
return writer.closed.catch(r => {
|
||||
assert_equals(r, error1, 'ws should be errored by the passed error');
|
||||
});
|
||||
}, 'controller argument should be passed to start method');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
write(chunk, controller) {
|
||||
controller.error(error1);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return Promise.all([
|
||||
writer.write('a'),
|
||||
promise_rejects(t, error1, writer.closed, 'controller.error() in write() should errored the stream')
|
||||
]);
|
||||
}, 'controller argument should be passed to write method');
|
||||
|
||||
promise_test(t => {
|
||||
const ws = new WritableStream({
|
||||
close(controller) {
|
||||
controller.error(error1);
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
return Promise.all([
|
||||
writer.close(),
|
||||
promise_rejects(t, error1, writer.closed, 'controller.error() in close() should error the stream')
|
||||
]);
|
||||
}, 'controller argument should be passed to close method');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({}, {
|
||||
highWaterMark: 1000,
|
||||
size() { return 1; }
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(writer.desiredSize, 1000, 'desiredSize should be 1000');
|
||||
return writer.ready.then(v => {
|
||||
assert_equals(v, undefined, 'ready promise should fulfill with undefined');
|
||||
});
|
||||
}, 'highWaterMark should be reflected to desiredSize');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({}, {
|
||||
highWaterMark: Infinity,
|
||||
size() { return 0; }
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(writer.desiredSize, Infinity, 'desiredSize should be Infinity');
|
||||
|
||||
return writer.ready;
|
||||
}, 'WritableStream should be writable and ready should fulfill immediately if the strategy does not apply ' +
|
||||
'backpressure');
|
||||
|
||||
test(() => {
|
||||
new WritableStream();
|
||||
}, 'WritableStream should be constructible with no arguments');
|
||||
|
||||
test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(typeof writer.write, 'function', 'writer should have a write method');
|
||||
assert_equals(typeof writer.abort, 'function', 'writer should have an abort method');
|
||||
assert_equals(typeof writer.close, 'function', 'writer should have a close method');
|
||||
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should start at 1');
|
||||
|
||||
assert_not_equals(typeof writer.ready, 'undefined', 'writer should have a ready property');
|
||||
assert_equals(typeof writer.ready.then, 'function', 'ready property should be thenable');
|
||||
assert_not_equals(typeof writer.closed, 'undefined', 'writer should have a closed property');
|
||||
assert_equals(typeof writer.closed.then, 'function', 'closed property should be thenable');
|
||||
}, 'WritableStream instances should have standard methods and properties');
|
||||
|
||||
test(() => {
|
||||
['WritableStreamDefaultWriter', 'WritableStreamDefaultController'].forEach(c =>
|
||||
assert_equals(typeof self[c], 'undefined', `${c} should not be exported`));
|
||||
}, 'private constructors should not be exported');
|
||||
|
||||
test(() => {
|
||||
let WritableStreamDefaultController;
|
||||
new WritableStream({
|
||||
start(c) {
|
||||
WritableStreamDefaultController = c.constructor;
|
||||
}
|
||||
});
|
||||
|
||||
assert_throws(new TypeError(), () => new WritableStreamDefaultController({}),
|
||||
'constructor should throw a TypeError exception');
|
||||
}, 'WritableStreamDefaultController constructor should throw unless passed a WritableStream');
|
||||
|
||||
test(() => {
|
||||
let WritableStreamDefaultController;
|
||||
const stream = new WritableStream({
|
||||
start(c) {
|
||||
WritableStreamDefaultController = c.constructor;
|
||||
}
|
||||
});
|
||||
|
||||
assert_throws(new TypeError(), () => new WritableStreamDefaultController(stream),
|
||||
'constructor should throw a TypeError exception');
|
||||
}, 'WritableStreamDefaultController constructor should throw when passed an initialised WritableStream');
|
||||
|
||||
test(() => {
|
||||
const stream = new WritableStream();
|
||||
const writer = stream.getWriter();
|
||||
const WritableStreamDefaultWriter = writer.constructor;
|
||||
writer.releaseLock();
|
||||
assert_throws(new TypeError(), () => new WritableStreamDefaultWriter({}),
|
||||
'constructor should throw a TypeError exception');
|
||||
}, 'WritableStreamDefaultWriter should throw unless passed a WritableStream');
|
||||
|
||||
test(() => {
|
||||
const stream = new WritableStream();
|
||||
const writer = stream.getWriter();
|
||||
const WritableStreamDefaultWriter = writer.constructor;
|
||||
assert_throws(new TypeError(), () => new WritableStreamDefaultWriter(stream),
|
||||
'constructor should throw a TypeError exception');
|
||||
}, 'WritableStreamDefaultWriter constructor should throw when stream argument is locked');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>constructor.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('constructor.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>constructor.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('constructor.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>count-queuing-strategy.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('count-queuing-strategy.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>count-queuing-strategy.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="count-queuing-strategy.js"></script>
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
test(() => {
|
||||
new WritableStream({}, new CountQueuingStrategy({ highWaterMark: 4 }));
|
||||
}, 'Can construct a writable stream with a valid CountQueuingStrategy');
|
||||
|
||||
promise_test(() => {
|
||||
const dones = Object.create(null);
|
||||
|
||||
const ws = new WritableStream(
|
||||
{
|
||||
write(chunk) {
|
||||
return new Promise(resolve => {
|
||||
dones[chunk] = resolve;
|
||||
});
|
||||
}
|
||||
},
|
||||
new CountQueuingStrategy({ highWaterMark: 0 })
|
||||
);
|
||||
|
||||
const writer = ws.getWriter();
|
||||
let writePromiseB;
|
||||
let writePromiseC;
|
||||
|
||||
return Promise.resolve().then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be initially 0');
|
||||
|
||||
const writePromiseA = writer.write('a');
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after 1st write()');
|
||||
|
||||
writePromiseB = writer.write('b');
|
||||
assert_equals(writer.desiredSize, -2, 'desiredSize should be -2 after 2nd write()');
|
||||
|
||||
dones.a();
|
||||
return writePromiseA;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after completing 1st write()');
|
||||
|
||||
dones.b();
|
||||
return writePromiseB;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after completing 2nd write()');
|
||||
|
||||
writePromiseC = writer.write('c');
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after 3rd write()');
|
||||
|
||||
dones.c();
|
||||
return writePromiseC;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after completing 3rd write()');
|
||||
});
|
||||
}, 'Correctly governs the value of a WritableStream\'s state property (HWM = 0)');
|
||||
|
||||
promise_test(() => {
|
||||
const dones = Object.create(null);
|
||||
|
||||
const ws = new WritableStream(
|
||||
{
|
||||
write(chunk) {
|
||||
return new Promise(resolve => {
|
||||
dones[chunk] = resolve;
|
||||
});
|
||||
}
|
||||
},
|
||||
new CountQueuingStrategy({ highWaterMark: 4 })
|
||||
);
|
||||
|
||||
const writer = ws.getWriter();
|
||||
let writePromiseB;
|
||||
let writePromiseC;
|
||||
let writePromiseD;
|
||||
|
||||
return Promise.resolve().then(() => {
|
||||
assert_equals(writer.desiredSize, 4, 'desiredSize should be initially 4');
|
||||
|
||||
const writePromiseA = writer.write('a');
|
||||
assert_equals(writer.desiredSize, 3, 'desiredSize should be 3 after 1st write()');
|
||||
|
||||
writePromiseB = writer.write('b');
|
||||
assert_equals(writer.desiredSize, 2, 'desiredSize should be 2 after 2nd write()');
|
||||
|
||||
writePromiseC = writer.write('c');
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1 after 3rd write()');
|
||||
|
||||
writePromiseD = writer.write('d');
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after 4th write()');
|
||||
|
||||
writer.write('e');
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after 5th write()');
|
||||
|
||||
writer.write('f');
|
||||
assert_equals(writer.desiredSize, -2, 'desiredSize should be -2 after 6th write()');
|
||||
|
||||
writer.write('g');
|
||||
assert_equals(writer.desiredSize, -3, 'desiredSize should be -3 after 7th write()');
|
||||
|
||||
dones.a();
|
||||
return writePromiseA;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, -2, 'desiredSize should be -2 after completing 1st write()');
|
||||
|
||||
dones.b();
|
||||
return writePromiseB;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after completing 2nd write()');
|
||||
|
||||
dones.c();
|
||||
return writePromiseC;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after completing 3rd write()');
|
||||
|
||||
writer.write('h');
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after 8th write()');
|
||||
|
||||
dones.d();
|
||||
return writePromiseD;
|
||||
}).then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after completing 4th write()');
|
||||
|
||||
writer.write('i');
|
||||
assert_equals(writer.desiredSize, -1, 'desiredSize should be -1 after 9th write()');
|
||||
});
|
||||
}, 'Correctly governs the value of a WritableStream\'s state property (HWM = 4)');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>count-queuing-strategy.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('count-queuing-strategy.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>count-queuing-strategy.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('count-queuing-strategy.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>general.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('general.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>general.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
|
||||
|
||||
<script src="general.js"></script>
|
||||
218
tests/wpt/web-platform-tests/streams/writable-streams/general.js
Normal file
218
tests/wpt/web-platform-tests/streams/writable-streams/general.js
Normal file
|
|
@ -0,0 +1,218 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
}
|
||||
|
||||
test(() => {
|
||||
const ws = new WritableStream({});
|
||||
const writer = ws.getWriter();
|
||||
writer.releaseLock();
|
||||
|
||||
assert_throws(new TypeError(), () => writer.desiredSize, 'desiredSize should throw a TypeError');
|
||||
}, 'desiredSize on a released writer');
|
||||
|
||||
test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
|
||||
}, 'desiredSize initial value');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.close();
|
||||
|
||||
return writer.closed.then(() => {
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0');
|
||||
});
|
||||
}, 'desiredSize on a writer for a closed stream');
|
||||
|
||||
test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.close();
|
||||
writer.releaseLock();
|
||||
|
||||
ws.getWriter();
|
||||
}, 'ws.getWriter() on a closing WritableStream');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.close().then(() => {
|
||||
writer.releaseLock();
|
||||
|
||||
ws.getWriter();
|
||||
});
|
||||
}, 'ws.getWriter() on a closed WritableStream');
|
||||
|
||||
test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.abort();
|
||||
writer.releaseLock();
|
||||
|
||||
ws.getWriter();
|
||||
}, 'ws.getWriter() on an aborted WritableStream');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({
|
||||
start(c) {
|
||||
c.error();
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
return writer.closed.then(
|
||||
v => assert_unreached('writer.closed fulfilled unexpectedly with: ' + v),
|
||||
() => {
|
||||
writer.releaseLock();
|
||||
|
||||
ws.getWriter();
|
||||
}
|
||||
);
|
||||
}, 'ws.getWriter() on an errored WritableStream');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream({});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
writer.releaseLock();
|
||||
|
||||
return writer.closed.then(
|
||||
v => assert_unreached('writer.closed fulfilled unexpectedly with: ' + v),
|
||||
closedRejection => {
|
||||
assert_equals(closedRejection.name, 'TypeError', 'closed promise should reject with a TypeError');
|
||||
return writer.ready.then(
|
||||
v => assert_unreached('writer.ready fulfilled unexpectedly with: ' + v),
|
||||
readyRejection => assert_equals(readyRejection, closedRejection,
|
||||
'ready promise should reject with the same error')
|
||||
);
|
||||
}
|
||||
);
|
||||
}, 'closed and ready on a released writer');
|
||||
|
||||
promise_test(() => {
|
||||
const promises = {};
|
||||
const resolvers = {};
|
||||
for (const methodName of ['start', 'write', 'close', 'abort']) {
|
||||
promises[methodName] = new Promise(resolve => {
|
||||
resolvers[methodName] = resolve;
|
||||
});
|
||||
}
|
||||
|
||||
// Calls to Sink methods after the first are implicitly ignored. Only the first value that is passed to the resolver
|
||||
// is used.
|
||||
class Sink {
|
||||
start() {
|
||||
// Called twice
|
||||
resolvers.start(this);
|
||||
}
|
||||
|
||||
write() {
|
||||
resolvers.write(this);
|
||||
}
|
||||
|
||||
close() {
|
||||
resolvers.close(this);
|
||||
}
|
||||
|
||||
abort() {
|
||||
resolvers.abort(this);
|
||||
}
|
||||
}
|
||||
|
||||
const theSink = new Sink();
|
||||
const ws = new WritableStream(theSink);
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.write('a');
|
||||
writer.close();
|
||||
|
||||
const ws2 = new WritableStream(theSink);
|
||||
const writer2 = ws2.getWriter();
|
||||
writer2.abort();
|
||||
|
||||
return promises.start
|
||||
.then(thisValue => assert_equals(thisValue, theSink, 'start should be called as a method'))
|
||||
.then(() => promises.write)
|
||||
.then(thisValue => assert_equals(thisValue, theSink, 'write should be called as a method'))
|
||||
.then(() => promises.close)
|
||||
.then(thisValue => assert_equals(thisValue, theSink, 'close should be called as a method'))
|
||||
.then(() => promises.abort)
|
||||
.then(thisValue => assert_equals(thisValue, theSink, 'abort should be called as a method'));
|
||||
}, 'WritableStream should call underlying sink methods as methods');
|
||||
|
||||
promise_test(t => {
|
||||
function functionWithOverloads() {}
|
||||
functionWithOverloads.apply = () => assert_unreached('apply() should not be called');
|
||||
functionWithOverloads.call = () => assert_unreached('call() should not be called');
|
||||
const underlyingSink = {
|
||||
start: functionWithOverloads,
|
||||
write: functionWithOverloads,
|
||||
close: functionWithOverloads,
|
||||
abort: functionWithOverloads
|
||||
};
|
||||
// Test start(), write(), close().
|
||||
const ws1 = new WritableStream(underlyingSink);
|
||||
const writer1 = ws1.getWriter();
|
||||
writer1.write('a');
|
||||
writer1.close();
|
||||
|
||||
// Test abort().
|
||||
const ws2 = new WritableStream(underlyingSink);
|
||||
const writer2 = ws2.getWriter();
|
||||
writer2.abort();
|
||||
|
||||
// Test abort() with a close underlying sink method present. (Historical; see
|
||||
// https://github.com/whatwg/streams/issues/620#issuecomment-263483953 for what used to be
|
||||
// tested here. But more coverage can't hurt.)
|
||||
const ws3 = new WritableStream({
|
||||
start: functionWithOverloads,
|
||||
write: functionWithOverloads,
|
||||
close: functionWithOverloads
|
||||
});
|
||||
const writer3 = ws3.getWriter();
|
||||
writer3.abort();
|
||||
|
||||
return writer1.closed
|
||||
.then(() => promise_rejects(t, new TypeError(), writer2.closed, 'writer2.closed should be rejected'))
|
||||
.then(() => promise_rejects(t, new TypeError(), writer3.closed, 'writer3.closed should be rejected'));
|
||||
}, 'methods should not not have .apply() or .call() called');
|
||||
|
||||
promise_test(() => {
|
||||
const strategy = {
|
||||
size() {
|
||||
if (this !== undefined) {
|
||||
throw new Error('size called as a method');
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
const ws = new WritableStream({}, strategy);
|
||||
const writer = ws.getWriter();
|
||||
return writer.write('a');
|
||||
}, 'WritableStream\'s strategy.size should not be called as a method');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = new WritableStream();
|
||||
const writer1 = ws.getWriter();
|
||||
assert_equals(undefined, writer1.releaseLock(), 'releaseLock() should return undefined');
|
||||
const writer2 = ws.getWriter();
|
||||
assert_equals(undefined, writer1.releaseLock(), 'no-op releaseLock() should return undefined');
|
||||
// Calling releaseLock() on writer1 should not interfere with writer2. If it did, then the ready promise would be
|
||||
// rejected.
|
||||
return writer2.ready;
|
||||
}, 'redundant releaseLock() is no-op');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>general.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('general.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>general.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('general.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>start.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('start.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>start.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script src="../resources/test-utils.js"></script>
|
||||
<script src="../resources/recording-streams.js"></script>
|
||||
|
||||
<script src="start.js"></script>
|
||||
107
tests/wpt/web-platform-tests/streams/writable-streams/start.js
Normal file
107
tests/wpt/web-platform-tests/streams/writable-streams/start.js
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
self.importScripts('../resources/test-utils.js');
|
||||
self.importScripts('../resources/recording-streams.js');
|
||||
}
|
||||
|
||||
promise_test(() => {
|
||||
let resolveStartPromise;
|
||||
const ws = recordingWritableStream({
|
||||
start() {
|
||||
return new Promise(resolve => {
|
||||
resolveStartPromise = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
|
||||
writer.write('a');
|
||||
assert_equals(writer.desiredSize, 0, 'desiredSize should be 0 after writer.write()');
|
||||
|
||||
// Wait and verify that write isn't called.
|
||||
return flushAsyncEvents()
|
||||
.then(() => {
|
||||
assert_array_equals(ws.events, [], 'write should not be called until start promise resolves');
|
||||
resolveStartPromise();
|
||||
return writer.ready;
|
||||
})
|
||||
.then(() => assert_array_equals(ws.events, ['write', 'a'],
|
||||
'write should not be called until start promise resolves'));
|
||||
}, 'underlying sink\'s write should not be called until start finishes');
|
||||
|
||||
promise_test(() => {
|
||||
let resolveStartPromise;
|
||||
const ws = recordingWritableStream({
|
||||
start() {
|
||||
return new Promise(resolve => {
|
||||
resolveStartPromise = resolve;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
const writer = ws.getWriter();
|
||||
|
||||
writer.close();
|
||||
assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
|
||||
|
||||
// Wait and verify that write isn't called.
|
||||
return flushAsyncEvents().then(() => {
|
||||
assert_array_equals(ws.events, [], 'close should not be called until start promise resolves');
|
||||
resolveStartPromise();
|
||||
return writer.closed;
|
||||
});
|
||||
}, 'underlying sink\'s close should not be called until start finishes');
|
||||
|
||||
test(() => {
|
||||
const passedError = new Error('horrible things');
|
||||
|
||||
let writeCalled = false;
|
||||
let closeCalled = false;
|
||||
assert_throws(passedError, () => {
|
||||
// recordingWritableStream cannot be used here because the exception in the
|
||||
// constructor prevents assigning the object to a variable.
|
||||
new WritableStream({
|
||||
start() {
|
||||
throw passedError;
|
||||
},
|
||||
write() {
|
||||
writeCalled = true;
|
||||
},
|
||||
close() {
|
||||
closeCalled = true;
|
||||
}
|
||||
});
|
||||
}, 'constructor should throw passedError');
|
||||
assert_false(writeCalled, 'write should not be called');
|
||||
assert_false(closeCalled, 'close should not be called');
|
||||
}, 'underlying sink\'s write or close should not be called if start throws');
|
||||
|
||||
promise_test(() => {
|
||||
const ws = recordingWritableStream({
|
||||
start() {
|
||||
return Promise.reject();
|
||||
}
|
||||
});
|
||||
|
||||
// Wait and verify that write or close aren't called.
|
||||
return flushAsyncEvents()
|
||||
.then(() => assert_array_equals(ws.events, [], 'write and close should not be called'));
|
||||
}, 'underlying sink\'s write or close should not be invoked if the promise returned by start is rejected');
|
||||
|
||||
promise_test(t => {
|
||||
const rejection = { name: 'this is checked' };
|
||||
const ws = new WritableStream({
|
||||
start() {
|
||||
return {
|
||||
then(onFulfilled, onRejected) { onRejected(rejection); }
|
||||
};
|
||||
}
|
||||
});
|
||||
return promise_rejects(t, rejection, ws.getWriter().closed, 'closed promise should be rejected');
|
||||
}, 'returning a thenable from start() should work');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>start.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('start.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>start.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('start.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>write.js dedicated worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new Worker('write.js'));
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>write.js browser context wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script src="../resources/test-utils.js"></script>
|
||||
<script src="../resources/recording-streams.js"></script>
|
||||
|
||||
<script src="write.js"></script>
|
||||
258
tests/wpt/web-platform-tests/streams/writable-streams/write.js
Normal file
258
tests/wpt/web-platform-tests/streams/writable-streams/write.js
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
'use strict';
|
||||
|
||||
if (self.importScripts) {
|
||||
self.importScripts('/resources/testharness.js');
|
||||
self.importScripts('../resources/test-utils.js');
|
||||
self.importScripts('../resources/recording-streams.js');
|
||||
}
|
||||
|
||||
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(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(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(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(t, error1, writer.write('a'),
|
||||
'write() should reject with the error returned from the sink\'s write method')
|
||||
.then(() => promise_rejects(t, new 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(t, error2, writer.write('a'),
|
||||
'write() should reject with the error returned from the sink\'s write method ')
|
||||
.then(() => {
|
||||
return Promise.all([
|
||||
promise_rejects(t, error1, writer.ready,
|
||||
'writer.ready must reject with the error passed to the controller'),
|
||||
promise_rejects(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');
|
||||
|
||||
done();
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>write.js service worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
service_worker_test('write.js', 'Service worker test setup');
|
||||
</script>
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
<!DOCTYPE html>
|
||||
<meta charset="utf-8">
|
||||
<title>write.js shared worker wrapper file</title>
|
||||
|
||||
<script src="/resources/testharness.js"></script>
|
||||
<script src="/resources/testharnessreport.js"></script>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
fetch_tests_from_worker(new SharedWorker('write.js'));
|
||||
</script>
|
||||
Loading…
Add table
Add a link
Reference in a new issue