How to use IsReadableStreamLocked method in wpt

Best JavaScript code snippet using wpt

ReadableStream.js

Source:ReadableStream.js

...118    get locked() {119      if (IsReadableStream(this) === false) {120        throw new TypeError(errIllegalInvocation);121      }122      return IsReadableStreamLocked(this);123    }124    cancel(reason) {125      if (IsReadableStream(this) === false) {126        return Promise_reject(new TypeError(errIllegalInvocation));127      }128      if (IsReadableStreamLocked(this) === true) {129        return Promise_reject(new TypeError(errCancelLockedStream));130      }131      return CancelReadableStream(this, reason);132    }133    getReader() {134      if (IsReadableStream(this) === false) {135        throw new TypeError(errIllegalInvocation);136      }137      return AcquireReadableStreamReader(this);138    }139    tee() {140      if (IsReadableStream(this) === false) {141        throw new TypeError(errIllegalInvocation);142      }143      return TeeReadableStream(this);144    }145  }146  class ReadableStreamController {147    constructor(stream) {148      if (IsReadableStream(stream) === false) {149        throw new TypeError(errIllegalConstructor);150      }151      if (stream[readableStreamController] !== undefined) {152        throw new TypeError(errIllegalConstructor);153      }154      this[readableStreamControllerControlledReadableStream] = stream;155    }156    get desiredSize() {157      if (IsReadableStreamController(this) === false) {158        throw new TypeError(errIllegalInvocation);159      }160      return GetReadableStreamDesiredSize(161          this[readableStreamControllerControlledReadableStream]);162    }163    close() {164      if (IsReadableStreamController(this) === false) {165        throw new TypeError(errIllegalInvocation);166      }167      const stream = this[readableStreamControllerControlledReadableStream];168      if (stream[readableStreamBits] & CLOSE_REQUESTED) {169        throw new TypeError(errCloseCloseRequestedStream);170      }171      if (stream[readableStreamState] === STATE_ERRORED) {172        throw new TypeError(errCloseErroredStream);173      }174      return CloseReadableStream(stream);175    }176    enqueue(chunk) {177      if (IsReadableStreamController(this) === false) {178        throw new TypeError(errIllegalInvocation);179      }180      const stream = this[readableStreamControllerControlledReadableStream];181      if (stream[readableStreamState] === STATE_ERRORED) {182        throw stream[readableStreamStoredError];183      }184      if (stream[readableStreamBits] & CLOSE_REQUESTED) {185        throw new TypeError(errEnqueueInCloseRequestedStream);186      }187      return EnqueueInReadableStream(stream, chunk);188    }189    error(e) {190      if (IsReadableStreamController(this) === false) {191        throw new TypeError(errIllegalInvocation);192      }193      const stream = this[readableStreamControllerControlledReadableStream];194      const state = stream[readableStreamState];195      if (state !== STATE_READABLE) {196        if (state === STATE_ERRORED) {197          throw new TypeError(errErrorErroredStream);198        }199        if (state === STATE_CLOSED) {200          throw new TypeError(errErrorClosedStream);201        }202      }203      return ErrorReadableStream(stream, e);204    }205  }206  class ReadableStreamReader {207    constructor(stream) {208      if (IsReadableStream(stream) === false) {209        throw new TypeError(errReaderConstructorBadArgument);210      }211      if (IsReadableStreamLocked(stream) === true) {212        throw new TypeError(errReaderConstructorStreamAlreadyLocked);213      }214      this[readableStreamReaderOwnerReadableStream] = stream;215      stream[readableStreamReader] = this;216      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();217      switch (stream[readableStreamState]) {218        case STATE_READABLE:219          this[readableStreamReaderClosedPromise] = v8.createPromise();220          break;221        case STATE_CLOSED:222          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);223          break;224        case STATE_ERRORED:225          this[readableStreamReaderClosedPromise] =226              Promise_reject(stream[readableStreamStoredError]);227          break;228      }229    }230    get closed() {231      if (IsReadableStreamReader(this) === false) {232        return Promise_reject(new TypeError(errIllegalInvocation));233      }234      return this[readableStreamReaderClosedPromise];235    }236    cancel(reason) {237      if (IsReadableStreamReader(this) === false) {238        return Promise_reject(new TypeError(errIllegalInvocation));239      }240      const stream = this[readableStreamReaderOwnerReadableStream];241      if (stream === undefined) {242        return Promise_reject(new TypeError(errCancelReleasedReader));243      }244      return CancelReadableStream(stream, reason);245    }246    read() {247      if (IsReadableStreamReader(this) === false) {248        return Promise_reject(new TypeError(errIllegalInvocation));249      }250      if (this[readableStreamReaderOwnerReadableStream] === undefined) {251        return Promise_reject(new TypeError(errReadReleasedReader));252      }253      return ReadFromReadableStreamReader(this);254    }255    releaseLock() {256      if (IsReadableStreamReader(this) === false) {257        throw new TypeError(errIllegalInvocation);258      }259      const stream = this[readableStreamReaderOwnerReadableStream];260      if (stream === undefined) {261        return undefined;262      }263      if (this[readableStreamReaderReadRequests].length > 0) {264        throw new TypeError(errReleaseReaderWithPendingRead);265      }266      if (stream[readableStreamState] === STATE_READABLE) {267        v8.rejectPromise(this[readableStreamReaderClosedPromise],268            new TypeError(errReleasedReaderClosedPromise));269      } else {270        this[readableStreamReaderClosedPromise] = Promise_reject(new TypeError(271            errReleasedReaderClosedPromise));272      }273      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =274          undefined;275      this[readableStreamReaderOwnerReadableStream] = undefined;276    }277  }278  //279  // Readable stream abstract operations280  //281  function AcquireReadableStreamReader(stream) {282    return new ReadableStreamReader(stream);283  }284  function CancelReadableStream(stream, reason) {285    stream[readableStreamBits] |= DISTURBED;286    const state = stream[readableStreamState];287    if (state === STATE_CLOSED) {288      return Promise_resolve(undefined);289    }290    if (state === STATE_ERRORED) {291      return Promise_reject(stream[readableStreamStoredError]);292    }293    stream[readableStreamQueue] = new v8.InternalPackedArray();294    FinishClosingReadableStream(stream);295    const underlyingSource = stream[readableStreamUnderlyingSource];296    const sourceCancelPromise = PromiseCallOrNoop(297        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');298    return thenPromise(sourceCancelPromise, () => undefined);299  }300  function CloseReadableStream(stream) {301    if (stream[readableStreamState] === STATE_CLOSED) {302      return undefined;303    }304    stream[readableStreamBits] |= CLOSE_REQUESTED;305    if (stream[readableStreamQueue].length === 0) {306      return FinishClosingReadableStream(stream);307    }308  }309  function EnqueueInReadableStream(stream, chunk) {310    if (stream[readableStreamState] === STATE_CLOSED) {311      return undefined;312    }313    if (IsReadableStreamLocked(stream) === true &&314        stream[readableStreamReader][readableStreamReaderReadRequests].length >315            0) {316      const readRequest =317          stream[readableStreamReader][readableStreamReaderReadRequests]318              .shift();319      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));320    } else {321      let chunkSize = 1;322      const strategySize = stream[readableStreamStrategySize];323      if (strategySize !== undefined) {324        try {325          chunkSize = strategySize(chunk);326        } catch (chunkSizeE) {327          if (stream[readableStreamState] === STATE_READABLE) {328            ErrorReadableStream(stream, chunkSizeE);329          }330          throw chunkSizeE;331        }332      }333      try {334        EnqueueValueWithSize(stream, chunk, chunkSize);335      } catch (enqueueE) {336        if (stream[readableStreamState] === STATE_READABLE) {337          ErrorReadableStream(stream, enqueueE);338        }339        throw enqueueE;340      }341    }342    RequestReadableStreamPull(stream);343  }344  function ErrorReadableStream(stream, e) {345    stream[readableStreamQueue] = new v8.InternalPackedArray();346    stream[readableStreamStoredError] = e;347    stream[readableStreamState] = STATE_ERRORED;348    const reader = stream[readableStreamReader];349    if (reader === undefined) {350      return undefined;351    }352    const readRequests = reader[readableStreamReaderReadRequests];353    for (let i = 0; i < readRequests.length; ++i) {354      v8.rejectPromise(readRequests[i], e);355    }356    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();357    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);358  }359  function FinishClosingReadableStream(stream) {360    stream[readableStreamState] = STATE_CLOSED;361    const reader = stream[readableStreamReader];362    if (reader === undefined) {363      return undefined;364    }365    const readRequests = reader[readableStreamReaderReadRequests];366    for (let i = 0; i < readRequests.length; ++i) {367      v8.resolvePromise(368          readRequests[i], CreateIterResultObject(undefined, true));369    }370    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();371    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);372  }373  function GetReadableStreamDesiredSize(stream) {374    const queueSize = GetTotalQueueSize(stream);375    return stream[readableStreamStrategyHWM] - queueSize;376  }377  function IsReadableStream(x) {378    return hasOwnProperty(x, readableStreamUnderlyingSource);379  }380  function IsReadableStreamDisturbed(stream) {381    return stream[readableStreamBits] & DISTURBED;382  }383  function IsReadableStreamLocked(stream) {384    return stream[readableStreamReader] !== undefined;385  }386  function IsReadableStreamController(x) {387    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);388  }389  function IsReadableStreamReader(x) {390    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);391  }392  function ReadFromReadableStreamReader(reader) {393    const stream = reader[readableStreamReaderOwnerReadableStream];394    stream[readableStreamBits] |= DISTURBED;395    if (stream[readableStreamState] === STATE_CLOSED) {396      return Promise_resolve(CreateIterResultObject(undefined, true));397    }398    if (stream[readableStreamState] === STATE_ERRORED) {399      return Promise_reject(stream[readableStreamStoredError]);400    }401    const queue = stream[readableStreamQueue];402    if (queue.length > 0) {403      const chunk = DequeueValue(stream);404      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {405        FinishClosingReadableStream(stream);406      } else {407        RequestReadableStreamPull(stream);408      }409      return Promise_resolve(CreateIterResultObject(chunk, false));410    } else {411      const readRequest = v8.createPromise();412      reader[readableStreamReaderReadRequests].push(readRequest);413      RequestReadableStreamPull(stream);414      return readRequest;415    }416  }417  function RequestReadableStreamPull(stream) {418    const shouldPull = ShouldReadableStreamPull(stream);419    if (shouldPull === false) {420      return undefined;421    }422    if (stream[readableStreamBits] & PULLING) {423      stream[readableStreamBits] |= PULL_AGAIN;424      return undefined;425    }426    stream[readableStreamBits] |= PULLING;427    const underlyingSource = stream[readableStreamUnderlyingSource];428    const controller = stream[readableStreamController];429    const pullPromise = PromiseCallOrNoop(430        underlyingSource, 'pull', controller, 'underlyingSource.pull');431    thenPromise(pullPromise,432        () => {433          stream[readableStreamBits] &= ~PULLING;434          if (stream[readableStreamBits] & PULL_AGAIN) {435            stream[readableStreamBits] &= ~PULL_AGAIN;436            return RequestReadableStreamPull(stream);437          }438        },439        e => {440          if (stream[readableStreamState] === STATE_READABLE) {441            return ErrorReadableStream(stream, e);442          }443        });444  }445  function ShouldReadableStreamPull(stream) {446    const state = stream[readableStreamState];447    if (state === STATE_CLOSED || state === STATE_ERRORED) {448      return false;449    }450    if (stream[readableStreamBits] & CLOSE_REQUESTED) {451      return false;452    }453    if (!(stream[readableStreamBits] & STARTED)) {454      return false;455    }456    if (IsReadableStreamLocked(stream) === true) {457      const reader = stream[readableStreamReader];458      const readRequests = reader[readableStreamReaderReadRequests];459      if (readRequests.length > 0) {460        return true;461      }462    }463    const desiredSize = GetReadableStreamDesiredSize(stream);464    if (desiredSize > 0) {465      return true;466    }467    return false;468  }469  // Potential future optimization: use class instances for the underlying470  // sources, so that we don't re-create...

