tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

templated.any.js (3885B)

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