Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use ReadableStreamDefaultControllerGetDesiredSize method in wpt

Best JavaScript code snippet using wpt

transform-stream.js

Source:transform-stream.js

...35    transformStream._readableClosed = true;36    TransformStreamErrorIfNeeded(transformStream, e);37    throw transformStream._storedError;38  }39  const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);40  const maybeBackpressure = desiredSize <= 0;41  if (maybeBackpressure === true && transformStream._backpressure === false) {42    // This allows pull() again. When desiredSize is 0, it's possible that a pull() will happen immediately (but43    // asynchronously) after this because of pending read()s and set _backpressure back to false.44    //45    // If pull() could be called from inside enqueue(), then this logic would be wrong. This cannot happen46    // because there is always a promise pending from start() or pull() when _backpressure is false.47    TransformStreamSetBackpressure(transformStream, true);48  }49}50function TransformStreamError(transformStream, e) {51  if (transformStream._errored === true) {52    throw new TypeError('TransformStream is already errored');53  }54  TransformStreamErrorInternal(transformStream, e);55}56// Abstract operations.57function TransformStreamCloseReadableInternal(transformStream) {58  assert(transformStream._errored === false);59  assert(transformStream._readableClosed === false);60  try {61    ReadableStreamDefaultControllerClose(transformStream._readableController);62  } catch (e) {63    assert(false);64  }65  transformStream._readableClosed = true;66}67function TransformStreamErrorIfNeeded(transformStream, e) {68  if (transformStream._errored === false) {69    TransformStreamErrorInternal(transformStream, e);70  }71}72function TransformStreamErrorInternal(transformStream, e) {73  // console.log('TransformStreamErrorInternal()');74  assert(transformStream._errored === false);75  transformStream._errored = true;76  transformStream._storedError = e;77  if (transformStream._writableDone === false) {78    WritableStreamDefaultControllerError(transformStream._writableController, e);79  }80  if (transformStream._readableClosed === false) {81    ReadableStreamDefaultControllerError(transformStream._readableController, e);82  }83}84// Used for preventing the next write() call on TransformStreamSink until there85// is no longer backpressure.86function TransformStreamReadableReadyPromise(transformStream) {87  assert(transformStream._backpressureChangePromise !== undefined,88         '_backpressureChangePromise should have been initialized');89  if (transformStream._backpressure === false) {90    return Promise.resolve();91  }92  assert(transformStream._backpressure === true, '_backpressure should have been initialized');93  return transformStream._backpressureChangePromise;94}95function TransformStreamSetBackpressure(transformStream, backpressure) {96  // console.log(`TransformStreamSetBackpressure(${backpressure})`);97  // Passes also when called during construction.98  assert(transformStream._backpressure !== backpressure,99         'TransformStreamSetBackpressure() should be called only when backpressure is changed');100  if (transformStream._backpressureChangePromise !== undefined) {101    // The fulfillment value is just for a sanity check.102    transformStream._backpressureChangePromise_resolve(backpressure);103  }104  transformStream._backpressureChangePromise = new Promise(resolve => {105    transformStream._backpressureChangePromise_resolve = resolve;106  });107  transformStream._backpressureChangePromise.then(resolution => {108    assert(resolution !== backpressure,109           '_backpressureChangePromise should be fulfilled only when backpressure is changed');110  });111  transformStream._backpressure = backpressure;112}113function TransformStreamDefaultTransform(chunk, transformStreamController) {114  const transformStream = transformStreamController._controlledTransformStream;115  TransformStreamEnqueueToReadable(transformStream, chunk);116  return Promise.resolve();117}118function TransformStreamTransform(transformStream, chunk) {119  // console.log('TransformStreamTransform()');120  assert(transformStream._errored === false);121  assert(transformStream._transforming === false);122  assert(transformStream._backpressure === false);123  transformStream._transforming = true;124  const transformer = transformStream._transformer;125  const controller = transformStream._transformStreamController;126  const transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller],127                             TransformStreamDefaultTransform, [chunk, controller]);128  return transformPromise.then(129    () => {130      transformStream._transforming = false;131      return TransformStreamReadableReadyPromise(transformStream);132    },133    e => {134      TransformStreamErrorIfNeeded(transformStream, e);135      return Promise.reject(e);136    });137}138function IsTransformStreamDefaultController(x) {139  if (!typeIsObject(x)) {140    return false;141  }142  if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {143    return false;144  }145  return true;146}147function IsTransformStream(x) {148  if (!typeIsObject(x)) {149    return false;150  }151  if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {152    return false;153  }154  return true;155}156class TransformStreamSink {157  constructor(transformStream, startPromise) {158    this._transformStream = transformStream;159    this._startPromise = startPromise;160  }161  start(c) {162    const transformStream = this._transformStream;163    transformStream._writableController = c;164    return this._startPromise.then(() => TransformStreamReadableReadyPromise(transformStream));165  }166  write(chunk) {167    // console.log('TransformStreamSink.write()');168    const transformStream = this._transformStream;169    return TransformStreamTransform(transformStream, chunk);170  }171  abort() {172    const transformStream = this._transformStream;173    transformStream._writableDone = true;174    TransformStreamErrorInternal(transformStream, new TypeError('Writable side aborted'));175  }176  close() {177    // console.log('TransformStreamSink.close()');178    const transformStream = this._transformStream;179    assert(transformStream._transforming === false);180    transformStream._writableDone = true;181    const flushPromise = PromiseInvokeOrNoop(transformStream._transformer,182                         'flush', [transformStream._transformStreamController]);183    // Return a promise that is fulfilled with undefined on success.184    return flushPromise.then(() => {185      if (transformStream._errored === true) {186        return Promise.reject(transformStream._storedError);187      }188      if (transformStream._readableClosed === false) {189        TransformStreamCloseReadableInternal(transformStream);190      }191      return Promise.resolve();192    }).catch(r => {193      TransformStreamErrorIfNeeded(transformStream, r);194      return Promise.reject(transformStream._storedError);195    });196  }197}198class TransformStreamSource {199  constructor(transformStream, startPromise) {200    this._transformStream = transformStream;201    this._startPromise = startPromise;202  }203  start(c) {204    const transformStream = this._transformStream;205    transformStream._readableController = c;206    return this._startPromise.then(() => {207      // Prevent the first pull() call until there is backpressure.208      assert(transformStream._backpressureChangePromise !== undefined,209             '_backpressureChangePromise should have been initialized');210      if (transformStream._backpressure === true) {211        return Promise.resolve();212      }213      assert(transformStream._backpressure === false, '_backpressure should have been initialized');214      return transformStream._backpressureChangePromise;215    });216  }217  pull() {218    // console.log('TransformStreamSource.pull()');219    const transformStream = this._transformStream;220    // Invariant. Enforced by the promises returned by start() and pull().221    assert(transformStream._backpressure === true, 'pull() should be never called while _backpressure is false');222    assert(transformStream._backpressureChangePromise !== undefined,223           '_backpressureChangePromise should have been initialized');224    TransformStreamSetBackpressure(transformStream, false);225    // Prevent the next pull() call until there is backpressure.226    return transformStream._backpressureChangePromise;227  }228  cancel() {229    const transformStream = this._transformStream;230    transformStream._readableClosed = true;231    TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));232  }233}234class TransformStreamDefaultController {235  constructor(transformStream) {236    if (IsTransformStream(transformStream) === false) {237      throw new TypeError('TransformStreamDefaultController can only be ' +238                          'constructed with a TransformStream instance');239    }240    if (transformStream._transformStreamController !== undefined) {241      throw new TypeError('TransformStreamDefaultController instances can ' +242                          'only be created by the TransformStream constructor');243    }244    this._controlledTransformStream = transformStream;245  }246  get desiredSize() {247    if (IsTransformStreamDefaultController(this) === false) {248      throw defaultControllerBrandCheckException('desiredSize');249    }250    const transformStream = this._controlledTransformStream;251    const readableController = transformStream._readableController;252    return ReadableStreamDefaultControllerGetDesiredSize(readableController);253  }254  enqueue(chunk) {255    if (IsTransformStreamDefaultController(this) === false) {256      throw defaultControllerBrandCheckException('enqueue');257    }258    TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);259  }260  close() {261    if (IsTransformStreamDefaultController(this) === false) {262      throw defaultControllerBrandCheckException('close');263    }264    TransformStreamCloseReadable(this._controlledTransformStream);265  }266  error(reason) {267    if (IsTransformStreamDefaultController(this) === false) {268      throw defaultControllerBrandCheckException('error');269    }270    TransformStreamError(this._controlledTransformStream, reason);271  }272}273class TransformStream {274  constructor(transformer = {}) {275    this._transformer = transformer;276    const { readableStrategy, writableStrategy } = transformer;277    this._transforming = false;278    this._errored = false;279    this._storedError = undefined;280    this._writableController = undefined;281    this._readableController = undefined;282    this._transformStreamController = undefined;283    this._writableDone = false;284    this._readableClosed = false;285    this._backpressure = undefined;286    this._backpressureChangePromise = undefined;287    this._backpressureChangePromise_resolve = undefined;288    this._transformStreamController = new TransformStreamDefaultController(this);289    let startPromise_resolve;290    const startPromise = new Promise(resolve => {291      startPromise_resolve = resolve;292    });293    const source = new TransformStreamSource(this, startPromise);294    this._readable = new ReadableStream(source, readableStrategy);295    const sink = new TransformStreamSink(this, startPromise);296    this._writable = new WritableStream(sink, writableStrategy);297    assert(this._writableController !== undefined);298    assert(this._readableController !== undefined);299    const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(this._readableController);300    // Set _backpressure based on desiredSize. As there is no read() at this point, we can just interpret301    // desiredSize being non-positive as backpressure.302    TransformStreamSetBackpressure(this, desiredSize <= 0);303    const transformStream = this;304    const startResult = InvokeOrNoop(transformer, 'start',305                          [transformStream._transformStreamController]);306    startPromise_resolve(startResult);307    startPromise.catch(e => {308      // The underlyingSink and underlyingSource will error the readable and writable ends on their own.309      if (transformStream._errored === false) {310        transformStream._errored = true;311        transformStream._storedError = e;312      }313    });...

transform-stream-polyfill.js

Source:transform-stream-polyfill.js

...34    transformStream._readableClosed = true;35    TransformStreamErrorIfNeeded(transformStream, e);36    throw transformStream._storedError;37  }38  const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);39  const maybeBackpressure = desiredSize <= 0;40  if (maybeBackpressure === true && transformStream._backpressure === false) {41    // This allows pull() again. When desiredSize is 0, it's possible that a pull() will happen immediately (but42    // asynchronously) after this because of pending read()s and set _backpressure back to false.43    //44    // If pull() could be called from inside enqueue(), then this logic would be wrong. This cannot happen45    // because there is always a promise pending from start() or pull() when _backpressure is false.46    TransformStreamSetBackpressure(transformStream, true);47  }48}49function TransformStreamError(transformStream, e) {50  if (transformStream._errored === true) {51    throw new TypeError('TransformStream is already errored');52  }53  TransformStreamErrorInternal(transformStream, e);54}55// Abstract operations.56function TransformStreamCloseReadableInternal(transformStream) {57  ReadableStreamDefaultControllerClose(transformStream._readableController);58  transformStream._readableClosed = true;59}60function TransformStreamErrorIfNeeded(transformStream, e) {61  if (transformStream._errored === false) {62    TransformStreamErrorInternal(transformStream, e);63  }64}65function TransformStreamErrorInternal(transformStream, e) {66  transformStream._errored = true;67  transformStream._storedError = e;68  if (transformStream._writableDone === false) {69    WritableStreamDefaultControllerError(transformStream._writableController, e);70  }71  if (transformStream._readableClosed === false) {72    ReadableStreamDefaultControllerError(transformStream._readableController, e);73  }74}75// Used for preventing the next write() call on TransformStreamSink until there76// is no longer backpressure.77function TransformStreamReadableReadyPromise(transformStream) {78  if (transformStream._backpressure === false) {79    return Promise.resolve();80  }81  return transformStream._backpressureChangePromise;82}83function TransformStreamSetBackpressure(transformStream, backpressure) {84  // Passes also when called during construction.85  if (transformStream._backpressureChangePromise !== undefined) {86    // The fulfillment value is just for a sanity check.87    transformStream._backpressureChangePromise_resolve(backpressure);88  }89  transformStream._backpressureChangePromise = new Promise(resolve => {90    transformStream._backpressureChangePromise_resolve = resolve;91  });92  transformStream._backpressureChangePromise.then(resolution => {93  });94  transformStream._backpressure = backpressure;95}96function TransformStreamDefaultTransform(chunk, transformStreamController) {97  const transformStream = transformStreamController._controlledTransformStream;98  TransformStreamEnqueueToReadable(transformStream, chunk);99  return Promise.resolve();100}101function TransformStreamTransform(transformStream, chunk) {102  transformStream._transforming = true;103  const transformer = transformStream._transformer;104  const controller = transformStream._transformStreamController;105  const transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller],106                             TransformStreamDefaultTransform, [chunk, controller]);107  return transformPromise.then(108    () => {109      transformStream._transforming = false;110      return TransformStreamReadableReadyPromise(transformStream);111    },112    e => {113      TransformStreamErrorIfNeeded(transformStream, e);114      return Promise.reject(e);115    });116}117function IsTransformStreamDefaultController(x) {118  if (!typeIsObject(x)) {119    return false;120  }121  if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {122    return false;123  }124  return true;125}126function IsTransformStream(x) {127  if (!typeIsObject(x)) {128    return false;129  }130  if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {131    return false;132  }133  return true;134}135class TransformStreamSink {136  constructor(transformStream, startPromise) {137    this._transformStream = transformStream;138    this._startPromise = startPromise;139  }140  start(c) {141    const transformStream = this._transformStream;142    transformStream._writableController = c;143    return this._startPromise.then(() => TransformStreamReadableReadyPromise(transformStream));144  }145  write(chunk) {146    const transformStream = this._transformStream;147    return TransformStreamTransform(transformStream, chunk);148  }149  abort() {150    const transformStream = this._transformStream;151    transformStream._writableDone = true;152    TransformStreamErrorInternal(transformStream, new TypeError('Writable side aborted'));153  }154  close() {155    const transformStream = this._transformStream;156    transformStream._writableDone = true;157    const flushPromise = PromiseInvokeOrNoop(transformStream._transformer,158                         'flush', [transformStream._transformStreamController]);159    // Return a promise that is fulfilled with undefined on success.160    return flushPromise.then(() => {161      if (transformStream._errored === true) {162        return Promise.reject(transformStream._storedError);163      }164      if (transformStream._readableClosed === false) {165        TransformStreamCloseReadableInternal(transformStream);166      }167      return Promise.resolve();168    }).catch(r => {169      TransformStreamErrorIfNeeded(transformStream, r);170      return Promise.reject(transformStream._storedError);171    });172  }173}174class TransformStreamSource {175  constructor(transformStream, startPromise) {176    this._transformStream = transformStream;177    this._startPromise = startPromise;178  }179  start(c) {180    const transformStream = this._transformStream;181    transformStream._readableController = c;182    return this._startPromise.then(() => {183      // Prevent the first pull() call until there is backpressure.184      if (transformStream._backpressure === true) {185        return Promise.resolve();186      }187      return transformStream._backpressureChangePromise;188    });189  }190  pull() {191    const transformStream = this._transformStream;192    // Invariant. Enforced by the promises returned by start() and pull().193    TransformStreamSetBackpressure(transformStream, false);194    // Prevent the next pull() call until there is backpressure.195    return transformStream._backpressureChangePromise;196  }197  cancel() {198    const transformStream = this._transformStream;199    transformStream._readableClosed = true;200    TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));201  }202}203class TransformStreamDefaultController {204  constructor(transformStream) {205    if (IsTransformStream(transformStream) === false) {206      throw new TypeError('TransformStreamDefaultController can only be ' +207                          'constructed with a TransformStream instance');208    }209    if (transformStream._transformStreamController !== undefined) {210      throw new TypeError('TransformStreamDefaultController instances can ' +211                          'only be created by the TransformStream constructor');212    }213    this._controlledTransformStream = transformStream;214  }215  get desiredSize() {216    if (IsTransformStreamDefaultController(this) === false) {217      throw defaultControllerBrandCheckException('desiredSize');218    }219    const transformStream = this._controlledTransformStream;220    const readableController = transformStream._readableController;221    return ReadableStreamDefaultControllerGetDesiredSize(readableController);222  }223  enqueue(chunk) {224    if (IsTransformStreamDefaultController(this) === false) {225      throw defaultControllerBrandCheckException('enqueue');226    }227    TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);228  }229  close() {230    if (IsTransformStreamDefaultController(this) === false) {231      throw defaultControllerBrandCheckException('close');232    }233    TransformStreamCloseReadable(this._controlledTransformStream);234  }235  error(reason) {236    if (IsTransformStreamDefaultController(this) === false) {237      throw defaultControllerBrandCheckException('error');238    }239    TransformStreamError(this._controlledTransformStream, reason);240  }241}242class TransformStream {243  constructor(transformer = {}) {244    this._transformer = transformer;245    const { readableStrategy, writableStrategy } = transformer;246    this._transforming = false;247    this._errored = false;248    this._storedError = undefined;249    this._writableController = undefined;250    this._readableController = undefined;251    this._transformStreamController = undefined;252    this._writableDone = false;253    this._readableClosed = false;254    this._backpressure = undefined;255    this._backpressureChangePromise = undefined;256    this._backpressureChangePromise_resolve = undefined;257    this._transformStreamController = new TransformStreamDefaultController(this);258    let startPromise_resolve;259    const startPromise = new Promise(resolve => {260      startPromise_resolve = resolve;261    });262    const source = new TransformStreamSource(this, startPromise);263    this._readable = new ReadableStream(source, readableStrategy);264    const sink = new TransformStreamSink(this, startPromise);265    this._writable = new WritableStream(sink, writableStrategy);266    const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(this._readableController);267    // Set _backpressure based on desiredSize. As there is no read() at this point, we can just interpret268    // desiredSize being non-positive as backpressure.269    TransformStreamSetBackpressure(this, desiredSize <= 0);270    const transformStream = this;271    const startResult = InvokeOrNoop(transformer, 'start',272                          [transformStream._transformStreamController]);273    startPromise_resolve(startResult);274    startPromise.catch(e => {275      // The underlyingSink and underlyingSource will error the readable and writable ends on their own.276      if (transformStream._errored === false) {277        transformStream._errored = true;278        transformStream._storedError = e;279      }280    });281  }282  get readable() {283    if (IsTransformStream(this) === false) {284      throw streamBrandCheckException('readable');285    }286    return this._readable;287  }288  get writable() {289    if (IsTransformStream(this) === false) {290      throw streamBrandCheckException('writable');291    }292    return this._writable;293  }294}295// Helper functions for the TransformStreamDefaultController.296function defaultControllerBrandCheckException(name) {297  return new TypeError(298    `TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);299}300// Stubs for abstract operations used from ReadableStream and WritableStream.301function ReadableStreamDefaultControllerEnqueue(controller, chunk) {302  controller.enqueue(chunk);303}304function ReadableStreamDefaultControllerGetDesiredSize(controller) {305  return controller.desiredSize;306}307function ReadableStreamDefaultControllerClose(controller) {308  controller.close();309}310function ReadableStreamDefaultControllerError(controller, e) {311  controller.error(e);312}313function WritableStreamDefaultControllerError(controller, e) {314  controller.error(e);315}316// Helper functions for the TransformStream.317function streamBrandCheckException(name) {318  return new TypeError(...

transform_stream_default_controller.ts

Source:transform_stream_default_controller.ts

1// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.2import {3  FlushAlgorithm,4  isTransformStreamDefaultController,5  readableStreamDefaultControllerGetDesiredSize,6  setFunctionName,7  TransformAlgorithm,8  transformStreamDefaultControllerEnqueue,9  transformStreamDefaultControllerError,10  transformStreamDefaultControllerTerminate,11} from "./internals.ts";12import { ReadableStreamDefaultControllerImpl } from "./readable_stream_default_controller.ts";13import * as sym from "./symbols.ts";14import { TransformStreamImpl } from "./transform_stream.ts";15import { customInspect } from "../console.ts";16// eslint-disable-next-line @typescript-eslint/no-explicit-any17export class TransformStreamDefaultControllerImpl<I = any, O = any>18  implements TransformStreamDefaultController<O> {19  [sym.controlledTransformStream]: TransformStreamImpl<I, O>;20  [sym.flushAlgorithm]: FlushAlgorithm;21  [sym.transformAlgorithm]: TransformAlgorithm<I>;22  private constructor() {23    throw new TypeError(24      "TransformStreamDefaultController's constructor cannot be called."25    );26  }27  get desiredSize(): number | null {28    if (!isTransformStreamDefaultController(this)) {29      throw new TypeError("Invalid TransformStreamDefaultController.");30    }31    const readableController = this[sym.controlledTransformStream][32      sym.readable33    ][sym.readableStreamController];34    return readableStreamDefaultControllerGetDesiredSize(35      readableController as ReadableStreamDefaultControllerImpl<O>36    );37  }38  enqueue(chunk: O): void {39    if (!isTransformStreamDefaultController(this)) {40      throw new TypeError("Invalid TransformStreamDefaultController.");41    }42    transformStreamDefaultControllerEnqueue(this, chunk);43  }44  // eslint-disable-next-line @typescript-eslint/no-explicit-any45  error(reason?: any): void {46    if (!isTransformStreamDefaultController(this)) {47      throw new TypeError("Invalid TransformStreamDefaultController.");48    }49    transformStreamDefaultControllerError(this, reason);50  }51  terminate(): void {52    if (!isTransformStreamDefaultController(this)) {53      throw new TypeError("Invalid TransformStreamDefaultController.");54    }55    transformStreamDefaultControllerTerminate(this);56  }57  [customInspect](): string {58    return `${this.constructor.name} { desiredSize: ${String(59      this.desiredSize60    )} }`;61  }62}63setFunctionName(64  TransformStreamDefaultControllerImpl,65  "TransformStreamDefaultController"...

Using AI Code Generation

1import { ReadableStream, ReadableStreamDefaultControllerGetDesiredSize } from 'streams';2const rs = new ReadableStream({3  start(controller) {4    controller.enqueue('a');5    controller.enqueue('b');6    controller.enqueue('c');7    console.log(ReadableStreamDefaultControllerGetDesiredSize(controller));8  }9});10rs.getReader().read().then(result => {11  console.log(result);12  return rs.getReader().read();13}).then(result => {14  console.log(result);15  return rs.getReader().read();16}).then(result => {17  console.log(result);18  return rs.getReader().read();19}).then(result => {20  console.log(result);21});22import { ReadableStream } from 'streams';23const rs = new ReadableStream({24  start(controller) {25    controller.enqueue('a');26    controller.enqueue('b');27    controller.enqueue('c');28    console.log(controller.desiredSize);29  }30});31rs.getReader().read().then(result => {32  console.log(result);33  return rs.getReader().read();34}).then(result => {35  console.log(result);36  return rs.getReader().read();37}).then(result => {38  console.log(result);39  return rs.getReader().read();40}).then(result => {41  console.log(result);42});43import { ReadableStream } from 'streams';44const rs = new ReadableStream({45  start(controller) {46    controller.enqueue('a');47    controller.enqueue('b');48    controller.enqueue('c');49    console.log(controller.desiredSize);

Using AI Code Generation

1test(() => {2  let rs = new ReadableStream({3    start(controller) {4      assert_equals(controller.desiredSize, 1);5      controller.enqueue('a');6      assert_equals(controller.desiredSize, 0);7      controller.enqueue('b');8      assert_equals(controller.desiredSize, -1);9      controller.close();10      assert_equals(controller.desiredSize, 0);11    }12  });13}, 'ReadableStreamDefaultController.desiredSize should be correct');14test(() => {15  let rs = new ReadableStream({16    start(controller) {17      controller.close();18      assert_throws(new TypeError(), () => controller.close());19    }20  });21}, 'ReadableStreamDefaultController.close should throw if the stream is already closed');22test(() => {23  let rs = new ReadableStream({24    start(controller) {25      controller.enqueue('a');26      assert_throws(new TypeError(), () => controller.enqueue('b'));27    }28  });29}, 'ReadableStreamDefaultController.enqueue should throw if the stream is already closed');30test(() => {31  let rs = new ReadableStream({32    start(controller) {33      controller.error();34      assert_throws(new TypeError(), () => controller.error());35    }36  });37}, 'ReadableStreamDefaultController.error should throw if the stream is already errored');38test(() => {39  let rs = new ReadableStream({40    start(controller) {41      controller.error();42      assert_throws(new TypeError(), () => controller.error());43    }44  });45}, 'ReadableStreamDefaultController.error should throw if the stream is already errored');46test(() => {47  let rs = new ReadableStream({48    start(controller) {49      controller.error();50      assert_throws(new TypeError(), () => controller.error());51    }52  });53}, 'ReadableStreamDefaultController.error should throw if the stream is already errored');

Using AI Code Generation

1test(function() {2  const rs = new ReadableStream({3    start(controller) {4      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');5    },6  });7}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');8test(function() {9  const rs = new ReadableStream({10    start(controller) {11      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');12    },13  });14}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');15test(function() {16  const rs = new ReadableStream({17    start(controller) {18      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');19    },20  });21}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');22test(function() {23  const rs = new ReadableStream({24    start(controller) {25      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');26    },27  });28}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');29test(function() {30  const rs = new ReadableStream({31    start(controller) {32      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');33    },34  });35}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');36test(function() {37  const rs = new ReadableStream({38    start(controller) {39      assert_equals(controller.desiredSize, 1, 'desiredSize should be 1');40    },41  });42}, 'ReadableStreamDefaultControllerGetDesiredSize method should return the desired size');43test(function() {

Using AI Code Generation

1  var rs = new ReadableStream({2    start(c) {3      var desiredSize = c.desiredSize;4      assert_equals(desiredSize, 1, 'The initial desired size should be 1');5    }6  });7  var reader = rs.getReader();8  var chunk = new Uint8Array([0x61]);9  reader.read().then(function(result) {10    assert_equals(result.value, chunk, 'The chunk read should be the same one written');11    assert_false(result.done, 'done');12  });13  reader.releaseLock();14  rs.cancel();15  rs = new ReadableStream({16    start(c) {17      c.enqueue(chunk);18      var desiredSize = c.desiredSize;19      assert_equals(desiredSize, 0, 'The desired size should be 0 after enqueueing a chunk');20    }21  });22  reader = rs.getReader();23  reader.read().then(function(result) {24    assert_equals(result.value, chunk, 'The chunk read should be the same one written');25    assert_false(result.done, 'done');26  });27  reader.releaseLock();28  rs.cancel();29  rs = new ReadableStream({30    start(c) {31      c.enqueue(chunk);32      c.close();33      var desiredSize = c.desiredSize;34      assert_equals(desiredSize, 0, 'The desired size should be 0 after enqueueing a chunk and closing');35    }36  });37  reader = rs.getReader();38  reader.read().then(function(result) {39    assert_equals(result.value, chunk, 'The chunk read should be the same one written');40    assert_false(result.done, 'done');41  });42  reader.releaseLock();43  rs.cancel();44  rs = new ReadableStream({45    start(c) {46      c.enqueue(chunk);47      c.error();48      var desiredSize = c.desiredSize;49      assert_equals(desiredSize, 0, 'The desired size should be 0 after enqueueing a chunk and erroring');50    }51  });52  reader = rs.getReader();53  reader.read().then(function(result) {54    assert_equals(result.value, chunk, 'The chunk read should be the same one written');55    assert_false(result.done, 'done');56  });57  reader.releaseLock();58  rs.cancel();59  rs = new ReadableStream({60    start(c) {61      c.enqueue(chunk);62      c.error(new Error('boo'));

Using AI Code Generation

1var rs = new ReadableStream({2    start: function (controller) {3        controller.enqueue(new Uint8Array([0x01, 0x02]));4        controller.close();5    }6});7var reader = rs.getReader();8var controller = reader._readableStreamController;9var desiredSize = controller.desiredSize;10assert_equals(desiredSize, 2, 'The desired size must be 2');11reader.releaseLock();12var rs = new ReadableStream({13    start: function (controller) {14        controller.enqueue(new Uint8Array([0x01, 0x02]));15        controller.close();16    }17});18var reader = rs.getReader();19var controller = reader._readableStreamController;20var desiredSize = controller.desiredSize;21assert_equals(desiredSize, 2, 'The desired size must be 2');22reader.releaseLock();23var rs = new ReadableStream({24    start: function (controller) {25        controller.enqueue(new Uint8Array([0x01, 0x02]));26        controller.close();27    }28});29var reader = rs.getReader();30var controller = reader._readableStreamController;31var desiredSize = controller.desiredSize;32assert_equals(desiredSize, 2, 'The desired size must be 2');33reader.releaseLock();34var rs = new ReadableStream({35    start: function (controller) {

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.