How to use defaultWriterReadyPromiseInitializeAsRejected method in wpt

Best JavaScript code snippet using wpt

writable-stream.ts

Source:writable-stream.ts

...403        defaultWriterReadyPromiseInitializeAsResolved(this);404      }405      defaultWriterClosedPromiseInitialize(this);406    } else if (state === 'erroring') {407      defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);408      defaultWriterClosedPromiseInitialize(this);409    } else if (state === 'closed') {410      defaultWriterReadyPromiseInitializeAsResolved(this);411      defaultWriterClosedPromiseInitializeAsResolved(this);412    } else {413      assert(state === 'errored');414      const storedError = stream._storedError;415      defaultWriterReadyPromiseInitializeAsRejected(this, storedError);416      defaultWriterClosedPromiseInitializeAsRejected(this, storedError);417    }418  }419  get closed(): Promise<void> {420    if (IsWritableStreamDefaultWriter(this) === false) {421      return Promise.reject(defaultWriterBrandCheckException('closed'));422    }423    return this._closedPromise;424  }425  get desiredSize(): number | null {426    if (IsWritableStreamDefaultWriter(this) === false) {427      throw defaultWriterBrandCheckException('desiredSize');428    }429    if (this._ownerWritableStream === undefined) {430      throw defaultWriterLockException('desiredSize');431    }432    return WritableStreamDefaultWriterGetDesiredSize(this);433  }434  get ready(): Promise<void> {435    if (IsWritableStreamDefaultWriter(this) === false) {436      return Promise.reject(defaultWriterBrandCheckException('ready'));437    }438    return this._readyPromise;439  }440  abort(reason: any): Promise<void> {441    if (IsWritableStreamDefaultWriter(this) === false) {442      return Promise.reject(defaultWriterBrandCheckException('abort'));443    }444    if (this._ownerWritableStream === undefined) {445      return Promise.reject(defaultWriterLockException('abort'));446    }447    return WritableStreamDefaultWriterAbort(this, reason);448  }449  close(): Promise<void> {450    if (IsWritableStreamDefaultWriter(this) === false) {451      return Promise.reject(defaultWriterBrandCheckException('close'));452    }453    const stream = this._ownerWritableStream;454    if (stream === undefined) {455      return Promise.reject(defaultWriterLockException('close'));456    }457    if (WritableStreamCloseQueuedOrInFlight(stream) === true) {458      return Promise.reject(new TypeError('cannot close an already-closing stream'));459    }460    return WritableStreamDefaultWriterClose(this);461  }462  releaseLock(): void {463    if (IsWritableStreamDefaultWriter(this) === false) {464      throw defaultWriterBrandCheckException('releaseLock');465    }466    const stream = this._ownerWritableStream;467    if (stream === undefined) {468      return;469    }470    assert(stream._writer !== undefined);471    WritableStreamDefaultWriterRelease(this);472  }473  write(chunk: W): Promise<void> {474    if (IsWritableStreamDefaultWriter(this) === false) {475      return Promise.reject(defaultWriterBrandCheckException('write'));476    }477    if (this._ownerWritableStream === undefined) {478      return Promise.reject(defaultWriterLockException('write to'));479    }480    return WritableStreamDefaultWriterWrite(this, chunk);481  }482}483// Abstract operations for the WritableStreamDefaultWriter.484function IsWritableStreamDefaultWriter<W>(x: any): x is WritableStreamDefaultWriter<W> {485  if (!typeIsObject(x)) {486    return false;487  }488  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {489    return false;490  }491  return true;492}493// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.494function WritableStreamDefaultWriterAbort(writer: WritableStreamDefaultWriter<any>, reason: any) {495  const stream = writer._ownerWritableStream;496  assert(stream !== undefined);497  return WritableStreamAbort(stream, reason);498}499function WritableStreamDefaultWriterClose(writer: WritableStreamDefaultWriter<any>): Promise<void> {500  const stream = writer._ownerWritableStream;501  assert(stream !== undefined);502  const state = stream._state;503  if (state === 'closed' || state === 'errored') {504    return Promise.reject(new TypeError(505      `The stream (in ${state} state) is not in the writable state and cannot be closed`));506  }507  assert(state === 'writable' || state === 'erroring');508  assert(WritableStreamCloseQueuedOrInFlight(stream) === false);509  const promise = new Promise<void>((resolve, reject) => {510    const closeRequest: CloseRequest = {511      _resolve: resolve,512      _reject: reject513    };514    stream._closeRequest = closeRequest;515  });516  if (stream._backpressure === true && state === 'writable') {517    defaultWriterReadyPromiseResolve(writer);518  }519  WritableStreamDefaultControllerClose(stream._writableStreamController);520  return promise;521}522function WritableStreamDefaultWriterCloseWithErrorPropagation(writer: WritableStreamDefaultWriter<any>): Promise<void> {523  const stream = writer._ownerWritableStream;524  assert(stream !== undefined);525  const state = stream._state;526  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {527    return Promise.resolve();528  }529  if (state === 'errored') {530    return Promise.reject(stream._storedError);531  }532  assert(state === 'writable' || state === 'erroring');533  return WritableStreamDefaultWriterClose(writer);534}535function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer: WritableStreamDefaultWriter<any>, error: any) {536  if (writer._closedPromiseState === 'pending') {537    defaultWriterClosedPromiseReject(writer, error);538  } else {539    defaultWriterClosedPromiseResetToRejected(writer, error);540  }541}542function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer: WritableStreamDefaultWriter<any>, error: any) {543  if (writer._readyPromiseState === 'pending') {544    defaultWriterReadyPromiseReject(writer, error);545  } else {546    defaultWriterReadyPromiseResetToRejected(writer, error);547  }548}549function WritableStreamDefaultWriterGetDesiredSize(writer: WritableStreamDefaultWriter<any>): number | null {550  const stream = writer._ownerWritableStream;551  const state = stream._state;552  if (state === 'errored' || state === 'erroring') {553    return null;554  }555  if (state === 'closed') {556    return 0;557  }558  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);559}560function WritableStreamDefaultWriterRelease(writer: WritableStreamDefaultWriter<any>) {561  const stream = writer._ownerWritableStream;562  assert(stream !== undefined);563  assert(stream._writer === writer);564  const releasedError = new TypeError(565    'Writer was released and can no longer be used to monitor the stream\'s closedness');566  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);567  // The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not568  // rejected until afterwards. This means that simply testing state will not work.569  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);570  stream._writer = undefined;571  writer._ownerWritableStream = undefined!;572}573function WritableStreamDefaultWriterWrite<W>(writer: WritableStreamDefaultWriter<W>, chunk: W): Promise<void> {574  const stream = writer._ownerWritableStream;575  assert(stream !== undefined);576  const controller = stream._writableStreamController;577  const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);578  if (stream !== writer._ownerWritableStream) {579    return Promise.reject(defaultWriterLockException('write to'));580  }581  const state = stream._state;582  if (state === 'errored') {583    return Promise.reject(stream._storedError);584  }585  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {586    return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));587  }588  if (state === 'erroring') {589    return Promise.reject(stream._storedError);590  }591  assert(state === 'writable');592  const promise = WritableStreamAddWriteRequest(stream);593  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);594  return promise;595}596interface WriteRecord<W> {597  chunk: W;598}599type QueueRecord<W> = WriteRecord<W> | 'close';600export type WritableStreamDefaultControllerType = WritableStreamDefaultController<any>;601class WritableStreamDefaultController<W = any> {602  /** @internal */603  _controlledWritableStream!: WritableStream<W>;604  /** @internal */605  _queue!: SimpleQueue<QueuePair<QueueRecord<W>>>;606  /** @internal */607  _queueTotalSize!: number;608  /** @internal */609  _started!: boolean;610  /** @internal */611  _strategySizeAlgorithm!: QueuingStrategySizeCallback<W>;612  /** @internal */613  _strategyHWM!: number;614  /** @internal */615  _writeAlgorithm!: (chunk: W) => Promise<void>;616  /** @internal */617  _closeAlgorithm!: () => Promise<void>;618  /** @internal */619  _abortAlgorithm!: (reason: any) => Promise<void>;620  /** @internal */621  constructor() {622    throw new TypeError('WritableStreamDefaultController cannot be constructed explicitly');623  }624  error(e: any) {625    if (IsWritableStreamDefaultController(this) === false) {626      throw new TypeError(627        'WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');628    }629    const state = this._controlledWritableStream._state;630    if (state !== 'writable') {631      // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so632      // just treat it as a no-op.633      return;634    }635    WritableStreamDefaultControllerError(this, e);636  }637  /** @internal */638  [AbortSteps](reason: any) {639    const result = this._abortAlgorithm(reason);640    WritableStreamDefaultControllerClearAlgorithms(this);641    return result;642  }643  /** @internal */644  [ErrorSteps]() {645    ResetQueue(this);646  }647}648// Abstract operations implementing interface required by the WritableStream.649function IsWritableStreamDefaultController<W>(x: any): x is WritableStreamDefaultController<W> {650  if (!typeIsObject(x)) {651    return false;652  }653  if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {654    return false;655  }656  return true;657}658function SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,659                                                 controller: WritableStreamDefaultController<W>,660                                                 startAlgorithm: () => void | PromiseLike<void>,661                                                 writeAlgorithm: (chunk: W) => Promise<void>,662                                                 closeAlgorithm: () => Promise<void>,663                                                 abortAlgorithm: (reason: any) => Promise<void>,664                                                 highWaterMark: number,665                                                 sizeAlgorithm: QueuingStrategySizeCallback<W>) {666  assert(IsWritableStream(stream) === true);667  assert(stream._writableStreamController === undefined);668  controller._controlledWritableStream = stream;669  stream._writableStreamController = controller;670  // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.671  controller._queue = undefined!;672  controller._queueTotalSize = undefined!;673  ResetQueue(controller);674  controller._started = false;675  controller._strategySizeAlgorithm = sizeAlgorithm;676  controller._strategyHWM = highWaterMark;677  controller._writeAlgorithm = writeAlgorithm;678  controller._closeAlgorithm = closeAlgorithm;679  controller._abortAlgorithm = abortAlgorithm;680  const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);681  WritableStreamUpdateBackpressure(stream, backpressure);682  const startResult = startAlgorithm();683  const startPromise = Promise.resolve(startResult);684  startPromise.then(685    () => {686      assert(stream._state === 'writable' || stream._state === 'erroring');687      controller._started = true;688      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);689    },690    r => {691      assert(stream._state === 'writable' || stream._state === 'erroring');692      controller._started = true;693      WritableStreamDealWithRejection(stream, r);694    }695  ).catch(rethrowAssertionErrorRejection);696}697function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: WritableStream<W>,698                                                                   underlyingSink: UnderlyingSink<W>,699                                                                   highWaterMark: number,700                                                                   sizeAlgorithm: QueuingStrategySizeCallback<W>) {701  assert(underlyingSink !== undefined);702  const controller = Object.create(WritableStreamDefaultController.prototype);703  function startAlgorithm() {704    return InvokeOrNoop<typeof underlyingSink, 'start'>(underlyingSink, 'start', [controller]);705  }706  const writeAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'write'>(707    underlyingSink, 'write', 1, [controller]708  );709  const closeAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'close'>(710    underlyingSink, 'close', 0, []711  );712  const abortAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'abort'>(713    underlyingSink, 'abort', 1, []714  );715  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,716                                       abortAlgorithm, highWaterMark, sizeAlgorithm);717}718// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.719function WritableStreamDefaultControllerClearAlgorithms(controller: WritableStreamDefaultController<any>) {720  controller._writeAlgorithm = undefined!;721  controller._closeAlgorithm = undefined!;722  controller._abortAlgorithm = undefined!;723  controller._strategySizeAlgorithm = undefined!;724}725function WritableStreamDefaultControllerClose(controller: WritableStreamDefaultController<any>) {726  EnqueueValueWithSize(controller, 'close', 0);727  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);728}729function WritableStreamDefaultControllerGetChunkSize<W>(controller: WritableStreamDefaultController<W>,730                                                        chunk: W): number {731  try {732    return controller._strategySizeAlgorithm(chunk);733  } catch (chunkSizeE) {734    WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);735    return 1;736  }737}738function WritableStreamDefaultControllerGetDesiredSize(controller: WritableStreamDefaultController<any>): number {739  return controller._strategyHWM - controller._queueTotalSize;740}741function WritableStreamDefaultControllerWrite<W>(controller: WritableStreamDefaultController<W>,742                                                 chunk: W,743                                                 chunkSize: number) {744  const writeRecord = { chunk };745  try {746    EnqueueValueWithSize(controller, writeRecord, chunkSize);747  } catch (enqueueE) {748    WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);749    return;750  }751  const stream = controller._controlledWritableStream;752  if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {753    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);754    WritableStreamUpdateBackpressure(stream, backpressure);755  }756  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);757}758// Abstract operations for the WritableStreamDefaultController.759function WritableStreamDefaultControllerAdvanceQueueIfNeeded<W>(controller: WritableStreamDefaultController<W>) {760  const stream = controller._controlledWritableStream;761  if (controller._started === false) {762    return;763  }764  if (stream._inFlightWriteRequest !== undefined) {765    return;766  }767  const state = stream._state;768  assert(state !== 'closed' && state !== 'errored');769  if (state === 'erroring') {770    WritableStreamFinishErroring(stream);771    return;772  }773  if (controller._queue.length === 0) {774    return;775  }776  const writeRecord = PeekQueueValue(controller);777  if (writeRecord === 'close') {778    WritableStreamDefaultControllerProcessClose(controller);779  } else {780    WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);781  }782}783function WritableStreamDefaultControllerErrorIfNeeded(controller: WritableStreamDefaultController<any>, error: any) {784  if (controller._controlledWritableStream._state === 'writable') {785    WritableStreamDefaultControllerError(controller, error);786  }787}788function WritableStreamDefaultControllerProcessClose(controller: WritableStreamDefaultController<any>) {789  const stream = controller._controlledWritableStream;790  WritableStreamMarkCloseRequestInFlight(stream);791  DequeueValue(controller);792  assert(controller._queue.length === 0);793  const sinkClosePromise = controller._closeAlgorithm();794  WritableStreamDefaultControllerClearAlgorithms(controller);795  sinkClosePromise.then(796    () => {797      WritableStreamFinishInFlightClose(stream);798    },799    reason => {800      WritableStreamFinishInFlightCloseWithError(stream, reason);801    }802  ).catch(rethrowAssertionErrorRejection);803}804function WritableStreamDefaultControllerProcessWrite<W>(controller: WritableStreamDefaultController<W>, chunk: W) {805  const stream = controller._controlledWritableStream;806  WritableStreamMarkFirstWriteRequestInFlight(stream);807  const sinkWritePromise = controller._writeAlgorithm(chunk);808  sinkWritePromise.then(809    () => {810      WritableStreamFinishInFlightWrite(stream);811      const state = stream._state;812      assert(state === 'writable' || state === 'erroring');813      DequeueValue(controller);814      if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {815        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);816        WritableStreamUpdateBackpressure(stream, backpressure);817      }818      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);819    },820    reason => {821      if (stream._state === 'writable') {822        WritableStreamDefaultControllerClearAlgorithms(controller);823      }824      WritableStreamFinishInFlightWriteWithError(stream, reason);825    }826  ).catch(rethrowAssertionErrorRejection);827}828function WritableStreamDefaultControllerGetBackpressure(controller: WritableStreamDefaultController<any>): boolean {829  const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);830  return desiredSize <= 0;831}832// A client of WritableStreamDefaultController may use these functions directly to bypass state check.833function WritableStreamDefaultControllerError(controller: WritableStreamDefaultController<any>, error: any) {834  const stream = controller._controlledWritableStream;835  assert(stream._state === 'writable');836  WritableStreamDefaultControllerClearAlgorithms(controller);837  WritableStreamStartErroring(stream, error);838}839// Helper functions for the WritableStream.840function streamBrandCheckException(name: string): TypeError {841  return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);842}843// Helper functions for the WritableStreamDefaultWriter.844function defaultWriterBrandCheckException(name: string): TypeError {845  return new TypeError(846    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);847}848function defaultWriterLockException(name: string): TypeError {849  return new TypeError('Cannot ' + name + ' a stream using a released writer');850}851function defaultWriterClosedPromiseInitialize(writer: WritableStreamDefaultWriter<any>) {852  writer._closedPromise = new Promise((resolve, reject) => {853    writer._closedPromise_resolve = resolve;854    writer._closedPromise_reject = reject;855    writer._closedPromiseState = 'pending';856  });857}858function defaultWriterClosedPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {859  defaultWriterClosedPromiseInitialize(writer);860  defaultWriterClosedPromiseReject(writer, reason);861}862function defaultWriterClosedPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter<any>) {863  defaultWriterClosedPromiseInitialize(writer);864  defaultWriterClosedPromiseResolve(writer);865}866function defaultWriterClosedPromiseReject(writer: WritableStreamDefaultWriter<any>, reason: any) {867  assert(writer._closedPromise_resolve !== undefined);868  assert(writer._closedPromise_reject !== undefined);869  assert(writer._closedPromiseState === 'pending');870  writer._closedPromise.catch(() => {});871  writer._closedPromise_reject!(reason);872  writer._closedPromise_resolve = undefined;873  writer._closedPromise_reject = undefined;874  writer._closedPromiseState = 'rejected';875}876function defaultWriterClosedPromiseResetToRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {877  assert(writer._closedPromise_resolve === undefined);878  assert(writer._closedPromise_reject === undefined);879  assert(writer._closedPromiseState !== 'pending');880  defaultWriterClosedPromiseInitializeAsRejected(writer, reason);881}882function defaultWriterClosedPromiseResolve(writer: WritableStreamDefaultWriter<any>) {883  assert(writer._closedPromise_resolve !== undefined);884  assert(writer._closedPromise_reject !== undefined);885  assert(writer._closedPromiseState === 'pending');886  writer._closedPromise_resolve!(undefined);887  writer._closedPromise_resolve = undefined;888  writer._closedPromise_reject = undefined;889  writer._closedPromiseState = 'resolved';890}891function defaultWriterReadyPromiseInitialize(writer: WritableStreamDefaultWriter<any>) {892  writer._readyPromise = new Promise((resolve, reject) => {893    writer._readyPromise_resolve = resolve;894    writer._readyPromise_reject = reject;895  });896  writer._readyPromiseState = 'pending';897}898function defaultWriterReadyPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {899  defaultWriterReadyPromiseInitialize(writer);900  defaultWriterReadyPromiseReject(writer, reason);901}902function defaultWriterReadyPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter<any>) {903  defaultWriterReadyPromiseInitialize(writer);904  defaultWriterReadyPromiseResolve(writer);905}906function defaultWriterReadyPromiseReject(writer: WritableStreamDefaultWriter<any>, reason: any) {907  assert(writer._readyPromise_resolve !== undefined);908  assert(writer._readyPromise_reject !== undefined);909  writer._readyPromise.catch(() => {});910  writer._readyPromise_reject!(reason);911  writer._readyPromise_resolve = undefined;912  writer._readyPromise_reject = undefined;913  writer._readyPromiseState = 'rejected';914}915function defaultWriterReadyPromiseReset(writer: WritableStreamDefaultWriter<any>) {916  assert(writer._readyPromise_resolve === undefined);917  assert(writer._readyPromise_reject === undefined);918  defaultWriterReadyPromiseInitialize(writer);919}920function defaultWriterReadyPromiseResetToRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {921  assert(writer._readyPromise_resolve === undefined);922  assert(writer._readyPromise_reject === undefined);923  defaultWriterReadyPromiseInitializeAsRejected(writer, reason);924}925function defaultWriterReadyPromiseResolve(writer: WritableStreamDefaultWriter<any>) {926  assert(writer._readyPromise_resolve !== undefined);927  assert(writer._readyPromise_reject !== undefined);928  writer._readyPromise_resolve!(undefined);929  writer._readyPromise_resolve = undefined;930  writer._readyPromise_reject = undefined;931  writer._readyPromiseState = 'fulfilled';...

