| 'use strict'; |
| |
| if (self.importScripts) { |
| self.importScripts('../resources/test-utils.js'); |
| self.importScripts('/resources/testharness.js'); |
| } |
| |
| let ReadableStreamDefaultReader; |
| let ReadableStreamController; |
| |
| test(() => { |
| |
| // It's not exposed globally, but we test a few of its properties here. |
| ReadableStreamDefaultReader = (new ReadableStream()).getReader().constructor; |
| |
| }, 'Can get the ReadableStreamDefaultReader constructor indirectly'); |
| |
| test(() => { |
| |
| // It's not exposed globally, but we test a few of its properties here. |
| new ReadableStream({ |
| start(c) { |
| ReadableStreamController = c.constructor; |
| } |
| }); |
| |
| }, 'Can get the ReadableStreamController constructor indirectly'); |
| |
| function fakeReadableStream() { |
| return { |
| cancel() { return Promise.resolve(); }, |
| getReader() { return new ReadableStreamDefaultReader(new ReadableStream()); }, |
| pipeThrough(obj) { return obj.readable; }, |
| pipeTo() { return Promise.resolve(); }, |
| tee() { return [realReadableStream(), realReadableStream()]; } |
| }; |
| } |
| |
| function realReadableStream() { |
| return new ReadableStream(); |
| } |
| |
| function fakeReadableStreamDefaultReader() { |
| return { |
| get closed() { return Promise.resolve(); }, |
| cancel() { return Promise.resolve(); }, |
| read() { return Promise.resolve({ value: undefined, done: true }); }, |
| releaseLock() { return; } |
| }; |
| } |
| |
| function fakeReadableStreamController() { |
| return { |
| close() { }, |
| enqueue() { }, |
| error() { } |
| }; |
| } |
| |
| promise_test(t => { |
| |
| return methodRejects(t, ReadableStream.prototype, 'cancel', fakeReadableStream()); |
| |
| }, 'ReadableStream.prototype.cancel enforces a brand check'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStream.prototype, 'getReader', fakeReadableStream()); |
| |
| }, 'ReadableStream.prototype.getReader enforces a brand check'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStream.prototype, 'tee', fakeReadableStream()); |
| |
| }, 'ReadableStream.prototype.tee enforces a brand check'); |
| |
| test(() => { |
| |
| assert_throws(new TypeError(), () => new ReadableStreamDefaultReader(fakeReadableStream()), |
| 'Constructing a ReadableStreamDefaultReader should throw'); |
| |
| }, 'ReadableStreamDefaultReader enforces a brand check on its argument'); |
| |
| promise_test(t => { |
| |
| return Promise.all([ |
| getterRejects(t, ReadableStreamDefaultReader.prototype, 'closed', fakeReadableStreamDefaultReader()), |
| getterRejects(t, ReadableStreamDefaultReader.prototype, 'closed', realReadableStream()) |
| ]); |
| |
| }, 'ReadableStreamDefaultReader.prototype.closed enforces a brand check'); |
| |
| promise_test(t => { |
| |
| return Promise.all([ |
| methodRejects(t, ReadableStreamDefaultReader.prototype, 'cancel', fakeReadableStreamDefaultReader()), |
| methodRejects(t, ReadableStreamDefaultReader.prototype, 'cancel', realReadableStream()) |
| ]); |
| |
| }, 'ReadableStreamDefaultReader.prototype.cancel enforces a brand check'); |
| |
| promise_test(t => { |
| |
| return Promise.all([ |
| methodRejects(t, ReadableStreamDefaultReader.prototype, 'read', fakeReadableStreamDefaultReader()), |
| methodRejects(t, ReadableStreamDefaultReader.prototype, 'read', realReadableStream()) |
| ]); |
| |
| }, 'ReadableStreamDefaultReader.prototype.read enforces a brand check'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStreamDefaultReader.prototype, 'releaseLock', fakeReadableStreamDefaultReader()); |
| methodThrows(ReadableStreamDefaultReader.prototype, 'releaseLock', realReadableStream()); |
| |
| }, 'ReadableStreamDefaultReader.prototype.releaseLock enforces a brand check'); |
| |
| test(() => { |
| |
| assert_throws(new TypeError(), () => new ReadableStreamController(fakeReadableStream()), |
| 'Constructing a ReadableStreamController should throw'); |
| |
| }, 'ReadableStreamController enforces a brand check on its argument'); |
| |
| test(() => { |
| |
| assert_throws(new TypeError(), () => new ReadableStreamController(realReadableStream()), |
| 'Constructing a ReadableStreamController should throw'); |
| |
| }, 'ReadableStreamController can\'t be given a fully-constructed ReadableStream'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStreamController.prototype, 'close', fakeReadableStreamController()); |
| |
| }, 'ReadableStreamController.prototype.close enforces a brand check'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStreamController.prototype, 'enqueue', fakeReadableStreamController()); |
| |
| }, 'ReadableStreamController.prototype.enqueue enforces a brand check'); |
| |
| test(() => { |
| |
| methodThrows(ReadableStreamController.prototype, 'error', fakeReadableStreamController()); |
| |
| }, 'ReadableStreamController.prototype.error enforces a brand check'); |
| |
| done(); |