OLD | NEW |
(Empty) | |
| 1 'use strict'; |
| 2 |
| 3 if (self.importScripts) { |
| 4 self.importScripts('../resources/test-utils.js'); |
| 5 self.importScripts('/resources/testharness.js'); |
| 6 } |
| 7 |
| 8 let ReadableStreamReader; |
| 9 let ReadableStreamController; |
| 10 |
| 11 test(() => { |
| 12 |
| 13 // It's not exposed globally, but we test a few of its properties here. |
| 14 ReadableStreamReader = (new ReadableStream()).getReader().constructor; |
| 15 |
| 16 }, 'Can get the ReadableStreamReader constructor indirectly'); |
| 17 |
| 18 test(() => { |
| 19 |
| 20 // It's not exposed globally, but we test a few of its properties here. |
| 21 new ReadableStream({ |
| 22 start(c) { |
| 23 ReadableStreamController = c.constructor; |
| 24 } |
| 25 }); |
| 26 |
| 27 }, 'Can get the ReadableStreamController constructor indirectly'); |
| 28 |
| 29 function fakeReadableStream() { |
| 30 return { |
| 31 cancel() { return Promise.resolve(); }, |
| 32 getReader() { return new ReadableStreamReader(new ReadableStream()); }, |
| 33 pipeThrough(obj) { return obj.readable; }, |
| 34 pipeTo() { return Promise.resolve(); }, |
| 35 tee() { return [realReadableStream(), realReadableStream()]; } |
| 36 }; |
| 37 } |
| 38 |
| 39 function realReadableStream() { |
| 40 return new ReadableStream(); |
| 41 } |
| 42 |
| 43 function fakeReadableStreamReader() { |
| 44 return { |
| 45 get closed() { return Promise.resolve(); }, |
| 46 cancel() { return Promise.resolve(); }, |
| 47 read() { return Promise.resolve({ value: undefined, done: true }); }, |
| 48 releaseLock() { return; } |
| 49 }; |
| 50 } |
| 51 |
| 52 function fakeReadableStreamController() { |
| 53 return { |
| 54 close() { }, |
| 55 enqueue() { }, |
| 56 error() { } |
| 57 }; |
| 58 } |
| 59 |
| 60 promise_test(t => { |
| 61 |
| 62 return methodRejects(t, ReadableStream.prototype, 'cancel', fakeReadableStream
()); |
| 63 |
| 64 }, 'ReadableStream.prototype.cancel enforces a brand check'); |
| 65 |
| 66 test(() => { |
| 67 |
| 68 methodThrows(ReadableStream.prototype, 'getReader', fakeReadableStream()); |
| 69 |
| 70 }, 'ReadableStream.prototype.getReader enforces a brand check'); |
| 71 |
| 72 test(() => { |
| 73 |
| 74 methodThrows(ReadableStream.prototype, 'tee', fakeReadableStream()); |
| 75 |
| 76 }, 'ReadableStream.prototype.tee enforces a brand check'); |
| 77 |
| 78 test(() => { |
| 79 |
| 80 assert_throws(new TypeError(), () => new ReadableStreamReader(fakeReadableStre
am()), |
| 81 'Constructing a ReadableStreamReader should throw'); |
| 82 |
| 83 }, 'ReadableStreamReader enforces a brand check on its argument'); |
| 84 |
| 85 promise_test(t => { |
| 86 |
| 87 return Promise.all([ |
| 88 getterRejects(t, ReadableStreamReader.prototype, 'closed', fakeReadableStrea
mReader()), |
| 89 getterRejects(t, ReadableStreamReader.prototype, 'closed', realReadableStrea
m()) |
| 90 ]); |
| 91 |
| 92 }, 'ReadableStreamReader.prototype.closed enforces a brand check'); |
| 93 |
| 94 promise_test(t => { |
| 95 |
| 96 return Promise.all([ |
| 97 methodRejects(t, ReadableStreamReader.prototype, 'cancel', fakeReadableStrea
mReader()), |
| 98 methodRejects(t, ReadableStreamReader.prototype, 'cancel', realReadableStrea
m()) |
| 99 ]); |
| 100 |
| 101 }, 'ReadableStreamReader.prototype.cancel enforces a brand check'); |
| 102 |
| 103 promise_test(t => { |
| 104 |
| 105 return Promise.all([ |
| 106 methodRejects(t, ReadableStreamReader.prototype, 'read', fakeReadableStreamR
eader()), |
| 107 methodRejects(t, ReadableStreamReader.prototype, 'read', realReadableStream(
)) |
| 108 ]); |
| 109 |
| 110 }, 'ReadableStreamReader.prototype.read enforces a brand check'); |
| 111 |
| 112 test(() => { |
| 113 |
| 114 methodThrows(ReadableStreamReader.prototype, 'releaseLock', fakeReadableStream
Reader()); |
| 115 methodThrows(ReadableStreamReader.prototype, 'releaseLock', realReadableStream
()); |
| 116 |
| 117 }, 'ReadableStreamReader.prototype.releaseLock enforces a brand check'); |
| 118 |
| 119 test(() => { |
| 120 |
| 121 assert_throws(new TypeError(), () => new ReadableStreamController(fakeReadable
Stream()), |
| 122 'Constructing a ReadableStreamController should throw'); |
| 123 |
| 124 }, 'ReadableStreamController enforces a brand check on its argument'); |
| 125 |
| 126 test(() => { |
| 127 |
| 128 assert_throws(new TypeError(), () => new ReadableStreamController(realReadable
Stream()), |
| 129 'Constructing a ReadableStreamController should throw'); |
| 130 |
| 131 }, 'ReadableStreamController can\'t be given a fully-constructed ReadableStream'
); |
| 132 |
| 133 test(() => { |
| 134 |
| 135 methodThrows(ReadableStreamController.prototype, 'close', fakeReadableStreamCo
ntroller()); |
| 136 |
| 137 }, 'ReadableStreamController.prototype.close enforces a brand check'); |
| 138 |
| 139 test(() => { |
| 140 |
| 141 methodThrows(ReadableStreamController.prototype, 'enqueue', fakeReadableStream
Controller()); |
| 142 |
| 143 }, 'ReadableStreamController.prototype.enqueue enforces a brand check'); |
| 144 |
| 145 test(() => { |
| 146 |
| 147 methodThrows(ReadableStreamController.prototype, 'error', fakeReadableStreamCo
ntroller()); |
| 148 |
| 149 }, 'ReadableStreamController.prototype.error enforces a brand check'); |
| 150 |
| 151 done(); |
OLD | NEW |