Lines Matching refs:reader
4 // For readable stream tests, the factory should return the stream. For reader tests, the factory should return a
5 // { stream, reader } object. (You can use this to vary the time at which you acquire a reader.)
73 const reader = rs.getReader();
74 reader.releaseLock();
76 const reader2 = rs.getReader(); // Getting a second reader should not throw.
79 rs.getReader(); // Getting a third reader should not throw.
89 assert_throws_js(TypeError, () => rs.getReader(), 'getting a second reader should throw');
90 assert_throws_js(TypeError, () => rs.getReader(), 'getting a third reader should throw');
92 }, label + ': should not be able to acquire a second reader if we don\'t release the first one');
101 const reader = rs.getReader();
104 promise_rejects_exactly(t, error, reader.closed),
105 promise_rejects_exactly(t, error, reader.read())
108 }, label + ': getReader() should return a reader that acts errored');
113 const reader = rs.getReader();
116 promise_rejects_exactly(t, error, reader.read()),
117 promise_rejects_exactly(t, error, reader.read()),
118 promise_rejects_exactly(t, error, reader.closed)
137 const reader = rs.getReader(); // Calling getReader() twice does not throw (the stream is not locked).
139 return promise_rejects_exactly(t, error, reader.closed);
141 }, label + ': should be able to obtain a second reader, with the correct closed promise');
148 assert_throws_js(TypeError, () => rs.getReader(), 'getting a second reader should throw a TypeError');
149 assert_throws_js(TypeError, () => rs.getReader(), 'getting a third reader should throw a TypeError');
171 const reader = rs.getReader();
172 const cancelPromise1 = reader.cancel();
173 const cancelPromise2 = reader.cancel();
182 }, label + ': reader cancel() should return a distinct rejected promise each time');
190 const reader = factory().reader;
192 assert_true('closed' in reader, 'has a closed property');
193 assert_equals(typeof reader.closed.then, 'function', 'closed property is thenable');
195 assert_equals(typeof reader.cancel, 'function', 'has a cancel method');
196 assert_equals(typeof reader.read, 'function', 'has a read method');
197 assert_equals(typeof reader.releaseLock, 'function', 'has a releaseLock method');
211 const reader = factory().reader;
213 reader.read().then(
224 const reader = factory().reader;
226 reader.read().then(
231 reader.read().then(
242 const reader = factory().reader;
243 assert_not_equals(reader.read(), reader.read(), 'the promises returned should be distinct');
258 const reader = streamAndReader.reader;
260 const read1 = reader.read();
261 const read2 = reader.read();
262 const closed = reader.closed;
264 reader.releaseLock();
278 const reader = factory().reader;
279 reader.releaseLock();
282 promise_rejects_js(t, TypeError, reader.read()),
283 promise_rejects_js(t, TypeError, reader.read())
290 const reader = factory().reader;
292 const closedBefore = reader.closed;
293 reader.releaseLock();
294 const closedAfter = reader.closed;
306 const reader = streamAndReader.reader;
308 reader.releaseLock();
315 const reader = factory().reader;
316 reader.cancel();
318 return reader.read().then(r => {
319 assert_object_equals(r, { value: undefined, done: true }, 'read()ing from the reader should give a done result');
322 }, label + ': canceling via the reader should cause the reader to act closed');
337 const reader = factory().reader;
339 return reader.read().then(v => {
347 const reader = factory().reader;
350 reader.read().then(v => {
353 reader.read().then(v => {
362 const reader = factory().reader;
364 return reader.read().then(() => reader.read()).then(v => {
372 const reader = factory().reader;
374 return reader.closed.then(v => assert_equals(v, undefined, 'reader closed should fulfill with undefined'));
380 const reader = factory().reader;
382 const closedBefore = reader.closed;
383 reader.releaseLock();
384 const closedAfter = reader.closed;
389 closedBefore.then(v => assert_equals(v, undefined, 'reader.closed acquired before release should fulfill')),
397 const reader = factory().reader;
398 const cancelPromise1 = reader.cancel();
399 const cancelPromise2 = reader.cancel();
400 const closedReaderPromise = reader.closed;
403 assert_not_equals(cancelPromise1, closedReaderPromise, 'cancel() promise 1 should be distinct from reader.closed');
404 assert_not_equals(cancelPromise2, closedReaderPromise, 'cancel() promise 2 should be distinct from reader.closed');
419 const reader = factory().reader;
420 return promise_rejects_exactly(t, error, reader.closed);
426 const reader = factory().reader;
427 const closedBefore = reader.closed;
430 reader.releaseLock();
432 const closedAfter = reader.closed;
442 const reader = factory().reader;
443 return promise_rejects_exactly(t, error, reader.read());
453 const reader = factory().reader;
456 reader.read().then(r => {
459 reader.read().then(r => {
468 const reader = factory().reader;
470 return reader.read().then(r => {
473 return reader.read().then(r2 => {
482 const reader = factory().reader;
483 assert_not_equals(reader.read(), reader.read(), 'the promises returned should be distinct');
489 const reader = factory().reader;
491 const promise1 = reader.closed.then(v => {
492 assert_equals(v, undefined, 'reader closed should fulfill with undefined');
495 const promise2 = reader.read().then(r => {
500 reader.cancel();
502 const promise3 = reader.read().then(r => {
517 const reader = factory().reader;
520 reader.read().then(r => {
523 reader.read().then(r => {
526 reader.read().then(r => {
535 const reader = factory().reader;
537 return reader.read().then(r => {
540 return reader.read().then(r2 => {
543 return reader.read().then(r3 => {
555 const reader = streamAndReader.reader;
559 const promise = reader.closed.then(v => {
560 assert_equals(v, undefined, 'reader closed should fulfill with undefined');
564 reader.read();
565 reader.read();
570 ': draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true');
576 const reader = streamAndReader.reader;
578 const promise = reader.closed.then(() => {
580 reader.releaseLock(); // Releasing the lock after reader closed should not throw.
584 reader.read();
585 reader.read();
593 const reader = factory().reader;
595 reader.releaseLock();
598 promise_rejects_js(t, TypeError, reader.read()),
599 promise_rejects_js(t, TypeError, reader.read()),
600 promise_rejects_js(t, TypeError, reader.read())
609 const reader = streamAndReader.reader;
611 const readerClosed = reader.closed;
613 assert_equals(reader.closed, readerClosed, 'accessing reader.closed twice in succession gives the same value');
615 const promise = reader.read().then(() => {
616 assert_equals(reader.closed, readerClosed, 'reader.closed is the same after read() fulfills');
618 reader.releaseLock();
620 assert_equals(reader.closed, readerClosed, 'reader.closed is the same after releasing the lock');
626 assert_equals(reader.closed, readerClosed, 'reader.closed is the same after calling read()');
630 }, label + ': reader\'s closed property always returns the same promise');