mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-07-25 18:32:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibWeb: Import TransformStream error tests

Browse source
This commit is contained in:
Timothy Flynn 2025-04-16 12:01:32 -04:00 • committed by Tim Flynn
commit 1673f6783c
Notes: github-actions[bot] 2025-04-16 17:16:43 +00:00
3 changed files with 402 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

27
Tests/LibWeb/Text/expected/wpt-import/streams/transform-streams/errors.any.txt Normal file
View file

@ -0,0 +1,27 @@
Harness status: OK
Found 21 tests
19 Pass
2 Fail
Pass TransformStream errors thrown in transform put the writable and readable in an errored state
Pass TransformStream errors thrown in flush put the writable and readable in an errored state
Pass errored TransformStream should not enqueue new chunks
Pass TransformStream transformer.start() rejected promise should error the stream
Pass when controller.error is followed by a rejection, the error reason should come from controller.error
Pass TransformStream constructor should throw when start does
Pass when strategy.size throws inside start(), the constructor should throw the same error
Pass when strategy.size calls controller.error() then throws, the constructor should throw the first error
Pass cancelling the readable side should error the writable
Pass it should be possible to error the readable between close requested and complete
Pass an exception from transform() should error the stream if terminate has been requested but not completed
Pass abort should set the close reason for the writable when it happens before cancel during start, and cancel should reject
Pass abort should set the close reason for the writable when it happens before cancel during underlying sink write, but cancel should still succeed
Pass controller.error() should do nothing the second time it is called
Pass controller.error() should close writable immediately after readable.cancel()
Pass controller.error() should do nothing after readable.cancel() resolves
Pass controller.error() should do nothing after writable.abort() has completed
Pass controller.error() should do nothing after a transformer method has thrown an exception
Pass erroring during write with backpressure should result in the write failing
Fail a write() that was waiting for backpressure should reject if the writable is aborted
Fail the readable should be errored with the reason passed to the writable abort() method

15
Tests/LibWeb/Text/input/wpt-import/streams/transform-streams/errors.any.html Normal file
View file

@ -0,0 +1,15 @@
<!doctype html>
<meta charset=utf-8>
<script>
self.GLOBAL = {
isWindow: function() { return true; },
isWorker: function() { return false; },
isShadowRealm: function() { return false; },
};
</script>
<script src="../../resources/testharness.js"></script>
<script src="../../resources/testharnessreport.js"></script>
<script src="../resources/test-utils.js"></script>
<div id=log></div>
<script src="../../streams/transform-streams/errors.any.js"></script>

360
Tests/LibWeb/Text/input/wpt-import/streams/transform-streams/errors.any.js Normal file
View file