readable_stream.ts

Source:readable_stream.ts

1// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.2import {3  acquireReadableStreamDefaultReader,4  initializeReadableStream,5  isReadableStream,6  isReadableStreamLocked,7  isUnderlyingByteSource,8  isWritableStream,9  isWritableStreamLocked,10  makeSizeAlgorithmFromSizeFunction,11  setFunctionName,12  setPromiseIsHandledToTrue,13  readableStreamCancel,14  ReadableStreamGenericReader,15  readableStreamPipeTo,16  readableStreamTee,17  setUpReadableByteStreamControllerFromUnderlyingSource,18  setUpReadableStreamDefaultControllerFromUnderlyingSource,19  validateAndNormalizeHighWaterMark,20} from "./internals.ts";21import { ReadableByteStreamControllerImpl } from "./readable_byte_stream_controller.ts";22import { ReadableStreamAsyncIteratorPrototype } from "./readable_stream_async_iterator.ts";23import { ReadableStreamDefaultControllerImpl } from "./readable_stream_default_controller.ts";24import * as sym from "./symbols.ts";25import { customInspect } from "../console.ts";26import { AbortSignalImpl } from "../abort_signal.ts";27// eslint-disable-next-line @typescript-eslint/no-explicit-any28export class ReadableStreamImpl<R = any> implements ReadableStream<R> {29  [sym.disturbed]: boolean;30  [sym.readableStreamController]:31    | ReadableStreamDefaultControllerImpl<R>32    | ReadableByteStreamControllerImpl;33  [sym.reader]: ReadableStreamGenericReader<R> | undefined;34  [sym.state]: "readable" | "closed" | "errored";35  // eslint-disable-next-line @typescript-eslint/no-explicit-any36  [sym.storedError]: any;37  constructor(38    underlyingSource: UnderlyingByteSource | UnderlyingSource<R> = {},39    strategy:40      | {41          highWaterMark?: number;42          size?: undefined;43        }44      | QueuingStrategy<R> = {}45  ) {46    initializeReadableStream(this);47    const { size } = strategy;48    let { highWaterMark } = strategy;49    const { type } = underlyingSource;50    if (isUnderlyingByteSource(underlyingSource)) {51      if (size !== undefined) {52        throw new RangeError(53          `When underlying source is "bytes", strategy.size must be undefined.`54        );55      }56      highWaterMark = validateAndNormalizeHighWaterMark(highWaterMark ?? 0);57      setUpReadableByteStreamControllerFromUnderlyingSource(58        this,59        underlyingSource,60        highWaterMark61      );62    } else if (type === undefined) {63      const sizeAlgorithm = makeSizeAlgorithmFromSizeFunction(size);64      highWaterMark = validateAndNormalizeHighWaterMark(highWaterMark ?? 1);65      setUpReadableStreamDefaultControllerFromUnderlyingSource(66        this,67        underlyingSource,68        highWaterMark,69        sizeAlgorithm70      );71    } else {72      throw new RangeError(73        `Valid values for underlyingSource are "bytes" or undefined.  Received: "${type}".`74      );75    }76  }77  get locked(): boolean {78    if (!isReadableStream(this)) {79      throw new TypeError("Invalid ReadableStream.");80    }81    return isReadableStreamLocked(this);82  }83  // eslint-disable-next-line @typescript-eslint/no-explicit-any84  cancel(reason?: any): Promise<void> {85    if (!isReadableStream(this)) {86      return Promise.reject(new TypeError("Invalid ReadableStream."));87    }88    if (isReadableStreamLocked(this)) {89      return Promise.reject(90        new TypeError("Cannot cancel a locked ReadableStream.")91      );92    }93    return readableStreamCancel(this, reason);94  }95  getIterator({96    preventCancel,97  }: { preventCancel?: boolean } = {}): AsyncIterableIterator<R> {98    if (!isReadableStream(this)) {99      throw new TypeError("Invalid ReadableStream.");100    }101    const reader = acquireReadableStreamDefaultReader(this);102    const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);103    iterator[sym.asyncIteratorReader] = reader;104    iterator[sym.preventCancel] = Boolean(preventCancel);105    return iterator;106  }107  getReader({ mode }: { mode?: string } = {}): ReadableStreamDefaultReader<R> {108    if (!isReadableStream(this)) {109      throw new TypeError("Invalid ReadableStream.");110    }111    if (mode === undefined) {112      return acquireReadableStreamDefaultReader(this, true);113    }114    mode = String(mode);115    // 3.2.5.4.4 If mode is "byob", return ? AcquireReadableStreamBYOBReader(this, true).116    throw new RangeError(`Unsupported mode "${mode}"`);117  }118  pipeThrough<T>(119    {120      writable,121      readable,122    }: {123      writable: WritableStream<R>;124      readable: ReadableStream<T>;125    },126    { preventClose, preventAbort, preventCancel, signal }: PipeOptions = {}127  ): ReadableStream<T> {128    if (!isReadableStream(this)) {129      throw new TypeError("Invalid ReadableStream.");130    }131    if (!isWritableStream(writable)) {132      throw new TypeError("writable is not a valid WritableStream.");133    }134    if (!isReadableStream(readable)) {135      throw new TypeError("readable is not a valid ReadableStream.");136    }137    preventClose = Boolean(preventClose);138    preventAbort = Boolean(preventAbort);139    preventCancel = Boolean(preventCancel);140    if (signal && !(signal instanceof AbortSignalImpl)) {141      throw new TypeError("Invalid signal.");142    }143    if (isReadableStreamLocked(this)) {144      throw new TypeError("ReadableStream is locked.");145    }146    if (isWritableStreamLocked(writable)) {147      throw new TypeError("writable is locked.");148    }149    const promise = readableStreamPipeTo(150      this,151      writable,152      preventClose,153      preventAbort,154      preventCancel,155      signal156    );157    setPromiseIsHandledToTrue(promise);158    return readable;159  }160  pipeTo(161    dest: WritableStream<R>,162    { preventClose, preventAbort, preventCancel, signal }: PipeOptions = {}163  ): Promise<void> {164    if (!isReadableStream(this)) {165      return Promise.reject(new TypeError("Invalid ReadableStream."));166    }167    if (!isWritableStream(dest)) {168      return Promise.reject(169        new TypeError("dest is not a valid WritableStream.")170      );171    }172    preventClose = Boolean(preventClose);173    preventAbort = Boolean(preventAbort);174    preventCancel = Boolean(preventCancel);175    if (signal && !(signal instanceof AbortSignalImpl)) {176      return Promise.reject(new TypeError("Invalid signal."));177    }178    if (isReadableStreamLocked(this)) {179      return Promise.reject(new TypeError("ReadableStream is locked."));180    }181    if (isWritableStreamLocked(dest)) {182      return Promise.reject(new TypeError("dest is locked."));183    }184    return readableStreamPipeTo(185      this,186      dest,187      preventClose,188      preventAbort,189      preventCancel,190      signal191    );192  }193  tee(): [ReadableStreamImpl<R>, ReadableStreamImpl<R>] {194    if (!isReadableStream(this)) {195      throw new TypeError("Invalid ReadableStream.");196    }197    return readableStreamTee(this, false);198  }199  [customInspect](): string {200    return `${this.constructor.name} { locked: ${String(this.locked)} }`;201  }202  [Symbol.asyncIterator](203    options: {204      preventCancel?: boolean;205    } = {}206  ): AsyncIterableIterator<R> {207    return this.getIterator(options);208  }209}...

