Web Inspector: REGRESSION (r238602): Elements: deleting the last child of a collapsed...
[WebKit-https.git] / LayoutTests / streams / readable-stream-byob-request.js
1 'use strict';
2
3 if (self.importScripts) {
4     self.importScripts('../resources/testharness.js');
5 }
6
7
8 // FIXME: Remove next line when bug https://bugs.webkit.org/show_bug.cgi?id=167697
9 // is fixed. For the moment, so that test may pass, we have to insert a reference
10 // to Uint8Array here (otherwise, the private variable cannot be resolved).
11 const d = new Uint8Array(1);
12
13 test(function() {
14     let controller;
15
16     const rs = new ReadableStream({
17         start: function(c) {
18             controller = c;
19         },
20         type: "bytes"
21     });
22
23     assert_equals(controller.byobRequest, undefined, "by default byobRequest should be undefined");
24 }, "By default, byobRequest should be undefined");
25
26 test(function() {
27
28     let controller;
29     const autoAllocateChunkSize = 128;
30     const rs = new ReadableStream({
31         autoAllocateChunkSize,
32         start: function(c) {
33             controller = c;
34         },
35         type: "bytes"
36     });
37
38     rs.getReader().read();
39     const byobReq = controller.byobRequest;
40
41     assert_equals(byobReq.view.length, autoAllocateChunkSize, "byobRequest length should be equal to autoAllocateChunkSize value")
42
43 }, "byobRequest.view length should be equal to autoAllocateChunkSize")
44
45 test(function() {
46
47     let controller;
48     const rs = new ReadableStream({
49         autoAllocateChunkSize: 16,
50         start: function(c) {
51             controller = c;
52         },
53         type: "bytes"
54     });
55
56     rs.getReader().read();
57     const byobReq = controller.byobRequest;
58
59     assert_throws(new TypeError("Can only call ReadableStreamBYOBRequest.respond on instances of ReadableStreamBYOBRequest"),
60         function() { byobReq.respond.apply(rs, 1); });
61
62 }, "Calling respond() with a this object different from ReadableStreamBYOBRequest should throw a TypeError");
63
64 test(function() {
65
66     let controller;
67     const rs = new ReadableStream({
68         autoAllocateChunkSize: 16,
69         start: function(c) {
70             controller = c;
71         },
72         type: "bytes"
73     });
74
75     rs.getReader().read();
76     const byobReq = controller.byobRequest;
77
78     assert_throws(new RangeError("bytesWritten has an incorrect value"),
79         function() { byobReq.respond(-1); });
80 }, "Calling respond() with a negative bytesWritten value should throw a RangeError");
81
82 test(function() {
83
84     let controller;
85     const rs = new ReadableStream({
86         autoAllocateChunkSize: 16,
87         start: function(c) {
88             controller = c;
89         },
90         type: "bytes"
91     });
92
93     rs.getReader().read();
94     const byobReq = controller.byobRequest;
95
96     assert_throws(new RangeError("bytesWritten has an incorrect value"),
97         function() { byobReq.respond("abc"); });
98 }, "Calling respond() with a bytesWritten value which is not a number should throw a RangeError");
99
100 test(function() {
101
102     let controller;
103     const rs = new ReadableStream({
104         autoAllocateChunkSize: 16,
105         start: function(c) {
106             controller = c;
107         },
108         type: "bytes"
109     });
110
111     rs.getReader().read();
112     const byobReq = controller.byobRequest;
113
114     assert_throws(new RangeError("bytesWritten has an incorrect value"),
115         function() { byobReq.respond(Number.POSITIVE_INFINITY); });
116 }, "Calling respond() with a positive infinity bytesWritten value should throw a RangeError");
117
118 test(function() {
119
120     let controller;
121     const rs = new ReadableStream({
122         autoAllocateChunkSize: 16,
123         start: function(c) {
124             controller = c;
125         },
126         type: "bytes"
127     });
128
129     rs.getReader().read();
130     const byobReq = controller.byobRequest;
131     controller.close();
132
133     assert_throws(new TypeError("bytesWritten is different from 0 even though stream is closed"),
134         function() { byobReq.respond(1); });
135 }, "Calling respond() with a bytesWritten value different from 0 when stream is closed should throw a TypeError");
136
137 test(function() {
138
139     let controller;
140     const rs = new ReadableStream({
141         autoAllocateChunkSize: 16,
142         start: function(c) {
143             controller = c;
144         },
145         type: "bytes"
146     });
147
148     // FIXME: When ReadableStreamBYOBReader is implemented, another test (or even several ones)
149     // based on this one should be added so that reader's readIntoRequests attribute is not empty
150     // and currently unreachable code is reached.
151     rs.getReader().read();
152     const byobReq = controller.byobRequest;
153     controller.close();
154     byobReq.respond(0);
155
156 }, "Calling respond() with a bytesWritten value of 0 when stream is closed should succeed");
157
158 test(function() {
159
160     let controller;
161     const rs = new ReadableStream({
162         autoAllocateChunkSize: 16,
163         start: function(c) {
164             controller = c;
165         },
166         type: "bytes"
167     });
168
169     rs.getReader().read();
170     const byobReq = controller.byobRequest;
171     assert_throws(new RangeError("bytesWritten value is too great"),
172         function() { byobReq.respond(17); });
173
174 }, "Calling respond() with a bytesWritten value greater than autoAllocateChunkSize should fail");
175
176 promise_test(function() {
177
178     const rs = new ReadableStream({
179         autoAllocateChunkSize: 16,
180         pull: function(controller) {
181             const br = controller.byobRequest;
182             br.view[0] = 1;
183             br.view[1] = 2;
184             br.respond(2);
185         },
186         type: "bytes"
187     });
188
189     return rs.getReader().read().then(result => {
190         assert_equals(result.value.byteLength, 2);
191         assert_equals(result.value.byteOffset, 0);
192         assert_equals(result.value.buffer.byteLength, 16);
193         assert_equals(result.value[0], 1);
194         assert_equals(result.value[1], 2);
195     });
196 }, "Calling respond() with a bytesWritten value lower than autoAllocateChunkSize should succeed");
197
198 // FIXME: when ReadableStreamBYOBReader is implemented, add tests with elementSize different from 1
199 // so that more code can be covered.
200
201 test(function() {
202
203     let controller;
204     const rs = new ReadableStream({
205         autoAllocateChunkSize: 16,
206         start: function(c) {
207             controller = c;
208         },
209         type: "bytes"
210     });
211
212     rs.getReader().read();
213     const byobReq = controller.byobRequest;
214
215     assert_throws(new TypeError("Can only call ReadableStreamBYOBRequest.respondWithNewView on instances of ReadableStreamBYOBRequest"),
216         function() { byobReq.respondWithNewView.apply(rs, new Uint8Array(1)); });
217
218 }, "Calling respondWithNewView() with a this object different from ReadableStreamBYOBRequest should throw a TypeError");
219
220 test(function() {
221
222     let controller;
223     const rs = new ReadableStream({
224         autoAllocateChunkSize: 16,
225         start: function(c) {
226             controller = c;
227         },
228         type: "bytes"
229     });
230
231     rs.getReader().read();
232     const byobReq = controller.byobRequest;
233
234     assert_throws(new TypeError("Provided view is not an object"),
235         function() { byobReq.respondWithNewView(function() {}); });
236
237 }, "Calling respondWithNewView() with an argument that is not an object should throw a TypeError");
238
239 test(function() {
240
241     let controller;
242     const rs = new ReadableStream({
243         autoAllocateChunkSize: 16,
244         start: function(c) {
245             controller = c;
246         },
247         type: "bytes"
248     });
249
250     rs.getReader().read();
251     const byobReq = controller.byobRequest;
252
253     assert_throws(new TypeError("Provided view is not an ArrayBufferView"),
254         function() { byobReq.respondWithNewView({}); });
255
256 }, "Calling respondWithNewView() with an argument that is not an ArrayBufferView should throw a TypeError");
257
258 promise_test(function() {
259
260     const rs = new ReadableStream({
261         autoAllocateChunkSize: 2,
262         pull: function(controller) {
263             const newView = new Uint8Array([3, 6]);
264             const br = controller.byobRequest;
265             br.respondWithNewView(newView);
266         },
267         type: "bytes"
268     });
269
270     return rs.getReader().read().then(result => {
271         assert_equals(result.value.byteLength, 2);
272         assert_equals(result.value.byteOffset, 0);
273         assert_equals(result.value.buffer.byteLength, 2);
274         assert_equals(result.value[0], 3);
275         assert_equals(result.value[1], 6);
276     });
277 }, "When using autoAllocateChunkSize, calling respondWithNewView() should succeed if view.byteLength is equal to autoAllocateChunkSize");
278
279 promise_test(function(test) {
280
281     const rs = new ReadableStream({
282         autoAllocateChunkSize: 16,
283         pull: function(controller) {
284             const newView = new Uint8Array([3, 6]);
285             const br = controller.byobRequest;
286             br.respondWithNewView(newView);
287         },
288         type: "bytes"
289     });
290
291     const error = new RangeError("Invalid value for view.byteLength");
292
293     return promise_rejects(test, error, rs.getReader().read());
294 }, "When using autoAllocateChunkSize, calling respondWithNewView() should throw a RangeError if view.byteOffset is different from 0");
295
296 promise_test(function(test) {
297
298     const rs = new ReadableStream({
299         autoAllocateChunkSize: 16,
300         pull: function(controller) {
301             const buffer = new ArrayBuffer(3);
302             const newView = new Uint8Array(buffer, 1); // byteOffset of 1
303             const br = controller.byobRequest;
304             br.respondWithNewView(newView);
305         },
306         type: "bytes"
307     });
308
309     const error = new RangeError("Invalid value for view.byteOffset");
310
311     return promise_rejects(test, error, rs.getReader().read());
312 }, "When using autoAllocateChunkSize, calling respondWithNewView() should throw a RangeError if view.byteLength is different from autoAllocateChunkSize");
313
314 done();