writable-stream.js

Source:writable-stream.js

...311        defaultWriterReadyPromiseInitializeAsResolved(this);312      }313      defaultWriterClosedPromiseInitialize(this);314    } else if (state === 'erroring') {315      defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);316      this._readyPromise.catch(() => {});317      defaultWriterClosedPromiseInitialize(this);318    } else if (state === 'closed') {319      defaultWriterReadyPromiseInitializeAsResolved(this);320      defaultWriterClosedPromiseInitializeAsResolved(this);321    } else {322      assert(state === 'errored', 'state must be errored');323      const storedError = stream._storedError;324      defaultWriterReadyPromiseInitializeAsRejected(this, storedError);325      this._readyPromise.catch(() => {});326      defaultWriterClosedPromiseInitializeAsRejected(this, storedError);327      this._closedPromise.catch(() => {});328    }329  }330  get closed() {331    if (IsWritableStreamDefaultWriter(this) === false) {332      return Promise.reject(defaultWriterBrandCheckException('closed'));333    }334    return this._closedPromise;335  }336  get desiredSize() {337    if (IsWritableStreamDefaultWriter(this) === false) {338      throw defaultWriterBrandCheckException('desiredSize');339    }340    if (this._ownerWritableStream === undefined) {341      throw defaultWriterLockException('desiredSize');342    }343    return WritableStreamDefaultWriterGetDesiredSize(this);344  }345  get ready() {346    if (IsWritableStreamDefaultWriter(this) === false) {347      return Promise.reject(defaultWriterBrandCheckException('ready'));348    }349    return this._readyPromise;350  }351  abort(reason) {352    if (IsWritableStreamDefaultWriter(this) === false) {353      return Promise.reject(defaultWriterBrandCheckException('abort'));354    }355    if (this._ownerWritableStream === undefined) {356      return Promise.reject(defaultWriterLockException('abort'));357    }358    return WritableStreamDefaultWriterAbort(this, reason);359  }360  close() {361    if (IsWritableStreamDefaultWriter(this) === false) {362      return Promise.reject(defaultWriterBrandCheckException('close'));363    }364    const stream = this._ownerWritableStream;365    if (stream === undefined) {366      return Promise.reject(defaultWriterLockException('close'));367    }368    if (WritableStreamCloseQueuedOrInFlight(stream) === true) {369      return Promise.reject(new TypeError('cannot close an already-closing stream'));370    }371    return WritableStreamDefaultWriterClose(this);372  }373  releaseLock() {374    if (IsWritableStreamDefaultWriter(this) === false) {375      throw defaultWriterBrandCheckException('releaseLock');376    }377    const stream = this._ownerWritableStream;378    if (stream === undefined) {379      return;380    }381    assert(stream._writer !== undefined);382    WritableStreamDefaultWriterRelease(this);383  }384  write(chunk) {385    if (IsWritableStreamDefaultWriter(this) === false) {386      return Promise.reject(defaultWriterBrandCheckException('write'));387    }388    if (this._ownerWritableStream === undefined) {389      return Promise.reject(defaultWriterLockException('write to'));390    }391    return WritableStreamDefaultWriterWrite(this, chunk);392  }393}394// Abstract operations for the WritableStreamDefaultWriter.395function IsWritableStreamDefaultWriter(x) {396  if (!typeIsObject(x)) {397    return false;398  }399  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {400    return false;401  }402  return true;403}404// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.405function WritableStreamDefaultWriterAbort(writer, reason) {406  const stream = writer._ownerWritableStream;407  assert(stream !== undefined);408  return WritableStreamAbort(stream, reason);409}410function WritableStreamDefaultWriterClose(writer) {411  const stream = writer._ownerWritableStream;412  assert(stream !== undefined);413  const state = stream._state;414  if (state === 'closed' || state === 'errored') {415    return Promise.reject(new TypeError(416      `The stream (in ${state} state) is not in the writable state and cannot be closed`));417  }418  assert(state === 'writable' || state === 'erroring');419  assert(WritableStreamCloseQueuedOrInFlight(stream) === false);420  const promise = new Promise((resolve, reject) => {421    const closeRequest = {422      _resolve: resolve,423      _reject: reject424    };425    stream._closeRequest = closeRequest;426  });427  if (stream._backpressure === true && state === 'writable') {428    defaultWriterReadyPromiseResolve(writer);429  }430  WritableStreamDefaultControllerClose(stream._writableStreamController);431  return promise;432}433function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {434  const stream = writer._ownerWritableStream;435  assert(stream !== undefined);436  const state = stream._state;437  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {438    return Promise.resolve();439  }440  if (state === 'errored') {441    return Promise.reject(stream._storedError);442  }443  assert(state === 'writable' || state === 'erroring');444  return WritableStreamDefaultWriterClose(writer);445}446function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {447  if (writer._closedPromiseState === 'pending') {448    defaultWriterClosedPromiseReject(writer, error);449  } else {450    defaultWriterClosedPromiseResetToRejected(writer, error);451  }452  writer._closedPromise.catch(() => {});453}454function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {455  if (writer._readyPromiseState === 'pending') {456    defaultWriterReadyPromiseReject(writer, error);457  } else {458    defaultWriterReadyPromiseResetToRejected(writer, error);459  }460  writer._readyPromise.catch(() => {});461}462function WritableStreamDefaultWriterGetDesiredSize(writer) {463  const stream = writer._ownerWritableStream;464  const state = stream._state;465  if (state === 'errored' || state === 'erroring') {466    return null;467  }468  if (state === 'closed') {469    return 0;470  }471  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);472}473function WritableStreamDefaultWriterRelease(writer) {474  const stream = writer._ownerWritableStream;475  assert(stream !== undefined);476  assert(stream._writer === writer);477  const releasedError = new TypeError(478    'Writer was released and can no longer be used to monitor the stream\'s closedness');479  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);480  // The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not481  // rejected until afterwards. This means that simply testing state will not work.482  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);483  stream._writer = undefined;484  writer._ownerWritableStream = undefined;485}486function WritableStreamDefaultWriterWrite(writer, chunk) {487  const stream = writer._ownerWritableStream;488  assert(stream !== undefined);489  const controller = stream._writableStreamController;490  const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);491  if (stream !== writer._ownerWritableStream) {492    return Promise.reject(defaultWriterLockException('write to'));493  }494  const state = stream._state;495  if (state === 'errored') {496    return Promise.reject(stream._storedError);497  }498  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {499    return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));500  }501  if (state === 'erroring') {502    return Promise.reject(stream._storedError);503  }504  assert(state === 'writable');505  const promise = WritableStreamAddWriteRequest(stream);506  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);507  return promise;508}509class WritableStreamDefaultController {510  constructor(stream, underlyingSink, size, highWaterMark) {511    if (IsWritableStream(stream) === false) {512      throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');513    }514    if (stream._writableStreamController !== undefined) {515      throw new TypeError(516        'WritableStreamDefaultController instances can only be created by the WritableStream constructor');517    }518    this._controlledWritableStream = stream;519    this._underlyingSink = underlyingSink;520    // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.521    this._queue = undefined;522    this._queueTotalSize = undefined;523    ResetQueue(this);524    this._started = false;525    const normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);526    this._strategySize = normalizedStrategy.size;527    this._strategyHWM = normalizedStrategy.highWaterMark;528    const backpressure = WritableStreamDefaultControllerGetBackpressure(this);529    WritableStreamUpdateBackpressure(stream, backpressure);530  }531  error(e) {532    if (IsWritableStreamDefaultController(this) === false) {533      throw new TypeError(534        'WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');535    }536    const state = this._controlledWritableStream._state;537    if (state !== 'writable') {538      // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so539      // just treat it as a no-op.540      return;541    }542    WritableStreamDefaultControllerError(this, e);543  }544  [AbortSteps](reason) {545    return PromiseInvokeOrNoop(this._underlyingSink, 'abort', [reason]);546  }547  [ErrorSteps]() {548    ResetQueue(this);549  }550  [StartSteps]() {551    const startResult = InvokeOrNoop(this._underlyingSink, 'start', [this]);552    const stream = this._controlledWritableStream;553    Promise.resolve(startResult).then(554      () => {555        assert(stream._state === 'writable' || stream._state === 'erroring');556        this._started = true;557        WritableStreamDefaultControllerAdvanceQueueIfNeeded(this);558      },559      r => {560        assert(stream._state === 'writable' || stream._state === 'erroring');561        this._started = true;562        WritableStreamDealWithRejection(stream, r);563      }564    )565    .catch(rethrowAssertionErrorRejection);566  }567}568// Abstract operations implementing interface required by the WritableStream.569function WritableStreamDefaultControllerClose(controller) {570  EnqueueValueWithSize(controller, 'close', 0);571  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);572}573function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {574  const strategySize = controller._strategySize;575  if (strategySize === undefined) {576    return 1;577  }578  try {579    return strategySize(chunk);580  } catch (chunkSizeE) {581    WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);582    return 1;583  }584}585function WritableStreamDefaultControllerGetDesiredSize(controller) {586  return controller._strategyHWM - controller._queueTotalSize;587}588function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {589  const writeRecord = { chunk };590  try {591    EnqueueValueWithSize(controller, writeRecord, chunkSize);592  } catch (enqueueE) {593    WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);594    return;595  }596  const stream = controller._controlledWritableStream;597  if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {598    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);599    WritableStreamUpdateBackpressure(stream, backpressure);600  }601  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);602}603// Abstract operations for the WritableStreamDefaultController.604function IsWritableStreamDefaultController(x) {605  if (!typeIsObject(x)) {606    return false;607  }608  if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {609    return false;610  }611  return true;612}613function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {614  const stream = controller._controlledWritableStream;615  if (controller._started === false) {616    return;617  }618  if (stream._inFlightWriteRequest !== undefined) {619    return;620  }621  const state = stream._state;622  if (state === 'closed' || state === 'errored') {623    return;624  }625  if (state === 'erroring') {626    WritableStreamFinishErroring(stream);627    return;628  }629  if (controller._queue.length === 0) {630    return;631  }632  const writeRecord = PeekQueueValue(controller);633  if (writeRecord === 'close') {634    WritableStreamDefaultControllerProcessClose(controller);635  } else {636    WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);637  }638}639function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {640  if (controller._controlledWritableStream._state === 'writable') {641    WritableStreamDefaultControllerError(controller, error);642  }643}644function WritableStreamDefaultControllerProcessClose(controller) {645  const stream = controller._controlledWritableStream;646  WritableStreamMarkCloseRequestInFlight(stream);647  DequeueValue(controller);648  assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');649  const sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', []);650  sinkClosePromise.then(651    () => {652      WritableStreamFinishInFlightClose(stream);653    },654    reason => {655      WritableStreamFinishInFlightCloseWithError(stream, reason);656    }657  )658  .catch(rethrowAssertionErrorRejection);659}660function WritableStreamDefaultControllerProcessWrite(controller, chunk) {661  const stream = controller._controlledWritableStream;662  WritableStreamMarkFirstWriteRequestInFlight(stream);663  const sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);664  sinkWritePromise.then(665    () => {666      WritableStreamFinishInFlightWrite(stream);667      const state = stream._state;668      assert(state === 'writable' || state === 'erroring');669      DequeueValue(controller);670      if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {671        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);672        WritableStreamUpdateBackpressure(stream, backpressure);673      }674      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);675    },676    reason => {677      WritableStreamFinishInFlightWriteWithError(stream, reason);678    }679  )680  .catch(rethrowAssertionErrorRejection);681}682function WritableStreamDefaultControllerGetBackpressure(controller) {683  const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);684  return desiredSize <= 0;685}686// A client of WritableStreamDefaultController may use these functions directly to bypass state check.687function WritableStreamDefaultControllerError(controller, error) {688  const stream = controller._controlledWritableStream;689  assert(stream._state === 'writable');690  WritableStreamStartErroring(stream, error);691}692// Helper functions for the WritableStream.693function streamBrandCheckException(name) {694  return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);695}696// Helper functions for the WritableStreamDefaultWriter.697function defaultWriterBrandCheckException(name) {698  return new TypeError(699    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);700}701function defaultWriterLockException(name) {702  return new TypeError('Cannot ' + name + ' a stream using a released writer');703}704function defaultWriterClosedPromiseInitialize(writer) {705  writer._closedPromise = new Promise((resolve, reject) => {706    writer._closedPromise_resolve = resolve;707    writer._closedPromise_reject = reject;708    writer._closedPromiseState = 'pending';709  });710}711function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {712  writer._closedPromise = Promise.reject(reason);713  writer._closedPromise_resolve = undefined;714  writer._closedPromise_reject = undefined;715  writer._closedPromiseState = 'rejected';716}717function defaultWriterClosedPromiseInitializeAsResolved(writer) {718  writer._closedPromise = Promise.resolve(undefined);719  writer._closedPromise_resolve = undefined;720  writer._closedPromise_reject = undefined;721  writer._closedPromiseState = 'resolved';722}723function defaultWriterClosedPromiseReject(writer, reason) {724  assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');725  assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');726  assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');727  writer._closedPromise_reject(reason);728  writer._closedPromise_resolve = undefined;729  writer._closedPromise_reject = undefined;730  writer._closedPromiseState = 'rejected';731}732function defaultWriterClosedPromiseResetToRejected(writer, reason) {733  assert(writer._closedPromise_resolve === undefined, 'writer._closedPromise_resolve === undefined');734  assert(writer._closedPromise_reject === undefined, 'writer._closedPromise_reject === undefined');735  assert(writer._closedPromiseState !== 'pending', 'writer._closedPromiseState is not pending');736  writer._closedPromise = Promise.reject(reason);737  writer._closedPromiseState = 'rejected';738}739function defaultWriterClosedPromiseResolve(writer) {740  assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');741  assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');742  assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');743  writer._closedPromise_resolve(undefined);744  writer._closedPromise_resolve = undefined;745  writer._closedPromise_reject = undefined;746  writer._closedPromiseState = 'resolved';747}748function defaultWriterReadyPromiseInitialize(writer) {749  writer._readyPromise = new Promise((resolve, reject) => {750    writer._readyPromise_resolve = resolve;751    writer._readyPromise_reject = reject;752  });753  writer._readyPromiseState = 'pending';754}755function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {756  writer._readyPromise = Promise.reject(reason);757  writer._readyPromise_resolve = undefined;758  writer._readyPromise_reject = undefined;759  writer._readyPromiseState = 'rejected';760}761function defaultWriterReadyPromiseInitializeAsResolved(writer) {762  writer._readyPromise = Promise.resolve(undefined);763  writer._readyPromise_resolve = undefined;764  writer._readyPromise_reject = undefined;765  writer._readyPromiseState = 'fulfilled';766}767function defaultWriterReadyPromiseReject(writer, reason) {768  assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');769  assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');...

