1// META: global=window,worker
2// META: script=../resources/test-utils.js
3// META: script=../resources/rs-test-templates.js
4'use strict';
5
6// Run the readable stream test templates against readable streams created directly using the constructor
7
8const theError = { name: 'boo!' };
9const chunks = ['a', 'b'];
10
11templatedRSEmpty('ReadableStream (empty)', () => {
12  return new ReadableStream();
13});
14
15templatedRSEmptyReader('ReadableStream (empty) reader', () => {
16  return streamAndDefaultReader(new ReadableStream());
17});
18
19templatedRSClosed('ReadableStream (closed via call in start)', () => {
20  return new ReadableStream({
21    start(c) {
22      c.close();
23    }
24  });
25});
26
27templatedRSClosedReader('ReadableStream reader (closed before getting reader)', () => {
28  let controller;
29  const stream = new ReadableStream({
30    start(c) {
31      controller = c;
32    }
33  });
34  controller.close();
35  const result = streamAndDefaultReader(stream);
36  return result;
37});
38
39templatedRSClosedReader('ReadableStream reader (closed after getting reader)', () => {
40  let controller;
41  const stream = new ReadableStream({
42    start(c) {
43      controller = c;
44    }
45  });
46  const result = streamAndDefaultReader(stream);
47  controller.close();
48  return result;
49});
50
51templatedRSClosed('ReadableStream (closed via cancel)', () => {
52  const stream = new ReadableStream();
53  stream.cancel();
54  return stream;
55});
56
57templatedRSClosedReader('ReadableStream reader (closed via cancel after getting reader)', () => {
58  const stream = new ReadableStream();
59  const result = streamAndDefaultReader(stream);
60  result.reader.cancel();
61  return result;
62});
63
64templatedRSErrored('ReadableStream (errored via call in start)', () => {
65  return new ReadableStream({
66    start(c) {
67      c.error(theError);
68    }
69  });
70}, theError);
71
72templatedRSErroredSyncOnly('ReadableStream (errored via call in start)', () => {
73  return new ReadableStream({
74    start(c) {
75      c.error(theError);
76    }
77  });
78}, theError);
79
80templatedRSErrored('ReadableStream (errored via returning a rejected promise in start)', () => {
81  return new ReadableStream({
82    start() {
83      return Promise.reject(theError);
84    }
85  });
86}, theError);
87
88templatedRSErroredReader('ReadableStream (errored via returning a rejected promise in start) reader', () => {
89  return streamAndDefaultReader(new ReadableStream({
90    start() {
91      return Promise.reject(theError);
92    }
93  }));
94}, theError);
95
96templatedRSErroredReader('ReadableStream reader (errored before getting reader)', () => {
97  let controller;
98  const stream = new ReadableStream({
99    start(c) {
100      controller = c;
101    }
102  });
103  controller.error(theError);
104  return streamAndDefaultReader(stream);
105}, theError);
106
107templatedRSErroredReader('ReadableStream reader (errored after getting reader)', () => {
108  let controller;
109  const result = streamAndDefaultReader(new ReadableStream({
110    start(c) {
111      controller = c;
112    }
113  }));
114  controller.error(theError);
115  return result;
116}, theError);
117
118templatedRSTwoChunksOpenReader('ReadableStream (two chunks enqueued, still open) reader', () => {
119  return streamAndDefaultReader(new ReadableStream({
120    start(c) {
121      c.enqueue(chunks[0]);
122      c.enqueue(chunks[1]);
123    }
124  }));
125}, chunks);
126
127templatedRSTwoChunksClosedReader('ReadableStream (two chunks enqueued, then closed) reader', () => {
128  let doClose;
129  const stream = new ReadableStream({
130    start(c) {
131      c.enqueue(chunks[0]);
132      c.enqueue(chunks[1]);
133      doClose = c.close.bind(c);
134    }
135  });
136  const result = streamAndDefaultReader(stream);
137  doClose();
138  return result;
139}, chunks);
140
141function streamAndDefaultReader(stream) {
142  return { stream, reader: stream.getReader() };
143}
144