KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use defaultReaderClosedPromiseResetToRejected method in wpt
Best JavaScript code snippet using wpt
readable-stream.js
Source:readable-stream.js 
...624 defaultReaderClosedPromiseReject(625 reader,626 new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));627 } else {628 defaultReaderClosedPromiseResetToRejected(629 reader,630 new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));631 }632 reader._closedPromise.catch(() => {});633 reader._ownerReadableStream._reader = undefined;634 reader._ownerReadableStream = undefined;635}636function ReadableStreamBYOBReaderRead(reader, view) {637 const stream = reader._ownerReadableStream;638 assert(stream !== undefined);639 stream._disturbed = true;640 if (stream._state === 'errored') {641 return Promise.reject(stream._storedError);642 }643 // Controllers must implement this.644 return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);645}646function ReadableStreamDefaultReaderRead(reader) {647 const stream = reader._ownerReadableStream;648 assert(stream !== undefined);649 stream._disturbed = true;650 if (stream._state === 'closed') {651 return Promise.resolve(CreateIterResultObject(undefined, true));652 }653 if (stream._state === 'errored') {654 return Promise.reject(stream._storedError);655 }656 assert(stream._state === 'readable');657 return stream._readableStreamController[InternalPull]();658}659// Controllers660class ReadableStreamDefaultController {661 constructor(stream, underlyingSource, size, highWaterMark) {662 if (IsReadableStream(stream) === false) {663 throw new TypeError('ReadableStreamDefaultController can only be constructed with a ReadableStream instance');664 }665 if (stream._readableStreamController !== undefined) {666 throw new TypeError(667 'ReadableStreamDefaultController instances can only be created by the ReadableStream constructor');668 }669 this._controlledReadableStream = stream;670 this._underlyingSource = underlyingSource;671 this._queue = [];672 this._started = false;673 this._closeRequested = false;674 this._pullAgain = false;675 this._pulling = false;676 const normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);677 this._strategySize = normalizedStrategy.size;678 this._strategyHWM = normalizedStrategy.highWaterMark;679 const controller = this;680 const startResult = InvokeOrNoop(underlyingSource, 'start', [this]);681 Promise.resolve(startResult).then(682 () => {683 controller._started = true;684 assert(controller._pulling === false);685 assert(controller._pullAgain === false);686 ReadableStreamDefaultControllerCallPullIfNeeded(controller);687 },688 r => {689 ReadableStreamDefaultControllerErrorIfNeeded(controller, r);690 }691 )692 .catch(rethrowAssertionErrorRejection);693 }694 get desiredSize() {695 if (IsReadableStreamDefaultController(this) === false) {696 throw defaultControllerBrandCheckException('desiredSize');697 }698 return ReadableStreamDefaultControllerGetDesiredSize(this);699 }700 close() {701 if (IsReadableStreamDefaultController(this) === false) {702 throw defaultControllerBrandCheckException('close');703 }704 if (this._closeRequested === true) {705 throw new TypeError('The stream has already been closed; do not close it again!');706 }707 const state = this._controlledReadableStream._state;708 if (state !== 'readable') {709 throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);710 }711 ReadableStreamDefaultControllerClose(this);712 }713 enqueue(chunk) {714 if (IsReadableStreamDefaultController(this) === false) {715 throw defaultControllerBrandCheckException('enqueue');716 }717 if (this._closeRequested === true) {718 throw new TypeError('stream is closed or draining');719 }720 const state = this._controlledReadableStream._state;721 if (state !== 'readable') {722 throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);723 }724 return ReadableStreamDefaultControllerEnqueue(this, chunk);725 }726 error(e) {727 if (IsReadableStreamDefaultController(this) === false) {728 throw defaultControllerBrandCheckException('error');729 }730 const stream = this._controlledReadableStream;731 if (stream._state !== 'readable') {732 throw new TypeError(`The stream is ${stream._state} and so cannot be errored`);733 }734 ReadableStreamDefaultControllerError(this, e);735 }736 [InternalCancel](reason) {737 this._queue = [];738 return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);739 }740 [InternalPull]() {741 const stream = this._controlledReadableStream;742 if (this._queue.length > 0) {743 const chunk = DequeueValue(this._queue);744 if (this._closeRequested === true && this._queue.length === 0) {745 ReadableStreamClose(stream);746 } else {747 ReadableStreamDefaultControllerCallPullIfNeeded(this);748 }749 return Promise.resolve(CreateIterResultObject(chunk, false));750 }751 const pendingPromise = ReadableStreamAddReadRequest(stream);752 ReadableStreamDefaultControllerCallPullIfNeeded(this);753 return pendingPromise;754 }755}756// Abstract operations for the ReadableStreamDefaultController.757function IsReadableStreamDefaultController(x) {758 if (!typeIsObject(x)) {759 return false;760 }761 if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {762 return false;763 }764 return true;765}766function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {767 const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);768 if (shouldPull === false) {769 return undefined;770 }771 if (controller._pulling === true) {772 controller._pullAgain = true;773 return undefined;774 }775 assert(controller._pullAgain === false);776 controller._pulling = true;777 const pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);778 pullPromise.then(779 () => {780 controller._pulling = false;781 if (controller._pullAgain === true) {782 controller._pullAgain = false;783 return ReadableStreamDefaultControllerCallPullIfNeeded(controller);784 }785 return undefined;786 },787 e => {788 ReadableStreamDefaultControllerErrorIfNeeded(controller, e);789 }790 )791 .catch(rethrowAssertionErrorRejection);792 return undefined;793}794function ReadableStreamDefaultControllerShouldCallPull(controller) {795 const stream = controller._controlledReadableStream;796 if (stream._state === 'closed' || stream._state === 'errored') {797 return false;798 }799 if (controller._closeRequested === true) {800 return false;801 }802 if (controller._started === false) {803 return false;804 }805 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {806 return true;807 }808 const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);809 if (desiredSize > 0) {810 return true;811 }812 return false;813}814// A client of ReadableStreamDefaultController may use these functions directly to bypass state check.815function ReadableStreamDefaultControllerClose(controller) {816 const stream = controller._controlledReadableStream;817 assert(controller._closeRequested === false);818 assert(stream._state === 'readable');819 controller._closeRequested = true;820 if (controller._queue.length === 0) {821 ReadableStreamClose(stream);822 }823}824function ReadableStreamDefaultControllerEnqueue(controller, chunk) {825 const stream = controller._controlledReadableStream;826 assert(controller._closeRequested === false);827 assert(stream._state === 'readable');828 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {829 ReadableStreamFulfillReadRequest(stream, chunk, false);830 } else {831 let chunkSize = 1;832 if (controller._strategySize !== undefined) {833 const strategySize = controller._strategySize;834 try {835 chunkSize = strategySize(chunk);836 } catch (chunkSizeE) {837 ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);838 throw chunkSizeE;839 }840 }841 try {842 EnqueueValueWithSize(controller._queue, chunk, chunkSize);843 } catch (enqueueE) {844 ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);845 throw enqueueE;846 }847 }848 ReadableStreamDefaultControllerCallPullIfNeeded(controller);849 return undefined;850}851function ReadableStreamDefaultControllerError(controller, e) {852 const stream = controller._controlledReadableStream;853 assert(stream._state === 'readable');854 controller._queue = [];855 ReadableStreamError(stream, e);856}857function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {858 if (controller._controlledReadableStream._state === 'readable') {859 ReadableStreamDefaultControllerError(controller, e);860 }861}862function ReadableStreamDefaultControllerGetDesiredSize(controller) {863 const queueSize = GetTotalQueueSize(controller._queue);864 return controller._strategyHWM - queueSize;865}866class ReadableStreamBYOBRequest {867 constructor(controller, view) {868 this._associatedReadableByteStreamController = controller;869 this._view = view;870 }871 get view() {872 return this._view;873 }874 respond(bytesWritten) {875 if (IsReadableStreamBYOBRequest(this) === false) {876 throw byobRequestBrandCheckException('respond');877 }878 if (this._associatedReadableByteStreamController === undefined) {879 throw new TypeError('This BYOB request has been invalidated');880 }881 ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);882 }883 respondWithNewView(view) {884 if (IsReadableStreamBYOBRequest(this) === false) {885 throw byobRequestBrandCheckException('respond');886 }887 if (this._associatedReadableByteStreamController === undefined) {888 throw new TypeError('This BYOB request has been invalidated');889 }890 if (!ArrayBuffer.isView(view)) {891 throw new TypeError('You can only respond with array buffer views');892 }893 ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);894 }895}896class ReadableByteStreamController {897 constructor(stream, underlyingByteSource, highWaterMark) {898 if (IsReadableStream(stream) === false) {899 throw new TypeError('ReadableByteStreamController can only be constructed with a ReadableStream instance given ' +900 'a byte source');901 }902 if (stream._readableStreamController !== undefined) {903 throw new TypeError(904 'ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte ' +905 'source');906 }907 this._controlledReadableStream = stream;908 this._underlyingByteSource = underlyingByteSource;909 this._pullAgain = false;910 this._pulling = false;911 ReadableByteStreamControllerClearPendingPullIntos(this);912 this._queue = [];913 this._totalQueuedBytes = 0;914 this._closeRequested = false;915 this._started = false;916 this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);917 const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;918 if (autoAllocateChunkSize !== undefined) {919 if (Number.isInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {920 throw new RangeError('autoAllocateChunkSize must be a positive integer');921 }922 }923 this._autoAllocateChunkSize = autoAllocateChunkSize;924 this._pendingPullIntos = [];925 const controller = this;926 const startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);927 Promise.resolve(startResult).then(928 () => {929 controller._started = true;930 assert(controller._pulling === false);931 assert(controller._pullAgain === false);932 ReadableByteStreamControllerCallPullIfNeeded(controller);933 },934 r => {935 if (stream._state === 'readable') {936 ReadableByteStreamControllerError(controller, r);937 }938 }939 )940 .catch(rethrowAssertionErrorRejection);941 }942 get byobRequest() {943 if (IsReadableByteStreamController(this) === false) {944 throw byteStreamControllerBrandCheckException('byobRequest');945 }946 if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {947 const firstDescriptor = this._pendingPullIntos[0];948 const view = new Uint8Array(firstDescriptor.buffer,949 firstDescriptor.byteOffset + firstDescriptor.bytesFilled,950 firstDescriptor.byteLength - firstDescriptor.bytesFilled);951 this._byobRequest = new ReadableStreamBYOBRequest(this, view);952 }953 return this._byobRequest;954 }955 get desiredSize() {956 if (IsReadableByteStreamController(this) === false) {957 throw byteStreamControllerBrandCheckException('desiredSize');958 }959 return ReadableByteStreamControllerGetDesiredSize(this);960 }961 close() {962 if (IsReadableByteStreamController(this) === false) {963 throw byteStreamControllerBrandCheckException('close');964 }965 if (this._closeRequested === true) {966 throw new TypeError('The stream has already been closed; do not close it again!');967 }968 const state = this._controlledReadableStream._state;969 if (state !== 'readable') {970 throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);971 }972 ReadableByteStreamControllerClose(this);973 }974 enqueue(chunk) {975 if (IsReadableByteStreamController(this) === false) {976 throw byteStreamControllerBrandCheckException('enqueue');977 }978 if (this._closeRequested === true) {979 throw new TypeError('stream is closed or draining');980 }981 const state = this._controlledReadableStream._state;982 if (state !== 'readable') {983 throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);984 }985 if (!ArrayBuffer.isView(chunk)) {986 throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');987 }988 ReadableByteStreamControllerEnqueue(this, chunk);989 }990 error(e) {991 if (IsReadableByteStreamController(this) === false) {992 throw byteStreamControllerBrandCheckException('error');993 }994 const stream = this._controlledReadableStream;995 if (stream._state !== 'readable') {996 throw new TypeError(`The stream is ${stream._state} and so cannot be errored`);997 }998 ReadableByteStreamControllerError(this, e);999 }1000 [InternalCancel](reason) {1001 if (this._pendingPullIntos.length > 0) {1002 const firstDescriptor = this._pendingPullIntos[0];1003 firstDescriptor.bytesFilled = 0;1004 }1005 this._queue = [];1006 this._totalQueuedBytes = 0;1007 return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);1008 }1009 [InternalPull]() {1010 const stream = this._controlledReadableStream;1011 assert(ReadableStreamHasDefaultReader(stream) === true);1012 if (this._totalQueuedBytes > 0) {1013 assert(ReadableStreamGetNumReadRequests(stream) === 0);1014 const entry = this._queue.shift();1015 this._totalQueuedBytes -= entry.byteLength;1016 ReadableByteStreamControllerHandleQueueDrain(this);1017 let view;1018 try {1019 view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);1020 } catch (viewE) {1021 return Promise.reject(viewE);1022 }1023 return Promise.resolve(CreateIterResultObject(view, false));1024 }1025 const autoAllocateChunkSize = this._autoAllocateChunkSize;1026 if (autoAllocateChunkSize !== undefined) {1027 let buffer;1028 try {1029 buffer = new ArrayBuffer(autoAllocateChunkSize);1030 } catch (bufferE) {1031 return Promise.reject(bufferE);1032 }1033 const pullIntoDescriptor = {1034 buffer,1035 byteOffset: 0,1036 byteLength: autoAllocateChunkSize,1037 bytesFilled: 0,1038 elementSize: 1,1039 ctor: Uint8Array,1040 readerType: 'default'1041 };1042 this._pendingPullIntos.push(pullIntoDescriptor);1043 }1044 const promise = ReadableStreamAddReadRequest(stream);1045 ReadableByteStreamControllerCallPullIfNeeded(this);1046 return promise;1047 }1048}1049// Abstract operations for the ReadableByteStreamController.1050function IsReadableByteStreamController(x) {1051 if (!typeIsObject(x)) {1052 return false;1053 }1054 if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {1055 return false;1056 }1057 return true;1058}1059function IsReadableStreamBYOBRequest(x) {1060 if (!typeIsObject(x)) {1061 return false;1062 }1063 if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {1064 return false;1065 }1066 return true;1067}1068function ReadableByteStreamControllerCallPullIfNeeded(controller) {1069 const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);1070 if (shouldPull === false) {1071 return undefined;1072 }1073 if (controller._pulling === true) {1074 controller._pullAgain = true;1075 return undefined;1076 }1077 assert(controller._pullAgain === false);1078 controller._pulling = true;1079 // TODO: Test controller argument1080 const pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);1081 pullPromise.then(1082 () => {1083 controller._pulling = false;1084 if (controller._pullAgain === true) {1085 controller._pullAgain = false;1086 ReadableByteStreamControllerCallPullIfNeeded(controller);1087 }1088 },1089 e => {1090 if (controller._controlledReadableStream._state === 'readable') {1091 ReadableByteStreamControllerError(controller, e);1092 }1093 }1094 )1095 .catch(rethrowAssertionErrorRejection);1096 return undefined;1097}1098function ReadableByteStreamControllerClearPendingPullIntos(controller) {1099 ReadableByteStreamControllerInvalidateBYOBRequest(controller);1100 controller._pendingPullIntos = [];1101}1102function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {1103 assert(stream._state !== 'errored', 'state must not be errored');1104 let done = false;1105 if (stream._state === 'closed') {1106 assert(pullIntoDescriptor.bytesFilled === 0);1107 done = true;1108 }1109 const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);1110 if (pullIntoDescriptor.readerType === 'default') {1111 ReadableStreamFulfillReadRequest(stream, filledView, done);1112 } else {1113 assert(pullIntoDescriptor.readerType === 'byob');1114 ReadableStreamFulfillReadIntoRequest(stream, filledView, done);1115 }1116}1117function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {1118 const bytesFilled = pullIntoDescriptor.bytesFilled;1119 const elementSize = pullIntoDescriptor.elementSize;1120 assert(bytesFilled <= pullIntoDescriptor.byteLength);1121 assert(bytesFilled % elementSize === 0);1122 return new pullIntoDescriptor.ctor(1123 pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);1124}1125function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {1126 controller._queue.push({ buffer, byteOffset, byteLength });1127 controller._totalQueuedBytes += byteLength;1128}1129function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {1130 const elementSize = pullIntoDescriptor.elementSize;1131 const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;1132 const maxBytesToCopy = Math.min(controller._totalQueuedBytes,1133 pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);1134 const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;1135 const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;1136 let totalBytesToCopyRemaining = maxBytesToCopy;1137 let ready = false;1138 if (maxAlignedBytes > currentAlignedBytes) {1139 totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;1140 ready = true;1141 }1142 const queue = controller._queue;1143 while (totalBytesToCopyRemaining > 0) {1144 const headOfQueue = queue[0];1145 const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);1146 const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;1147 ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);1148 if (headOfQueue.byteLength === bytesToCopy) {1149 queue.shift();1150 } else {1151 headOfQueue.byteOffset += bytesToCopy;1152 headOfQueue.byteLength -= bytesToCopy;1153 }1154 controller._totalQueuedBytes -= bytesToCopy;1155 ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);1156 totalBytesToCopyRemaining -= bytesToCopy;1157 }1158 if (ready === false) {1159 assert(controller._totalQueuedBytes === 0, 'queue must be empty');1160 assert(pullIntoDescriptor.bytesFilled > 0);1161 assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);1162 }1163 return ready;1164}1165function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {1166 assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDescriptor);1167 ReadableByteStreamControllerInvalidateBYOBRequest(controller);1168 pullIntoDescriptor.bytesFilled += size;1169}1170function ReadableByteStreamControllerHandleQueueDrain(controller) {1171 assert(controller._controlledReadableStream._state === 'readable');1172 if (controller._totalQueuedBytes === 0 && controller._closeRequested === true) {1173 ReadableStreamClose(controller._controlledReadableStream);1174 } else {1175 ReadableByteStreamControllerCallPullIfNeeded(controller);1176 }1177}1178function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {1179 if (controller._byobRequest === undefined) {1180 return;1181 }1182 controller._byobRequest._associatedReadableByteStreamController = undefined;1183 controller._byobRequest._view = undefined;1184 controller._byobRequest = undefined;1185}1186function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {1187 assert(controller._closeRequested === false);1188 while (controller._pendingPullIntos.length > 0) {1189 if (controller._totalQueuedBytes === 0) {1190 return;1191 }1192 const pullIntoDescriptor = controller._pendingPullIntos[0];1193 if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {1194 ReadableByteStreamControllerShiftPendingPullInto(controller);1195 ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);1196 }1197 }1198}1199function ReadableByteStreamControllerPullInto(controller, view) {1200 const stream = controller._controlledReadableStream;1201 let elementSize = 1;1202 if (view.constructor !== DataView) {1203 elementSize = view.constructor.BYTES_PER_ELEMENT;1204 }1205 const ctor = view.constructor;1206 const pullIntoDescriptor = {1207 buffer: view.buffer,1208 byteOffset: view.byteOffset,1209 byteLength: view.byteLength,1210 bytesFilled: 0,1211 elementSize,1212 ctor,1213 readerType: 'byob'1214 };1215 if (controller._pendingPullIntos.length > 0) {1216 pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);1217 controller._pendingPullIntos.push(pullIntoDescriptor);1218 // No ReadableByteStreamControllerCallPullIfNeeded() call since:1219 // - No change happens on desiredSize1220 // - The source has already been notified of that there's at least 1 pending read(view)1221 return ReadableStreamAddReadIntoRequest(stream);1222 }1223 if (stream._state === 'closed') {1224 const emptyView = new view.constructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);1225 return Promise.resolve(CreateIterResultObject(emptyView, true));1226 }1227 if (controller._totalQueuedBytes > 0) {1228 if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {1229 const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);1230 ReadableByteStreamControllerHandleQueueDrain(controller);1231 return Promise.resolve(CreateIterResultObject(filledView, false));1232 }1233 if (controller._closeRequested === true) {1234 const e = new TypeError('Insufficient bytes to fill elements in the given buffer');1235 ReadableByteStreamControllerError(controller, e);1236 return Promise.reject(e);1237 }1238 }1239 pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);1240 controller._pendingPullIntos.push(pullIntoDescriptor);1241 const promise = ReadableStreamAddReadIntoRequest(stream);1242 ReadableByteStreamControllerCallPullIfNeeded(controller);1243 return promise;1244}1245function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {1246 firstDescriptor.buffer = SameRealmTransfer(firstDescriptor.buffer);1247 assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');1248 const stream = controller._controlledReadableStream;1249 while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {1250 const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);1251 ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);1252 }1253}1254function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {1255 if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {1256 throw new RangeError('bytesWritten out of range');1257 }1258 ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);1259 if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {1260 // TODO: Figure out whether we should detach the buffer or not here.1261 return;1262 }1263 ReadableByteStreamControllerShiftPendingPullInto(controller);1264 const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;1265 if (remainderSize > 0) {1266 const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;1267 const remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);1268 ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);1269 }1270 pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);1271 pullIntoDescriptor.bytesFilled -= remainderSize;1272 ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);1273 ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);1274}1275function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {1276 const firstDescriptor = controller._pendingPullIntos[0];1277 const stream = controller._controlledReadableStream;1278 if (stream._state === 'closed') {1279 if (bytesWritten !== 0) {1280 throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');1281 }1282 ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);1283 } else {1284 assert(stream._state === 'readable');1285 ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);1286 }1287}1288function ReadableByteStreamControllerShiftPendingPullInto(controller) {1289 const descriptor = controller._pendingPullIntos.shift();1290 ReadableByteStreamControllerInvalidateBYOBRequest(controller);1291 return descriptor;1292}1293function ReadableByteStreamControllerShouldCallPull(controller) {1294 const stream = controller._controlledReadableStream;1295 if (stream._state !== 'readable') {1296 return false;1297 }1298 if (controller._closeRequested === true) {1299 return false;1300 }1301 if (controller._started === false) {1302 return false;1303 }1304 if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {1305 return true;1306 }1307 if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {1308 return true;1309 }1310 if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {1311 return true;1312 }1313 return false;1314}1315// A client of ReadableByteStreamController may use these functions directly to bypass state check.1316function ReadableByteStreamControllerClose(controller) {1317 const stream = controller._controlledReadableStream;1318 assert(controller._closeRequested === false);1319 assert(stream._state === 'readable');1320 if (controller._totalQueuedBytes > 0) {1321 controller._closeRequested = true;1322 return;1323 }1324 if (controller._pendingPullIntos.length > 0) {1325 const firstPendingPullInto = controller._pendingPullIntos[0];1326 if (firstPendingPullInto.bytesFilled > 0) {1327 const e = new TypeError('Insufficient bytes to fill elements in the given buffer');1328 ReadableByteStreamControllerError(controller, e);1329 throw e;1330 }1331 }1332 ReadableStreamClose(stream);1333}1334function ReadableByteStreamControllerEnqueue(controller, chunk) {1335 const stream = controller._controlledReadableStream;1336 assert(controller._closeRequested === false);1337 assert(stream._state === 'readable');1338 const buffer = chunk.buffer;1339 const byteOffset = chunk.byteOffset;1340 const byteLength = chunk.byteLength;1341 const transferredBuffer = SameRealmTransfer(buffer);1342 if (ReadableStreamHasDefaultReader(stream) === true) {1343 if (ReadableStreamGetNumReadRequests(stream) === 0) {1344 ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);1345 } else {1346 assert(controller._queue.length === 0);1347 const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);1348 ReadableStreamFulfillReadRequest(stream, transferredView, false);1349 }1350 } else if (ReadableStreamHasBYOBReader(stream) === true) {1351 // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.1352 ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);1353 ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);1354 } else {1355 assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');1356 ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);1357 }1358}1359function ReadableByteStreamControllerError(controller, e) {1360 const stream = controller._controlledReadableStream;1361 assert(stream._state === 'readable');1362 ReadableByteStreamControllerClearPendingPullIntos(controller);1363 controller._queue = [];1364 ReadableStreamError(stream, e);1365}1366function ReadableByteStreamControllerGetDesiredSize(controller) {1367 return controller._strategyHWM - controller._totalQueuedBytes;1368}1369function ReadableByteStreamControllerRespond(controller, bytesWritten) {1370 bytesWritten = Number(bytesWritten);1371 if (IsFiniteNonNegativeNumber(bytesWritten) === false) {1372 throw new RangeError('bytesWritten must be a finite');1373 }1374 assert(controller._pendingPullIntos.length > 0);1375 ReadableByteStreamControllerRespondInternal(controller, bytesWritten);1376}1377function ReadableByteStreamControllerRespondWithNewView(controller, view) {1378 assert(controller._pendingPullIntos.length > 0);1379 const firstDescriptor = controller._pendingPullIntos[0];1380 if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {1381 throw new RangeError('The region specified by view does not match byobRequest');1382 }1383 if (firstDescriptor.byteLength !== view.byteLength) {1384 throw new RangeError('The buffer of view has different capacity than byobRequest');1385 }1386 firstDescriptor.buffer = view.buffer;1387 ReadableByteStreamControllerRespondInternal(controller, view.byteLength);1388}1389// Helper functions for the ReadableStream.1390function streamBrandCheckException(name) {1391 return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);1392}1393// Helper functions for the readers.1394function readerLockException(name) {1395 return new TypeError('Cannot ' + name + ' a stream using a released reader');1396}1397// Helper functions for the ReadableStreamDefaultReader.1398function defaultReaderBrandCheckException(name) {1399 return new TypeError(1400 `ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);1401}1402function defaultReaderClosedPromiseInitialize(reader) {1403 reader._closedPromise = new Promise((resolve, reject) => {1404 reader._closedPromise_resolve = resolve;1405 reader._closedPromise_reject = reject;1406 });1407}1408function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {1409 reader._closedPromise = Promise.reject(reason);1410 reader._closedPromise_resolve = undefined;1411 reader._closedPromise_reject = undefined;1412}1413function defaultReaderClosedPromiseInitializeAsResolved(reader) {1414 reader._closedPromise = Promise.resolve(undefined);1415 reader._closedPromise_resolve = undefined;1416 reader._closedPromise_reject = undefined;1417}1418function defaultReaderClosedPromiseReject(reader, reason) {1419 assert(reader._closedPromise_resolve !== undefined);1420 assert(reader._closedPromise_reject !== undefined);1421 reader._closedPromise_reject(reason);1422 reader._closedPromise_resolve = undefined;1423 reader._closedPromise_reject = undefined;1424}1425function defaultReaderClosedPromiseResetToRejected(reader, reason) {1426 assert(reader._closedPromise_resolve === undefined);1427 assert(reader._closedPromise_reject === undefined);1428 reader._closedPromise = Promise.reject(reason);1429}1430function defaultReaderClosedPromiseResolve(reader) {1431 assert(reader._closedPromise_resolve !== undefined);1432 assert(reader._closedPromise_reject !== undefined);1433 reader._closedPromise_resolve(undefined);1434 reader._closedPromise_resolve = undefined;1435 reader._closedPromise_reject = undefined;1436}1437// Helper functions for the ReadableStreamDefaultReader.1438function byobReaderBrandCheckException(name) {1439 return new TypeError(...
generic-reader.ts
Source:generic-reader.ts
...27 defaultReaderClosedPromiseReject(28 reader,29 new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));30 } else {31 defaultReaderClosedPromiseResetToRejected(32 reader,33 new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));34 }35 reader._ownerReadableStream._reader = undefined;36 reader._ownerReadableStream = undefined!;37}38// Helper functions for the readers.39export function readerLockException(name: string): TypeError {40 return new TypeError('Cannot ' + name + ' a stream using a released reader');41}42// Helper functions for the ReadableStreamDefaultReader.43export function defaultReaderClosedPromiseInitialize(reader: ReadableStreamReader<any>) {44 reader._closedPromise = newPromise((resolve, reject) => {45 reader._closedPromise_resolve = resolve;46 reader._closedPromise_reject = reject;47 });48}49export function defaultReaderClosedPromiseInitializeAsRejected(reader: ReadableStreamReader<any>, reason: any) {50 defaultReaderClosedPromiseInitialize(reader);51 defaultReaderClosedPromiseReject(reader, reason);52}53export function defaultReaderClosedPromiseInitializeAsResolved(reader: ReadableStreamReader<any>) {54 defaultReaderClosedPromiseInitialize(reader);55 defaultReaderClosedPromiseResolve(reader);56}57export function defaultReaderClosedPromiseReject(reader: ReadableStreamReader<any>, reason: any) {58 assert(reader._closedPromise_resolve !== undefined);59 assert(reader._closedPromise_reject !== undefined);60 setPromiseIsHandledToTrue(reader._closedPromise);61 reader._closedPromise_reject!(reason);62 reader._closedPromise_resolve = undefined;63 reader._closedPromise_reject = undefined;64}65export function defaultReaderClosedPromiseResetToRejected(reader: ReadableStreamReader<any>, reason: any) {66 assert(reader._closedPromise_resolve === undefined);67 assert(reader._closedPromise_reject === undefined);68 defaultReaderClosedPromiseInitializeAsRejected(reader, reason);69}70export function defaultReaderClosedPromiseResolve(reader: ReadableStreamReader<any>) {71 assert(reader._closedPromise_resolve !== undefined);72 assert(reader._closedPromise_reject !== undefined);73 reader._closedPromise_resolve!(undefined);74 reader._closedPromise_resolve = undefined;75 reader._closedPromise_reject = undefined;...
Using AI Code Generation
1self.defaultReaderClosedPromiseResetToRejected();2self.defaultWriterClosedPromiseResetToRejected();3self.defaultWriterReadyPromiseResetToRejected();4self.defaultWriterReadyPromiseResetToRejectedWithException('Exception');5self.error1();6self.error2();7self.error3();8self.error4();9self.error5();10self.error6();11self.error7();12self.error8();13self.error9();14self.error10();15self.error11();16self.error12();17self.error13();18self.error14();19self.error15();20self.error16();21self.error17();22self.error18();23self.error19();24self.error20();25self.error21();26self.error22();27self.error23();28self.error24();29self.error25();30self.error26();31self.error27();
Using AI Code Generation
1const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;2const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;3const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;4const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;5const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;6const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;7const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;8const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;9const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;10const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;11const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;12const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;13const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;
Using AI Code Generation
1var defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;2var rs = new ReadableStream({3 start(controller) {4 controller.enqueue('a');5 controller.close();6 }7});8var reader = rs.getReader();9reader.read().then(result => {10 assert_equals(result.value, 'a');11 assert_true(result.done);12 return defaultReaderClosedPromiseResetToRejected(reader, new Error('oops'));13}).then(() => {14 return reader.read();15}).then(result => {16 assert_equals(result.value, undefined);17 assert_true(result.done);18}).catch(e => {19 assert_unreached(e);20});21var defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;22var rs = new ReadableStream({23 start(controller) {24 controller.enqueue('a');25 controller.close();26 }27});28var reader = rs.getReader();29reader.read().then(result => {30 assert_equals(result.value, 'a');31 assert_true(result.done);32 return defaultReaderClosedPromiseResetToRejected(reader, new Error('oops'));33}).then(() => {34 return reader.read();35}).then(result => {36 assert_equals(result.value, undefined);37 assert_true(result.done);38}).catch(e => {39 assert_unreached(e);40});41var defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;42var rs = new ReadableStream({43 start(controller) {44 controller.enqueue('a');45 controller.close();46 }47});48var reader = rs.getReader();49reader.read().then(result => {50 assert_equals(result.value, 'a');51 assert_true(result.done);52 return defaultReaderClosedPromiseResetToRejected(reader, new Error('oops'));53}).then(() => {54 return reader.read();55}).then(result => {56 assert_equals(result.value, undefined);57 assert_true(result.done);58}).catch(e => {59 assert_unreached(e);60});61var defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;62var rs = new ReadableStream({63 start(controller) {64 controller.enqueue('
Using AI Code Generation
1const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;2const readableStream = new ReadableStream();3const reader = readableStream.getReader();4defaultReaderClosedPromiseResetToRejected(reader);5const closedPromise = reader.closed;6assert_equals(closedPromise.constructor.name, 'Promise');7assert_equals(closedPromise._state, 'rejected');8assert_equals(closedPromise._result.constructor.name, 'TypeError');9assert_equals(closedPromise._result.message, 'closed promise is already rejected');10done();
Using AI Code Generation
1test(() => {2 const ws = new WritableStream({3 write() {4 return new Promise(resolve => {5 setTimeout(resolve, 1000);6 });7 }8 });9 const writer = ws.getWriter();10 const writePromise = writer.write('a');11 writer.releaseLock();12 return writePromise.then(() => {13 return promise_rejects(t, new TypeError(), ws.abort());14 });15}, 'abort() rejects if the stream is errored and there is a pending write()');16test(() => {17 const ws = new WritableStream();18 const writer = ws.getWriter();19 writer.releaseLock();20 return promise_rejects(t, new TypeError(), ws.abort());21}, 'abort() rejects if the stream is errored and there is a pending write()');22test(() => {23 const ws = new WritableStream();24 const writer = ws.getWriter();25 writer.releaseLock();26 return promise_rejects(t, new TypeError(), ws.abort());27}, 'abort() rejects if the stream is errored and there is a pending write()');28test(() => {29 const ws = new WritableStream();30 const writer = ws.getWriter();31 writer.releaseLock();32 return promise_rejects(t, new TypeError(), ws.abort());33}, 'abort() rejects if the stream is errored and there is a pending write()');34test(() => {35 const ws = new WritableStream();36 const writer = ws.getWriter();37 writer.releaseLock();38 return promise_rejects(t, new TypeError(), ws.abort());39}, 'abort() rejects if the stream is errored and there is a pending write()');40test(() => {41 const ws = new WritableStream();42 const writer = ws.getWriter();43 writer.releaseLock();44 return promise_rejects(t, new TypeError(), ws.abort());45}, 'abort() rejects if the stream is errored and there is
Using AI Code Generation
1promise_test(async t => {2 const stream = new ReadableStream({3 start(controller) {4 controller.close();5 }6 });7 const reader = stream.getReader();8 await reader.closed;9 const defaultReaderClosedPromiseResetToRejected = reader.closed.catch(() => {});10 await defaultReaderClosedPromiseResetToRejected;11}, 'Test defaultReaderClosedPromiseResetToRejected method of wpt');12Uncaught (in promise) TypeError: Cannot read property 'catch' of undefined13> readonly attribute ReadableStreamDefaultReader? locked;14> readonly attribute ReadableStreamDefaultReader? locked;15> readonly attribute ReadableStreamDefaultReader? locked;
Using AI Code Generation
1var defaultReaderClosedPromiseResetToRejected = new Promise(function(resolve, reject) {2 var rs = new ReadableStream({3 start(controller) {4 controller.enqueue('a');5 }6 });7 var reader = rs.getReader();8 reader.read().then(result => {9 assert(result.value === 'a');10 assert(result.done === false);11 reader.releaseLock();12 });13 reader.closed.then(() => {14 assert(false, 'closed should not be fulfilled');15 }, () => {16 assert(true, 'closed should be rejected');17 });18 reader.cancel();19});20promise_test(() => defaultReaderClosedPromiseResetToRejected, 'defaultReaderClosedPromiseResetToRejected');21var defaultReaderClosedPromiseResetToRejected = new Promise(function(resolve, reject) {22 var rs = new ReadableStream({23 start(controller) {24 controller.enqueue('a');25 }26 });27 var reader = rs.getReader();28 reader.read().then(result => {29 assert(result.value === 'a');30 assert(result.done === false);31 reader.releaseLock();32 });33 reader.closed.then(() => {34 assert(false, 'closed should not be fulfilled');35 }, () => {36 assert(true, 'closed should be rejected');37 });38 reader.cancel();39});40promise_test(() => defaultReaderClosedPromiseResetToRejected, 'defaultReaderClosedPromiseResetToRejected');41var defaultReaderClosedPromiseResetToRejected = new Promise(function(resolve, reject) {42 var rs = new ReadableStream({43 start(controller) {44 controller.enqueue('a');45 }46 });47 var reader = rs.getReader();48 reader.read().then(result => {49 assert(result.value === 'a');50 assert(result.done === false);51 reader.releaseLock();52 });53 reader.closed.then(() => {54 assert(false, 'closed should not be fulfilled');55 }, () => {56 assert(true, 'closed should be rejected');57 });58 reader.cancel();59});60promise_test(() => defaultReaderClosedPromiseResetToRejected, 'defaultReaderClosedPromiseResetToRejected');
Using AI Code Generation
1const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;2const reader = new ReadableStream().getReader();3const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;4const readableStream = new ReadableStream({5 start(c) {6 c.enqueue('a');7 c.close();8 }9});10const reader = readableStream.getReader();11const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;12const readableStream = new ReadableStream({13 start(c) {14 c.enqueue('a');15 c.error('e');16 }17});18const reader = readableStream.getReader();19const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;20const readableStream = new ReadableStream({21 start(c) {22 c.enqueue('a');23 c.error('e');24 }25});26const reader = readableStream.getReader();27reader.closed.then(() => console.log('closed'));28const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;29const readableStream = new ReadableStream({30 start(c) {31 c.enqueue('a');32 c.close();33 }34});35const reader = readableStream.getReader();36reader.closed.then(() => console.log('closed'));37const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;38const readableStream = new ReadableStream({39 start(c) {40 c.enqueue('a');41 c.close();42 }43});44const reader = readableStream.getReader();45reader.closed.then(() => console.log('closed'));46const defaultReaderClosedPromiseResetToRejected = wpt.defaultReaderClosedPromiseResetToRejected;47const readableStream = new ReadableStream({48 start(c) {49 c.enqueue('a');50 c.close();51 }52});
Using AI Code Generation
1import {defaultReaderClosedPromiseResetToRejected} from2'./resources/test-utils.js';3promise_test(async t => {4 const rs = new ReadableStream({5 start(c) {6 c.enqueue('a');7 c.close();8 }9 });10 const reader = rs.getReader();11 assert_equals(reader.closed, defaultReaderClosedPromiseResetToRejected);12 const result = await reader.read();13 assert_equals(result.value, 'a');14 assert_true(result.done);15}, 'ReadableStream with byte source: getReader().closed should be a rejected16promise');
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.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run wpt automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
