blob: 5bca6ae25c7c466543ec24edd9d85cbace9f3fe3 [file] [log] [blame]
<!DOCTYPE html>
<script>
// Silence unhandled rejection messages.
window.addEventListener("unhandledrejection", function(event) {
event.stopImmediatePropagation();
event.preventDefault();
});
</script>
<script src='../../resources/testharness.js'></script>
<script src='../../resources/testharnessreport.js'></script>
<script src='resources/streams-utils.js'></script>
<script>
// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
function templatedRSClosed(label, factory) {
test(function() {
}, 'Running templatedRSClosed with ' + label);
var test1 = async_test('piping to a WritableStream in the writable state should close the writable stream');
test1.step(function() {
var closeCalled = false;
var rs = factory();
var startPromise = Promise.resolve();
var ws = new WritableStream({
start: function() {
return startPromise;
},
write: function() {
assert_unreached('Unexpected write call');
},
close: function() {
closeCalled = true;
},
abort: function() {
assert_unreached('Unexpected abort call');
}
});
startPromise.then(test1.step_func(function() {
assert_equals(ws.state, 'writable', 'writable stream should start in writable state');
return rs.pipeTo(ws).then(test1.step_func(function() {
assert_true(closeCalled);
assert_equals(ws.state, 'closed', 'writable stream should become closed');
test1.done('underlying source close should be called');
}));
})).catch(test1.step_func(function(e) { assert_unreached(e); }));
});
var test2 = async_test('piping to a WritableStream in the writable state with { preventClose: true } should do nothing');
test2.step(function() {
var rs = factory();
var startPromise = Promise.resolve();
var ws = new WritableStream({
start: function() {
return startPromise;
},
write: function() {
assert_unreached('Unexpected write call');
},
close: function() {
assert_unreached('Unexpected close call');
},
abort: function() {
assert_unreached('Unexpected abort call');
}
});
startPromise.then(test2.step_func(function() {
assert_equals(ws.state, 'writable', 'writable stream should start in writable state');
return rs.pipeTo(ws, { preventClose: true }).then(test2.step_func(function() {
assert_equals(ws.state, 'writable', 'writable stream should still be writable');
test2.done('pipeTo promise should be fulfilled');
}));
})).catch(test2.step_func(function(e) { assert_unreached(e); }));
});
};
function templatedRSErrored(label, factory, error) {
test(function() {
}, 'Running templatedRSErrored with ' + label);
var test1 = async_test('piping to a WritableStream in the writable state should abort the writable stream');
test1.step(function() {
var rs = factory();
var startPromise = Promise.resolve();
var ws = new WritableStream({
start: function() {
return startPromise;
},
write: function() {
assert_unreached('Unexpected write call');
},
close: function() {
assert_reached('Unexpected close call');
},
abort: function(reason) {
assert_equals(reason, error);
}
});
startPromise.then(test1.step_func(function() {
assert_equals(ws.state, 'writable');
rs.pipeTo(ws).then(
test1.step_func(function() { assert_unreached('pipeTo promise should not be fulfilled'); }),
test1.step_func(function(e) {
assert_equals(e, error, 'pipeTo promise should be rejected with the passed error');
assert_equals(ws.state, 'errored', 'writable stream should become errored');
test1.done();
})
);
}));
});
};
function templatedRSErroredAsyncOnly(label, factory, error) {
test(function() {
}, 'Running templatedRSErroredAsyncOnly with ' + label);
var test1 = async_test('piping with no options');
test1.step(function() {
var closeCalled = false;
var rs = factory();
var ws = new WritableStream({
abort: function(r) {
assert_equals(r, error, 'reason passed to abort should equal the source error');
}
});
rs.pipeTo(ws).catch(test1.step_func(function(e) {
assert_equals(ws.state, 'errored', 'destination should be errored');
assert_equals(e, error, 'rejection reason of pipeToPromise should be the source error');
assert_true(closeCalled);
test1.done();
}));
ws.closed.catch(test1.step_func(function(e) {
assert_equals(e, error, 'rejection reason of dest closed should be the source error');
closeCalled = true;
}))
});
var test2 = async_test('piping with { preventAbort: false }');
test2.step(function() {
var abortCalled = false;
var closeRejected = false;
var rs = factory();
var ws = new WritableStream({
abort: function(r) {
assert_equals(r, error, 'reason passed to abort should equal the source error');
abortCalled = true;
}
});
rs.pipeTo(ws, { preventAbort: false }).catch(test2.step_func(function(e) {
assert_equals(ws.state, 'errored', 'destination should be errored');
assert_equals(e, error, 'rejection reason of pipeToPromise should be the source error');
assert_true(abortCalled);
assert_true(closeRejected);
test2.done();
}));
ws.closed.catch(test2.step_func(function(e) {
assert_equals(e, error, 'rejection reason of dest closed should be the source error');
closeRejected = true;
}));
});
var test3 = async_test('piping with { preventAbort: true }');
test3.step(function() {
var rs = factory();
var ws = new WritableStream({
abort: function() {
assert_unreached('underlying sink abort should not be called');
}
});
rs.pipeTo(ws, { preventAbort: true }).catch(test3.step_func(function(e) {
assert_equals(ws.state, 'writable', 'destination should remain writable');
assert_equals(e, error, 'rejection reason of pipeToPromise should be the source error');
test3.done();
}));
});
};
function templatedRSTwoChunksClosed(label, factory, error) {
test(function() {
}, 'Running templatedRSTwoChunksClosed with ' + label);
var test1 = async_test('piping with no options and no destination errors');
test1.step(function() {
var rs = factory();
var chunksWritten = [];
var ws = new WritableStream({
abort: function() {
assert_unreached('unexpected abort call');
},
write: function(chunk) {
chunksWritten.push(chunk);
}
});
rs.pipeTo(ws).then(test1.step_func(function() {
assert_equals(ws.state, 'closed', 'destination should be closed');
assert_array_equals(chunksWritten, chunks);
test1.done();
}));
});
var test2 = async_test('piping with { preventClose: false } and no destination errors');
test2.step(function() {
var rs = factory();
var chunksWritten = [];
var ws = new WritableStream({
abort: function() {
assert_unreached('unexpected abort call');
},
write: function(chunk) {
chunksWritten.push(chunk);
}
});
rs.pipeTo(ws).then(test2.step_func(function() {
assert_equals(ws.state, 'closed', 'destination should be closed');
assert_array_equals(chunksWritten, chunks);
test2.done();
}));
});
var test3 = async_test('piping with { preventClose: true } and no destination errors');
test3.step(function() {
var rs = factory();
var chunksWritten = [];
var ws = new WritableStream({
close: function() {
assert_unreached('unexpected close call');
},
abort: function() {
assert_unreached('unexpected abort call');
},
write: function(chunk) {
chunksWritten.push(chunk);
}
});
rs.pipeTo(ws, { preventClose: true }).then(test3.step_func(function() {
assert_equals(ws.state, 'writable', 'destination should be writable');
assert_array_equals(chunksWritten, chunks);
test3.done();
}));
});
var test4 = async_test('piping with { preventClose: false } and a destination with that errors synchronously');
test4.step(function() {
var rs = factory();
var theError = new Error('!!!');
var ws = new WritableStream({
close: function() {
assert_unreached('unexpected close call');
},
abort: function() {
assert_unreached('unexpected abort call');
},
write: function() {
throw theError;
}
});
rs.pipeTo(ws, { preventClose: false }).then(
test4.step_func(function() { assert_unreached('pipeTo promise should not fulfill'); }),
test4.step_func(function(e) {
assert_equals(e, theError, 'pipeTo promise should reject with the write error');
test4.done();
})
);
});
var test5 = async_test('piping with { preventClose: true } and a destination with that errors synchronously');
test5.step(function() {
var rs = factory();
var theError = new Error('!!!');
var ws = new WritableStream({
close: function() {
assert_unreached('unexpected close call');
},
abort: function() {
assert_unreached('unexpected abort call');
},
write: function() {
throw theError;
}
});
rs.pipeTo(ws, { preventClose: true }).then(
test5.step_func(function() { assert_unreached('pipeTo promise should not fulfill'); }),
test5.step_func(function(e) {
assert_equals(e, theError, 'pipeTo promise should reject with the write error');
test5.done();
})
);
});
var test6 = async_test('piping with { preventClose: true } and a destination that errors on the last chunk');
test6.step(function() {
var rs = factory();
var theError = new Error('!!!');
var chunkCounter = 0;
var ws = new WritableStream(
{
close: function() {
assert_unreached('unexpected close call');
},
abort: function() {
assert_unreached('unexpected abort call');
},
write: function() {
if (++chunkCounter === 2) {
return new Promise(test6.step_func(function(r, reject) { setTimeout(test6.step_func(function() { reject(theError); }), 200); }));
}
}
},
{
highWaterMark: Infinity,
size: function() { return 1; }
}
);
rs.pipeTo(ws, { preventClose: true }).then(
test6.step_func(function() { assert_unreached('pipeTo promise should not fulfill'); }),
test6.step_func(function(e) {
assert_equals(e, theError, 'pipeTo promise should reject with the write error');
test6.done();
})
);
});
};
templatedRSClosed('ReadableStream (closed via call in start)', function() {
return new ReadableStream({
start: function(c) {
c.close();
}
});
});
templatedRSClosed('ReadableStream (closed via cancel)', function() {
var stream = new ReadableStream();
stream.cancel();
return stream;
});
var theError = new Error('boo!');
templatedRSErrored('ReadableStream (errored via call in start)', function() {
return new ReadableStream({
start: function(c) {
c.error(theError);
}
})},
theError
);
templatedRSErrored('ReadableStream (errored via returning a rejected promise in start)', function() {
return new ReadableStream({
start: function() {
return Promise.reject(theError);
}
})},
theError
);
templatedRSErroredAsyncOnly('ReadableStream (errored via returning a rejected promise in start) reader', function() {
return new ReadableStream({
start: function() { return Promise.reject(theError); }
})},
theError
);
var chunks = ['a', 'b'];
templatedRSTwoChunksClosed('ReadableStream (two chunks enqueued, then closed)', function() {
return new ReadableStream({
start: function(c) {
c.enqueue(chunks[0]);
c.enqueue(chunks[1]);
c.close();
}
})},
chunks
);
templatedRSTwoChunksClosed('ReadableStream (two chunks enqueued async, then closed)', function() {
return new ReadableStream({
_cancelled: false,
start: function(c) {
setTimeout(() => {
if (!this._cancelled)
c.enqueue(chunks[0]);
}, 100);
setTimeout(() => {
if (!this._cancelled)
c.enqueue(chunks[1]);
}, 200);
setTimeout(() => {
if (!this._cancelled)
c.close();
}, 300);
},
cancel: function(reason) {
this._cancelled = true;
}
})},
chunks
);
templatedRSTwoChunksClosed('ReadableStream (two chunks enqueued via pull, then closed)', function() {
var pullCall = 0;
return new ReadableStream({
pull:function(c) {
if (pullCall >= chunks.length) {
c.close();
} else {
c.enqueue(chunks[pullCall++]);
}
}
});
},
chunks
);
</script>