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 |