1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
// META: global=window,worker
'use strict';
const error1 = new Error('a unique string');
error1.name = 'error1';
test(() => {
assert_throws_exactly(error1, () => {
new WritableStream({}, {
get size() {
throw error1;
},
highWaterMark: 5
});
}, 'construction should re-throw the error');
}, 'Writable stream: throwing strategy.size getter');
test(() => {
assert_throws_js(TypeError, () => {
new WritableStream({}, { size: 'a string' });
});
}, 'reject any non-function value for strategy.size');
test(() => {
assert_throws_exactly(error1, () => {
new WritableStream({}, {
size() {
return 1;
},
get highWaterMark() {
throw error1;
}
});
}, 'construction should re-throw the error');
}, 'Writable stream: throwing strategy.highWaterMark getter');
test(() => {
for (const highWaterMark of [-1, -Infinity, NaN, 'foo', {}]) {
assert_throws_js(RangeError, () => {
new WritableStream({}, {
size() {
return 1;
},
highWaterMark
});
}, `construction should throw a RangeError for ${highWaterMark}`);
}
}, 'Writable stream: invalid strategy.highWaterMark');
promise_test(t => {
const ws = new WritableStream({}, {
size() {
throw error1;
},
highWaterMark: 5
});
const writer = ws.getWriter();
const p1 = promise_rejects_exactly(t, error1, writer.write('a'), 'write should reject with the thrown error');
const p2 = promise_rejects_exactly(t, error1, writer.closed, 'closed should reject with the thrown error');
return Promise.all([p1, p2]);
}, 'Writable stream: throwing strategy.size method');
promise_test(() => {
const sizes = [NaN, -Infinity, Infinity, -1];
return Promise.all(sizes.map(size => {
const ws = new WritableStream({}, {
size() {
return size;
},
highWaterMark: 5
});
const writer = ws.getWriter();
return writer.write('a').then(() => assert_unreached('write must reject'), writeE => {
assert_equals(writeE.name, 'RangeError', `write must reject with a RangeError for ${size}`);
return writer.closed.then(() => assert_unreached('write must reject'), closedE => {
assert_equals(closedE, writeE, `closed should reject with the same error as write`);
});
});
}));
}, 'Writable stream: invalid strategy.size return value');
test(() => {
assert_throws_js(TypeError, () => new WritableStream(undefined, {
size: 'not a function',
highWaterMark: NaN
}), 'WritableStream constructor should throw a TypeError');
}, 'Writable stream: invalid size beats invalid highWaterMark');
|
