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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// META: global=window,worker
'use strict';
const error1 = new Error('error1');
error1.name = 'error1';
const error2 = new Error('error2');
error2.name = 'error2';
promise_test(() => {
let controller;
const ws = new WritableStream({
start(c) {
controller = c;
}
});
// Now error the stream after its construction.
controller.error(error1);
const writer = ws.getWriter();
assert_equals(writer.desiredSize, null, 'desiredSize should be null');
return writer.closed.catch(r => {
assert_equals(r, error1, 'ws should be errored by the passed error');
});
}, 'controller argument should be passed to start method');
promise_test(t => {
const ws = new WritableStream({
write(chunk, controller) {
controller.error(error1);
}
});
const writer = ws.getWriter();
return Promise.all([
writer.write('a'),
promise_rejects_exactly(t, error1, writer.closed, 'controller.error() in write() should error the stream')
]);
}, 'controller argument should be passed to write method');
// Older versions of the standard had the controller argument passed to close(). It wasn't useful, and so has been
// removed. This test remains to identify implementations that haven't been updated.
promise_test(t => {
const ws = new WritableStream({
close(...args) {
t.step(() => {
assert_array_equals(args, [], 'no arguments should be passed to close');
});
}
});
return ws.getWriter().close();
}, 'controller argument should not be passed to close method');
promise_test(() => {
const ws = new WritableStream({}, {
highWaterMark: 1000,
size() { return 1; }
});
const writer = ws.getWriter();
assert_equals(writer.desiredSize, 1000, 'desiredSize should be 1000');
return writer.ready.then(v => {
assert_equals(v, undefined, 'ready promise should fulfill with undefined');
});
}, 'highWaterMark should be reflected to desiredSize');
promise_test(() => {
const ws = new WritableStream({}, {
highWaterMark: Infinity,
size() { return 0; }
});
const writer = ws.getWriter();
assert_equals(writer.desiredSize, Infinity, 'desiredSize should be Infinity');
return writer.ready;
}, 'WritableStream should be writable and ready should fulfill immediately if the strategy does not apply ' +
'backpressure');
test(() => {
new WritableStream();
}, 'WritableStream should be constructible with no arguments');
test(() => {
const underlyingSink = { get start() { throw error1; } };
const queuingStrategy = { highWaterMark: 0, get size() { throw error2; } };
// underlyingSink is converted in prose in the method body, whereas queuingStrategy is done at the IDL layer.
// So the queuingStrategy exception should be encountered first.
assert_throws_exactly(error2, () => new WritableStream(underlyingSink, queuingStrategy));
}, 'underlyingSink argument should be converted after queuingStrategy argument');
test(() => {
const ws = new WritableStream({});
const writer = ws.getWriter();
assert_equals(typeof writer.write, 'function', 'writer should have a write method');
assert_equals(typeof writer.abort, 'function', 'writer should have an abort method');
assert_equals(typeof writer.close, 'function', 'writer should have a close method');
assert_equals(writer.desiredSize, 1, 'desiredSize should start at 1');
assert_not_equals(typeof writer.ready, 'undefined', 'writer should have a ready property');
assert_equals(typeof writer.ready.then, 'function', 'ready property should be thenable');
assert_not_equals(typeof writer.closed, 'undefined', 'writer should have a closed property');
assert_equals(typeof writer.closed.then, 'function', 'closed property should be thenable');
}, 'WritableStream instances should have standard methods and properties');
test(() => {
let WritableStreamDefaultController;
new WritableStream({
start(c) {
WritableStreamDefaultController = c.constructor;
}
});
assert_throws_js(TypeError, () => new WritableStreamDefaultController({}),
'constructor should throw a TypeError exception');
}, 'WritableStreamDefaultController constructor should throw');
test(() => {
let WritableStreamDefaultController;
const stream = new WritableStream({
start(c) {
WritableStreamDefaultController = c.constructor;
}
});
assert_throws_js(TypeError, () => new WritableStreamDefaultController(stream),
'constructor should throw a TypeError exception');
}, 'WritableStreamDefaultController constructor should throw when passed an initialised WritableStream');
test(() => {
const stream = new WritableStream();
const writer = stream.getWriter();
const WritableStreamDefaultWriter = writer.constructor;
writer.releaseLock();
assert_throws_js(TypeError, () => new WritableStreamDefaultWriter({}),
'constructor should throw a TypeError exception');
}, 'WritableStreamDefaultWriter should throw unless passed a WritableStream');
test(() => {
const stream = new WritableStream();
const writer = stream.getWriter();
const WritableStreamDefaultWriter = writer.constructor;
assert_throws_js(TypeError, () => new WritableStreamDefaultWriter(stream),
'constructor should throw a TypeError exception');
}, 'WritableStreamDefaultWriter constructor should throw when stream argument is locked');
|