Using AI Code Generation

1const assert = require('assert');2const { ReadableStream, IsReadableStreamLocked } = require('stream/web');3const rs = new ReadableStream({4  pull() {}5});6assert.strictEqual(IsReadableStreamLocked(rs), false);7rs.locked = true;8assert.strictEqual(IsReadableStreamLocked(rs), true);

Using AI Code Generation

1var readableStream = new ReadableStream({2  start(controller) {3    controller.enqueue('a');4    controller.enqueue('b');5    controller.enqueue('c');6  }7});8var reader = readableStream.getReader();9assert_false(reader.isReadableStreamLocked(readableStream), 'IsReadableStreamLocked should return false before locking the readable stream');10reader.releaseLock();11assert_false(reader.isReadableStreamLocked(readableStream), 'IsReadableStreamLocked should return false after releasing the lock');12reader = readableStream.getReader();13assert_true(reader.isReadableStreamLocked(readableStream), 'IsReadableStreamLocked should return true after locking the readable stream');14reader.releaseLock();15assert_false(reader.isReadableStreamLocked(readableStream), 'IsReadableStreamLocked should return false after releasing the lock');16var writableStream = new WritableStream({17  write(chunk, controller) {18  }19});20var writer = writableStream.getWriter();21assert_false(writer.isWritableStreamLocked(writableStream), 'IsWritableStreamLocked should return false before locking the writable stream');22writer.releaseLock();23assert_false(writer.isWritableStreamLocked(writableStream), 'IsWritableStreamLocked should return false after releasing the lock');24writer = writableStream.getWriter();25assert_true(writer.isWritableStreamLocked(writableStream), 'IsWritableStreamLocked should return true after locking the writable stream');26writer.releaseLock();27assert_false(writer.isWritableStreamLocked(writableStream), 'IsWritableStreamLocked should return false after releasing the lock');28var ts = new TransformStream();29var readable = ts.readable;30var writable = ts.writable;31var reader = readable.getReader();32var writer = writable.getWriter();33assert_false(reader.isTransformStreamLocked(ts), 'IsTransformStreamLocked should return false before locking the transform stream');34reader.releaseLock();35writer.releaseLock();36assert_false(reader.isTransformStreamLocked(ts), 'IsTransformStreamLocked should return false after releasing the lock');37reader = readable.getReader();38writer = writable.getWriter();39assert_true(reader.isTransformStreamLocked(ts), 'IsTransformStreamLocked should return true after locking the transform stream');40reader.releaseLock();41writer.releaseLock();