Using AI Code Generation

1const wpt = require('wpt');2wpt.defaultWriterReadyPromiseInitializeAsRejected();3const wpt = require('wpt');4wpt.defaultWriterReadyPromiseInitializeAsRejected();5const wpt = require('wpt');6wpt.defaultWriterReadyPromiseInitializeAsRejected();7const wpt = require('wpt');8wpt.defaultWriterReadyPromiseInitializeAsRejected();9const wpt = require('wpt');10wpt.defaultWriterReadyPromiseInitializeAsRejected();11const wpt = require('wpt');12wpt.defaultWriterReadyPromiseInitializeAsRejected();13const wpt = require('wpt');14wpt.defaultWriterReadyPromiseInitializeAsRejected();15const wpt = require('wpt');16wpt.defaultWriterReadyPromiseInitializeAsRejected();17const wpt = require('wpt');18wpt.defaultWriterReadyPromiseInitializeAsRejected();19const wpt = require('wpt');20wpt.defaultWriterReadyPromiseInitializeAsRejected();21const wpt = require('wpt');22wpt.defaultWriterReadyPromiseInitializeAsRejected();23const wpt = require('wpt');24wpt.defaultWriterReadyPromiseInitializeAsRejected();25const wpt = require('wpt');26wpt.defaultWriterReadyPromiseInitializeAsRejected();27const wpt = require('wpt');28wpt.defaultWriterReadyPromiseInitializeAsRejected();29const wpt = require('wpt

Using AI Code Generation

1importScripts('/resources/testharness.js');2importScripts('/resources/testharnessreport.js');3importScripts('../resources/test-helpers.sub.js');4promise_test(async t => {5  const writer = new WritableStreamDefaultWriter(new WritableStream());6  writer.releaseLock();7  const writer2 = new WritableStreamDefaultWriter(new WritableStream());8  const readyPromise = writer2.ready;9  writer2.releaseLock();10  const writer3 = new WritableStreamDefaultWriter(new WritableStream());11  writer3.releaseLock();12  await promise_rejects(t, new TypeError(), writer3.ready, 'writer3.ready should be rejected');13  await promise_rejects(t, new TypeError(), writer3.ready, 'writer3.ready should be rejected');14  return promise_rejects(t, new TypeError(), readyPromise, 'readyPromise should be rejected');15}, 'WritableStreamDefaultWriter ready promise should be rejected if writer is released');

Using AI Code Generation

1test(() => {2  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");3  assert_equals(promise._state, "rejected");4  assert_equals(promise._result, "reason");5}, "defaultWriterReadyPromiseInitializeAsRejected with 'reason'");6test(() => {7  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");8  promise.then(9    () => {10      assert_unreached("promise should be rejected");11    },12    (reason) => {13      assert_equals(reason, "reason");14    }15  );16}, "defaultWriterReadyPromiseInitializeAsRejected with 'reason'");17test(() => {18  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");19  promise.catch((reason) => {20    assert_equals(reason, "reason");21  });22}, "defaultWriterReadyPromiseInitializeAsRejected with 'reason'");23test(() => {24  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");25  promise.then(26    () => {27      assert_unreached("promise should be rejected");28    },29    (reason) => {30      assert_equals(reason, "reason");31    }32  );33  promise.catch((reason) => {34    assert_equals(reason, "reason");35  });36}, "defaultWriterReadyPromiseInitializeAsRejected with 'reason'");37test(() => {38  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");39  promise.then(40    () => {41      assert_unreached("promise should be rejected");42    },43    (reason) => {44      assert_equals(reason, "reason");45    }46  );47  promise.catch((reason) => {48    assert_equals(reason, "reason");49  });50  promise.then(51    () => {52      assert_unreached("promise should be rejected");53    },54    (reason) => {55      assert_equals(reason, "reason");56    }57  );58}, "defaultWriterReadyPromiseInitializeAsRejected with 'reason'");59test(() => {60  let promise = defaultWriterReadyPromiseInitializeAsRejected("reason");61  promise.then(62    () => {

Using AI Code Generation

1    wpt.defaultWriterReadyPromiseInitializeAsRejected;2    wpt.defaultWriterReadyPromiseInitializeAsRejected;3    wpt.defaultWriterReadyPromiseInitializeAsRejected;4    wpt.defaultWriterReadyPromiseInitializeAsRejected;5    wpt.defaultWriterReadyPromiseInitializeAsRejected;6    wpt.defaultWriterReadyPromiseInitializeAsRejected;7    wpt.defaultWriterReadyPromiseInitializeAsRejected;8    wpt.defaultWriterReadyPromiseInitializeAsRejected;9    wpt.defaultWriterReadyPromiseInitializeAsRejected;10    wpt.defaultWriterReadyPromiseInitializeAsRejected;11    wpt.defaultWriterReadyPromiseInitializeAsRejected;12    wpt.defaultWriterReadyPromiseInitializeAsRejected;

Using AI Code Generation

1test(function() {2  var writerReady = new WritableStreamDefaultWriter();3  writerReady._readyPromise.catch(function(){});4  writerReady._readyPromise = defaultWriterReadyPromiseInitializeAsRejected(writerReady);5  assert_equals(writerReady._readyPromise._state, 'rejected');6  assert_equals(writerReady._readyPromise._result, undefined);7}, 'defaultWriterReadyPromiseInitializeAsRejected method of wpt');8test(function() {9  var writerClosed = new WritableStreamDefaultWriter();10  writerClosed._closedPromise.catch(function(){});11  writerClosed._closedPromise = defaultWriterClosedPromiseInitializeAsResolved(writerClosed);12  assert_equals(writerClosed._closedPromise._state, 'fulfilled');13  assert_equals(writerClosed._closedPromise._result, undefined);14}, 'defaultWriterClosedPromiseInitializeAsResolved method of wpt');15test(function() {16  var writerClosed = new WritableStreamDefaultWriter();17  writerClosed._closedPromise.catch(function(){});18  writerClosed._closedPromise = defaultWriterClosedPromiseInitializeAsRejected(writerClosed);19  assert_equals(writerClosed._closedPromise._state, 'rejected');20  assert_equals(writerClosed._closedPromise._result, undefined);21}, 'defaultWriterClosedPromiseInitializeAsRejected method of wpt');22test(function() {23  var writerClosed = new WritableStreamDefaultWriter();24  writerClosed._closedPromise.catch(function(){});25  writerClosed._closedPromise = defaultWriterClosedPromiseInitializeAsRejected(writerClosed);26  assert_equals(writerClosed._closedPromise._state, 'rejected');27  assert_equals(writerClosed._closedPromise._result, undefined);28}, 'defaultWriterClosedPromiseInitializeAsRejected method of wpt');29test(function() {30  var writerClosed = new WritableStreamDefaultWriter();31  writerClosed._closedPromise.catch(function(){});32  writerClosed._closedPromise = defaultWriterClosedPromiseInitializeAsRejected(writerClosed);33  assert_equals(writerClosed._closedPromise._state, 'rejected');34  assert_equals(writerClosed._closedPromise._result, undefined);35}, 'default

Using AI Code Generation

1var defaultWriterReadyPromiseInitializeAsRejected = new WritableStreamDefaultWriter();2defaultWriterReadyPromiseInitializeAsRejected.ready.then(3    function() {4      console.log("Resolved");5    },6    function() {7      console.log("Rejected");8    }9);10var defaultWriterReadyPromiseInitializeAsResolved = new WritableStreamDefaultWriter();11defaultWriterReadyPromiseInitializeAsResolved.ready.then(12    function() {13      console.log("Resolved");14    },15    function() {16      console.log("Rejected");17    }18);19var defaultWriterReadyPromiseInitializeAsRejectedWithUndefined = new WritableStreamDefaultWriter();20defaultWriterReadyPromiseInitializeAsRejectedWithUndefined.ready.then(21    function() {22      console.log("Resolved");23    },24    function() {25      console.log("Rejected");26    }27);28var defaultWriterReadyPromiseInitializeAsResolvedWithUndefined = new WritableStreamDefaultWriter();29defaultWriterReadyPromiseInitializeAsResolvedWithUndefined.ready.then(30    function() {31      console.log("Resolved");32    },33    function() {34      console.log("Rejected");35    }36);37var defaultWriterReadyPromiseInitializeAsRejectedWithNull = new WritableStreamDefaultWriter();38defaultWriterReadyPromiseInitializeAsRejectedWithNull.ready.then(39    function() {40      console.log("Resolved");41    },42    function() {43      console.log("Rejected");44    }45);46var defaultWriterReadyPromiseInitializeAsResolvedWithNull = new WritableStreamDefaultWriter();47defaultWriterReadyPromiseInitializeAsResolvedWithNull.ready.then(48    function() {49      console.log("Resolved");50    },51    function() {52      console.log("Rejected");53    }54);55var defaultWriterReadyPromiseInitializeAsRejectedWithNumber = new WritableStreamDefaultWriter();56defaultWriterReadyPromiseInitializeAsRejectedWithNumber.ready.then(57    function() {58      console.log("Resolved");59    },60    function() {61      console.log("Rejected");62    }63);

Using AI Code Generation

1test(function() {2  var defaultWriterReadyPromiseInitializeAsRejected = new Promise(function(resolve, reject) {3    reject(new TypeError('This should be rejected'));4  });5  var writer = new WritableStreamDefaultWriter();6  writer.closed.then(function() {7    assert_unreached('closed should be rejected');8  }, function(r) {9    assert_equals(r.name, 'TypeError', 'closed should be rejected with TypeError');10  });11  defaultWriterReadyPromiseInitializeAsRejected.then(function() {12    writer.closed.then(function() {13      assert_unreached('closed should be rejected');14    }, function(r) {15      assert_equals(r.name, 'TypeError', 'closed should be rejected with TypeError');16    });17  });18}, 'WritableStreamDefaultWriter: defaultWriterReadyPromiseInitializeAsRejected');19test(function() {20  var writerClosedPromiseInitializeAsRejected = new Promise(function(resolve, reject) {21    reject(new TypeError('This should be rejected'));22  });23  var writer = new WritableStreamDefaultWriter();24  writer.ready.then(function() {25    assert_unreached('ready should be rejected');26  }, function(r) {27    assert_equals(r.name, 'TypeError', 'ready should be rejected with TypeError');28  });29  writerClosedPromiseInitializeAsRejected.then(function() {30    writer.ready.then(function() {31      assert_unreached('ready should be rejected');32    }, function(r) {33      assert_equals(r.name, 'TypeError', 'ready should be rejected with TypeError');34    });35  });36}, 'WritableStreamDefaultWriter: writerClosedPromiseInitializeAsRejected');37test(function() {38  var writerClosedPromiseInitializeAsFulfilled = new Promise(function(resolve, reject) {39    resolve(undefined);40  });41  var writer = new WritableStreamDefaultWriter();42  writer.ready.then(function() {43    assert_unreached('ready should be rejected');44  }, function(r) {45    assert_equals(r.name, 'TypeError', 'ready should be rejected with TypeError');46  });47  writerClosedPromiseInitializeAsFulfilled.then(function() {48    writer.ready.then(function() {49      assert_unreached('ready should be rejected');50    }, function(r) {51      assert_equals(r.name, 'TypeError', 'ready should be rejected with TypeError');

Using AI Code Generation

1const writer = writable.getWriter();2const reason = new Error('something went wrong');3wpt.defaultWriterReadyPromiseInitializeAsRejected(writer, reason);4const writer = writable.getWriter();5wpt.defaultWriterReadyPromiseInitializeAsFulfilled(writer);6const writer = writable.getWriter();7wpt.defaultWriterReadyPromiseInitialize(writer);8const writer = writable.getWriter();9const reason = new Error('something went wrong');10wpt.defaultWriterReadyPromiseReject(writer, reason);11const writer = writable.getWriter();12const reason = new Error('something went wrong');13wpt.defaultWriterReadyPromiseResetToRejected(writer, reason);14const writer = writable.getWriter();15wpt.defaultWriterReadyPromiseResolve(writer);16const writer = writable.getWriter();17wpt.defaultWriterReadyPromiseReset(writer);18const writer = writable.getWriter();19wpt.defaultWriterClose(writer);

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.