196 lines
6.5 KiB
JavaScript
196 lines
6.5 KiB
JavaScript
'use strict';
|
|
|
|
if (self.importScripts) {
|
|
self.importScripts('../resources/testharness.js');
|
|
}
|
|
|
|
test(function() {
|
|
const rs = new ReadableStream({
|
|
type: "bytes"
|
|
});
|
|
rs.getReader({ mode: 'byob' });
|
|
}, "Getting a ReadableStreamBYOBReader should succeed");
|
|
|
|
test(function() {
|
|
const rs = new ReadableStream();
|
|
const tmp = 12;
|
|
assert_throws(new TypeError("Can only call ReadableStream.getReader on instances of ReadableStream"),
|
|
function() { rs.getReader.apply(tmp); });
|
|
}, "Calling getReader() with a this object different from ReadableStream should throw a TypeError");
|
|
|
|
test(function() {
|
|
const rs = new ReadableStream();
|
|
|
|
assert_throws(new TypeError("ReadableStreamBYOBReader needs a ReadableByteStreamController"),
|
|
function() { rs.getReader({ mode: 'byob' }); });
|
|
}, "Calling getReader({ mode: 'byob' }) with a ReadableStream whose controller is a ReadableStreamDefaultController should throw a TypeError");
|
|
|
|
promise_test(function(test) {
|
|
const rs = new ReadableStream({ type: 'bytes' });
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
let rp = reader.cancel.apply(rs);
|
|
const myError= new TypeError("Can only call ReadableStreamBYOBReader.cancel() on instances of ReadableStreamBYOBReader");
|
|
|
|
return promise_rejects(test, myError, rp);
|
|
}, "Calling ReadableStreamBYOBReader.cancel() with a this object different from ReadableStreamBYOBReader should be rejected");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
const myError = new TypeError("Sample error");
|
|
controller.error(myError);
|
|
let rp = reader.cancel("Sample reason");
|
|
|
|
return promise_rejects(test, myError, rp);
|
|
}, "Calling ReadableStreamBYOBReader.cancel() on a ReadableStream that has been errored should result in a promise rejected with the same error");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
controller.close();
|
|
|
|
return reader.cancel("Sample reason").then(
|
|
function(res) {
|
|
assert_object_equals(res, undefined);
|
|
}
|
|
);
|
|
}, "Calling ReadableStreamBYOBReader.cancel() on a ReadableStream that has been closed should result in a promise resolved with undefined");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
controller.close();
|
|
|
|
return reader.closed.then(
|
|
function(res) {
|
|
assert_object_equals(res, undefined);
|
|
}
|
|
);
|
|
}, "If controller is closed after ReadableStreamBYOBReader creation, ReadableStreamBYOBReader.closed should be a promise resolved with undefined");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
controller.close();
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
|
|
return reader.closed.then(
|
|
function(res) {
|
|
assert_object_equals(res, undefined);
|
|
}
|
|
);
|
|
}, "If controller has already been closed when ReadableStreamBYOBReader is created, ReadableStreamBYOBReader.closed should be a promise resolved with undefined");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
const myError = new TypeError("Sample error");
|
|
controller.error(myError);
|
|
|
|
return promise_rejects(test, myError, reader.closed);
|
|
}, "If controller is errored after ReadableStreamBYOBReader creation, ReadableStreamBYOBReader.closed should be a promise rejected with the same error");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const myError = new TypeError("Sample error");
|
|
controller.error(myError);
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
|
|
return promise_rejects(test, myError, reader.closed);
|
|
}, "If controller has already been errored when ReadableStreamBYOBReader is created, ReadableStreamBYOBReader.closed should be a promise rejected with the same error");
|
|
|
|
test(function() {
|
|
const rs = new ReadableStream({ type: 'bytes' });
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
assert_throws(new TypeError("Can only call ReadableStreamBYOBReader.releaseLock() on instances of ReadableStreamBYOBReader"),
|
|
function() { reader.releaseLock.apply(rs); });
|
|
}, "Calling ReadableStreamBYOBReader.releaseLock() with a this object different from ReadableStreamBYOBReader should be rejected");
|
|
|
|
promise_test(function(test) {
|
|
const rs = new ReadableStream({
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
reader.releaseLock();
|
|
const myError = new TypeError();
|
|
|
|
return promise_rejects(test, myError, reader.closed);
|
|
}, "Calling ReadableStreamBYOBReader.releaseLock() on a stream that is readable should result in ReadableStreamBYOBReader.closed promise to be rejected with a TypeError");
|
|
|
|
promise_test(function(test) {
|
|
let controller;
|
|
|
|
const rs = new ReadableStream({
|
|
start: function(c) {
|
|
controller = c;
|
|
},
|
|
type: "bytes"
|
|
});
|
|
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
controller.close();
|
|
reader.releaseLock();
|
|
const myError = new TypeError();
|
|
|
|
return promise_rejects(test, myError, reader.closed);
|
|
}, "Calling ReadableStreamBYOBReader.releaseLock() on a stream that is not readable should result in ReadableStreamBYOBReader.closed promise to be rejected with a TypeError");
|
|
|
|
promise_test(function(test) {
|
|
const rs = new ReadableStream({ type: 'bytes' });
|
|
const reader = rs.getReader({ mode: 'byob' });
|
|
let rp = reader.read.apply(rs);
|
|
const myError= new TypeError("Can only call ReadableStreamBYOBReader.read() on instances of ReadableStreamBYOBReader");
|
|
|
|
return promise_rejects(test, myError, rp);
|
|
}, "Calling ReadableStreamBYOBReader.read() with a this object different from ReadableStreamBYOBReader should be rejected");
|
|
|
|
done();
|