@ -0,0 +1,360 @@
// META: global=window,worker,shadowrealm
// META: script=../resources/test-utils.js
'use strict';
const thrownError = new Error('bad things are happening!');
thrownError.name = 'error1';
promise_test(t => {
const ts = new TransformStream({
transform() {
throw thrownError;
},
cancel: t.unreached_func('cancel should not be called')
});
const reader = ts.readable.getReader();
const writer = ts.writable.getWriter();
return Promise.all([
promise_rejects_exactly(t, thrownError, writer.write('a'),
'writable\'s write should reject with the thrown error'),
promise_rejects_exactly(t, thrownError, reader.read(),
'readable\'s read should reject with the thrown error'),
promise_rejects_exactly(t, thrownError, reader.closed,
'readable\'s closed should be rejected with the thrown error'),
promise_rejects_exactly(t, thrownError, writer.closed,
'writable\'s closed should be rejected with the thrown error')
]);
}, 'TransformStream errors thrown in transform put the writable and readable in an errored state');
promise_test(t => {
const ts = new TransformStream({
transform() {
},
flush() {
throw thrownError;
},
cancel: t.unreached_func('cancel should not be called')
});
const reader = ts.readable.getReader();
const writer = ts.writable.getWriter();
return Promise.all([
writer.write('a'),
promise_rejects_exactly(t, thrownError, writer.close(),
'writable\'s close should reject with the thrown error'),
promise_rejects_exactly(t, thrownError, reader.read(),
'readable\'s read should reject with the thrown error'),
promise_rejects_exactly(t, thrownError, reader.closed,
'readable\'s closed should be rejected with the thrown error'),
promise_rejects_exactly(t, thrownError, writer.closed,
'writable\'s closed should be rejected with the thrown error')
]);
}, 'TransformStream errors thrown in flush put the writable and readable in an errored state');
test(t => {
new TransformStream({
start(c) {
c.enqueue('a');
c.error(new Error('generic error'));
assert_throws_js(TypeError, () => c.enqueue('b'), 'enqueue() should throw');
},
cancel: t.unreached_func('cancel should not be called')
});
}, 'errored TransformStream should not enqueue new chunks');
promise_test(t => {
const ts = new TransformStream({
start() {
return flushAsyncEvents().then(() => {
throw thrownError;
});
},
transform: t.unreached_func('transform should not be called'),
flush: t.unreached_func('flush should not be called'),
cancel: t.unreached_func('cancel should not be called')
});
const writer = ts.writable.getWriter();
const reader = ts.readable.getReader();
return Promise.all([
promise_rejects_exactly(t, thrownError, writer.write('a'), 'writer should reject with thrownError'),
promise_rejects_exactly(t, thrownError, writer.close(), 'close() should reject with thrownError'),
promise_rejects_exactly(t, thrownError, reader.read(), 'reader should reject with thrownError')
]);
}, 'TransformStream transformer.start() rejected promise should error the stream');
promise_test(t => {
const controllerError = new Error('start failure');
controllerError.name = 'controllerError';
const ts = new TransformStream({
start(c) {
return flushAsyncEvents()
.then(() => {
c.error(controllerError);
throw new Error('ignored error');
});
},
transform: t.unreached_func('transform should never be called if start() fails'),
flush: t.unreached_func('flush should never be called if start() fails'),
cancel: t.unreached_func('cancel should never be called if start() fails')
});
const writer = ts.writable.getWriter();
const reader = ts.readable.getReader();
return Promise.all([
promise_rejects_exactly(t, controllerError, writer.write('a'), 'writer should reject with controllerError'),
promise_rejects_exactly(t, controllerError, writer.close(), 'close should reject with same error'),
promise_rejects_exactly(t, controllerError, reader.read(), 'reader should reject with same error')
]);
}, 'when controller.error is followed by a rejection, the error reason should come from controller.error');
test(() => {
assert_throws_js(URIError, () => new TransformStream({
start() { throw new URIError('start thrown error'); },
transform() {}
}), 'constructor should throw');
}, 'TransformStream constructor should throw when start does');
test(() => {
const strategy = {
size() { throw new URIError('size thrown error'); }
};
assert_throws_js(URIError, () => new TransformStream({
start(c) {
c.enqueue('a');
},
transform() {}
}, undefined, strategy), 'constructor should throw the same error strategy.size throws');
}, 'when strategy.size throws inside start(), the constructor should throw the same error');
test(() => {
const controllerError = new URIError('controller.error');
let controller;
const strategy = {
size() {
controller.error(controllerError);
throw new Error('redundant error');
}
};
assert_throws_js(URIError, () => new TransformStream({
start(c) {
controller = c;
c.enqueue('a');
},
transform() {}
}, undefined, strategy), 'the first error should be thrown');
}, 'when strategy.size calls controller.error() then throws, the constructor should throw the first error');
promise_test(t => {
const ts = new TransformStream();
const writer = ts.writable.getWriter();
const closedPromise = writer.closed;
return Promise.all([
ts.readable.cancel(thrownError),
promise_rejects_exactly(t, thrownError, closedPromise, 'closed should throw a TypeError')
]);
}, 'cancelling the readable side should error the writable');
promise_test(t => {
let controller;
const ts = new TransformStream({
start(c) {
controller = c;
}
});
const writer = ts.writable.getWriter();
const reader = ts.readable.getReader();
const writePromise = writer.write('a');
const closePromise = writer.close();
controller.error(thrownError);
return Promise.all([
promise_rejects_exactly(t, thrownError, reader.closed, 'reader.closed should reject'),
promise_rejects_exactly(t, thrownError, writePromise, 'writePromise should reject'),
promise_rejects_exactly(t, thrownError, closePromise, 'closePromise should reject')]);
}, 'it should be possible to error the readable between close requested and complete');
promise_test(t => {
const ts = new TransformStream({
transform(chunk, controller) {
controller.enqueue(chunk);
controller.terminate();
throw thrownError;
}
}, undefined, { highWaterMark: 1 });
const writePromise = ts.writable.getWriter().write('a');
const closedPromise = ts.readable.getReader().closed;
return Promise.all([
promise_rejects_exactly(t, thrownError, writePromise, 'write() should reject'),
promise_rejects_exactly(t, thrownError, closedPromise, 'reader.closed should reject')
]);
}, 'an exception from transform() should error the stream if terminate has been requested but not completed');
promise_test(t => {
const ts = new TransformStream();
const writer = ts.writable.getWriter();
// The microtask following transformer.start() hasn't completed yet, so the abort is queued and not notified to the
// TransformStream yet.
const abortPromise = writer.abort(thrownError);
const cancelPromise = ts.readable.cancel(new Error('cancel reason'));
return Promise.all([
abortPromise,
cancelPromise,
promise_rejects_exactly(t, thrownError, writer.closed, 'writer.closed should reject'),
]);
}, 'abort should set the close reason for the writable when it happens before cancel during start, and cancel should ' +
'reject');
promise_test(t => {
let resolveTransform;
const transformPromise = new Promise(resolve => {
resolveTransform = resolve;
});
const ts = new TransformStream({
transform() {
return transformPromise;
}
}, undefined, { highWaterMark: 2 });
const writer = ts.writable.getWriter();
return delay(0).then(() => {
const writePromise = writer.write();
const abortPromise = writer.abort(thrownError);
const cancelPromise = ts.readable.cancel(new Error('cancel reason'));
resolveTransform();
return Promise.all([
writePromise,
abortPromise,
cancelPromise,
promise_rejects_exactly(t, thrownError, writer.closed, 'writer.closed should reject with thrownError')]);
});
}, 'abort should set the close reason for the writable when it happens before cancel during underlying sink write, ' +
'but cancel should still succeed');
const ignoredError = new Error('ignoredError');
ignoredError.name = 'ignoredError';
promise_test(t => {
const ts = new TransformStream({
start(controller) {
controller.error(thrownError);
controller.error(ignoredError);
}
});
return promise_rejects_exactly(t, thrownError, ts.writable.abort(), 'abort() should reject with thrownError');
}, 'controller.error() should do nothing the second time it is called');
promise_test(t => {
let controller;
const ts = new TransformStream({
start(c) {
controller = c;
}
});
const cancelPromise = ts.readable.cancel(ignoredError);
controller.error(thrownError);
return Promise.all([
cancelPromise,
promise_rejects_exactly(t, thrownError, ts.writable.getWriter().closed, 'closed should reject with thrownError')
]);
}, 'controller.error() should close writable immediately after readable.cancel()');
promise_test(t => {
let controller;
const ts = new TransformStream({
start(c) {
controller = c;
}
});
return ts.readable.cancel(thrownError).then(() => {
controller.error(ignoredError);
return promise_rejects_exactly(t, thrownError, ts.writable.getWriter().closed, 'closed should reject with thrownError');
});
}, 'controller.error() should do nothing after readable.cancel() resolves');
promise_test(t => {
let controller;
const ts = new TransformStream({
start(c) {
controller = c;
}
});
return ts.writable.abort(thrownError).then(() => {
controller.error(ignoredError);
return promise_rejects_exactly(t, thrownError, ts.writable.getWriter().closed, 'closed should reject with thrownError');
});
}, 'controller.error() should do nothing after writable.abort() has completed');
promise_test(t => {
let controller;
const ts = new TransformStream({
start(c) {
controller = c;
},
transform() {
throw thrownError;
}
}, undefined, { highWaterMark: Infinity });
const writer = ts.writable.getWriter();
return promise_rejects_exactly(t, thrownError, writer.write(), 'write() should reject').then(() => {
controller.error();
return promise_rejects_exactly(t, thrownError, writer.closed, 'closed should reject with thrownError');
});
}, 'controller.error() should do nothing after a transformer method has thrown an exception');
promise_test(t => {
let controller;
let calls = 0;
const ts = new TransformStream({
start(c) {
controller = c;
},
transform() {
++calls;
}
}, undefined, { highWaterMark: 1 });
return delay(0).then(() => {
// Create backpressure.
controller.enqueue('a');
const writer = ts.writable.getWriter();
// transform() will not be called until backpressure is relieved.
const writePromise = writer.write('b');
assert_equals(calls, 0, 'transform() should not have been called');
controller.error(thrownError);
// Now backpressure has been relieved and the write can proceed.
return promise_rejects_exactly(t, thrownError, writePromise, 'write() should reject').then(() => {
assert_equals(calls, 0, 'transform() should not be called');
});
});
}, 'erroring during write with backpressure should result in the write failing');
promise_test(t => {
const ts = new TransformStream({}, undefined, { highWaterMark: 0 });
return delay(0).then(() => {
const writer = ts.writable.getWriter();
// write should start synchronously
const writePromise = writer.write(0);
// The underlying sink's abort() is not called until the write() completes.
const abortPromise = writer.abort(thrownError);
// Perform a read to relieve backpressure and permit the write() to complete.
const readPromise = ts.readable.getReader().read();
return Promise.all([
promise_rejects_exactly(t, thrownError, readPromise, 'read() should reject'),
promise_rejects_exactly(t, thrownError, writePromise, 'write() should reject'),
abortPromise
]);
});
}, 'a write() that was waiting for backpressure should reject if the writable is aborted');
promise_test(t => {
const ts = new TransformStream();
ts.writable.abort(thrownError);
const reader = ts.readable.getReader();
return promise_rejects_exactly(t, thrownError, reader.read(), 'read() should reject with thrownError');
}, 'the readable should be errored with the reason passed to the writable abort() method');