Using AI Code Generation

1var rs = new ReadableStream({2  start(controller) {3    controller.enqueue('a');4    controller.close();5  }6});7var reader = rs.getReader();8assert_true(reader

Using AI Code Generation

1const assert = require('assert');2const { ReadableStream, CountQueuingStrategy } = require('stream/web');3const rs = new ReadableStream({4  start(controller) {5    controller.enqueue('a');6    controller.enqueue('b');7    controller.enqueue('c');8  },9  pull() { },10  cancel() { }11}, new CountQueuingStrategy({ highWaterMark: 100 }));12rs.getReader().releaseLock();13assert.strictEqual(rs.locked, false);14assert.strictEqual(rs.getReader().closed, undefined);15assert.strictEqual(rs.getReader().closed, undefined);16const assert = require('assert');17const { WritableStream } = require('stream/web');18const ws = new WritableStream({19  write() { },20  close() { },21  abort() { }22});23ws.getWriter().releaseLock();24assert.strictEqual(ws.locked, false);25assert.strictEqual(ws.getWriter().closed, undefined);26assert.strictEqual(ws.getWriter().closed, undefined);27const assert = require('assert');28const { TransformStream } = require('stream/web');29const ts = new TransformStream({30  transform() { },31  flush() { }32});33ts.readable.getWriter().releaseLock();34ts.writable.getWriter().releaseLock();35assert.strictEqual(ts.locked, false);36assert.strictEqual(ts.readable.getReader().closed, undefined);37assert.strictEqual(ts.writable.getWriter().closed, undefined);38const assert = require('assert');39const { ReadableStream, CountQueuingStrategy } = require('stream/web');40const rs = new ReadableStream({41  start(controller) {42    controller.enqueue('a');43    controller.enqueue('b');44    controller.enqueue('c');45  },46  pull() { },47  cancel() { }48}, new CountQueuingStrategy({ highWaterMark: 100 }));49rs.getReader().releaseLock();50assert.strictEqual(rs.locked, false);51assert.strictEqual(rs.getReader().closed, undefined);52assert.strictEqual(rs.getReader().closed, undefined);53const assert = require('assert');54const { WritableStream } = require('stream/web');55const ws = new WritableStream({56  write() { },57  close() { },58  abort()

Using AI Code Generation

1const assert = require('assert');2const { ReadableStream, WritableStream, TransformStream } = require('stream/web');3const { isReadableStreamLocked } = require('stream/web');4const readable = new ReadableStream({5  start(controller) {6    controller.enqueue('a');7    controller.enqueue('b');8    controller.enqueue('c');9  }10});11const reader = readable.getReader();12assert(isReadableStreamLocked(readable) === true);13reader.releaseLock();14assert(isReadableStreamLocked(readable) === false);15assert(isReadableStreamLocked(new ReadableStream()) === false);16assert(isReadableStreamLocked(new ReadableStream({ type: 'bytes' })) === false);17  throw new AssertionError(obj);18    at Object.<anonymous> (/home/runner/work/node-whatwg-stream/node-whatwg-stream/test.js:11:8)19    at Module._compile (internal/modules/cjs/loader.js:1200:30)20    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1220:10)21    at Module.load (internal/modules/cjs/loader.js:1050:32)22    at Function.Module._load (internal/modules/cjs/loader.js:938:14)23    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)24    at internal/main/run_main_module.js:17:47 {25}

Using AI Code Generation

1var rs = new ReadableStream({2  start(controller) {3    controller.enqueue("a");4    controller.enqueue("b");5    controller.close();6  }7});8var reader = rs.getReader();9assert_false(reader.isLocked, "The stream should not be locked");10reader.releaseLock();11assert_false(reader.isLocked, "The stream should not be locked");12var rs = new ReadableStream({13  start(controller) {14    controller.enqueue("a");15    controller.enqueue("b");16    controller.close();17  }18});19var reader = rs.getReader();20assert_false(reader.isLocked, "The stream should not be locked");21reader.read().then(function(result) {22  assert_equals(result.value, "a", "The first chunk read should be 'a'");23  assert_equals(result.done, false, "The first chunk read should not be done");24  return reader.read();25}).then(function(result) {26  assert_equals(result.value, "b", "The second chunk read should be 'b'");27  assert_equals(result.done, false, "The second chunk read should not be done");28  return reader.read();29}).then(function(result) {30  assert_equals(result.value, undefined, "The third chunk read should be undefined");31  assert_equals(result.done, true, "The third chunk read should be done");32  assert_false(reader.isLocked, "The stream should not be locked");33  done();34}, unreac

Using AI Code Generation

1'use strict';2const assert = require('assert');3const { ReadableStream } = require('stream/web');4{5  const rs = new ReadableStream({6    start(controller) {7      controller.close();8    }9  });10  assert.strictEqual(rs.locked, false);11  const reader = rs.getReader();12  assert.strictEqual(rs.locked, true);13}14{15  const rs = new ReadableStream();16  assert.strictEqual(rs.locked, false);17  const reader = rs.getReader();18  assert.strictEqual(rs.locked, true);19}20{21  const rs = new ReadableStream({22    start(controller) {23      controller.enqueue('a');24      controller.enqueue('b');25      controller.close();26    }27  });28  assert.strictEqual(rs.locked, false);29  const reader = rs.getReader();30  assert.strictEqual(rs.locked, true);31}32{33  const rs = new ReadableStream();34  assert.strictEqual(rs.locked, false);35  const reader = rs.getReader();36  assert.strictEqual(rs.locked, true);37  reader.releaseLock();38  assert.strictEqual(rs.locked, false);39}40{41  const rs = new ReadableStream();42  assert.strictEqual(rs.locked, false);43  const reader = rs.getReader();44  assert.strictEqual(rs.locked, true);45  reader.releaseLock();46  assert.strictEqual(rs.locked, false);47  const reader2 = rs.getReader();48  assert.strictEqual(rs.locked, true);49}50{51  const rs = new ReadableStream();52  assert.strictEqual(rs.locked, false);53  const reader = rs.getReader();54  assert.strictEqual(rs.locked, true);55  reader.releaseLock();56  assert.strictEqual(rs.locked, false);57  const reader2 = rs.getReader();58  assert.strictEqual(rs.locked, true);59  reader2.releaseLock();60  assert.strictEqual(rs.locked, false);61}62{63  const rs = new ReadableStream();64  assert.strictEqual(rs.locked, false);65  const reader = rs.getReader();66  assert.strictEqual(rs.locked, true);67  reader.releaseLock();68  assert.strictEqual(rs.locked, false);69  const reader2 = rs.getReader();70  assert.strictEqual(rs.locked, true);71  reader2.releaseLock();72  assert.strictEqual(rs.locked, false);73  const reader3 = rs.getReader();74  assert.strictEqual(rs.locked, true);75}76{

Using AI Code Generation

1const stream = new ReadableStream();2const reader = stream.getReader();3const locked = reader.locked;4reader.releaseLock();5const locked1 = reader.locked;6const stream1 = new ReadableStream();7const reader1 = stream1.getReader();8const locked2 = stream1.locked;9const stream2 = new ReadableStream();10const locked3 = stream2.locked;11const stream3 = new ReadableStream();12const reader2 = stream3.getReader();13const reader3 = stream3.getReader();14const locked4 = reader2.locked;15const locked5 = reader3.locked;16const stream4 = new ReadableStream();17const reader4 = stream4.getReader();18const reader5 = stream4.getReader();19reader4.releaseLock();20const locked6 = reader4.locked;21const locked7 = reader5.locked;22const stream = new WritableStream();23const writer = stream.getWriter();24const locked = writer.locked;25writer.releaseLock();26const locked1 = writer.locked;27const stream1 = new WritableStream();28const writer1 = stream1.getWriter();29const locked2 = stream1.locked;30const stream2 = new WritableStream();31const locked3 = stream2.locked;32const stream3 = new WritableStream();33const writer2 = stream3.getWriter();34const writer3 = stream3.getWriter();35const locked4 = writer2.locked;36const locked5 = writer3.locked;37const stream4 = new WritableStream();38const writer4 = stream4.getWriter();39const writer5 = stream4.getWriter();40writer4.releaseLock();41const locked6 = writer4.locked;42const locked7 = writer5.locked;43console.log(locked

Using AI Code Generation

1var rs = new ReadableStream();2rs.getReader();3var locked = rs.locked;4console.log(locked);5var rs = new ReadableStream();6rs.getReader();7var disturbed = rs.disturbed;8console.log(disturbed);9var rs = new ReadableStream();10var reader = rs.getReader();11var locked = reader.locked;12console.log(locked);13var ws = new WritableStream();14ws.getWriter();15var locked = ws.locked;16console.log(locked);17var ws = new WritableStream();18var writer = ws.getWriter();19var locked = writer.locked;20console.log(locked);21var ws = new WritableStream();22var writer = ws.getWriter();23var ready = writer.ready;24console.log(ready);25var ws = new WritableStream();26var writer = ws.getWriter();27var closed = writer.closed;28console.log(closed);29var ts = new TransformStream();30var controller = ts.writable.getWriter();31var active = controller.active;32console.log(active);33var ts = new TransformStream();34var controller = ts.writable.getWriter();35var started = controller.started;36console.log(started);37var ts = new TransformStream();38var controller = ts.writable.getWriter();39var closing = controller.closing;40console.log(closing);41var ts = new TransformStream();42var controller = ts.writable.getWriter();43var errored = controller.errored;44console.log(errored);45var ts = new TransformStream();46var controller = ts.writable.getWriter();47var flushAlgorithmSet = controller.flushAlgorithmSet;48console.log(flushAlgorithmSet);

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.