How to use writePromise4 method in wpt

Best JavaScript code snippet using wpt

aborting.js

Source:aborting.js

1'use strict';2if (self.importScripts) {3  self.importScripts('/resources/testharness.js');4  self.importScripts('../resources/test-utils.js');5  self.importScripts('../resources/recording-streams.js');6}7const error1 = new Error('error1');8error1.name = 'error1';9const error2 = new Error('error2');10error2.name = 'error2';11promise_test(t => {12  const ws = new WritableStream({13    write() {14      return new Promise(() => { }); // forever-pending, so normally .ready would not fulfill.15    }16  });17  const writer = ws.getWriter();18  const writePromise = writer.write('a');19  const readyPromise = writer.ready;20  writer.abort(error1);21  assert_equals(writer.ready, readyPromise, 'the ready promise property should not change');22  return Promise.all([23    promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError'),24    promise_rejects(t, new TypeError(), writePromise, 'the write() promise should reject with a TypeError')25  ]);26}, 'Aborting a WritableStream before it starts should cause the writer\'s unsettled ready promise to reject');27promise_test(t => {28  const ws = new WritableStream();29  const writer = ws.getWriter();30  writer.write('a');31  const readyPromise = writer.ready;32  return readyPromise.then(() => {33    writer.abort(error1);34    assert_not_equals(writer.ready, readyPromise, 'the ready promise property should change');35    return promise_rejects(t, new TypeError(), writer.ready, 'the ready promise should reject with a TypeError');36  });37}, 'Aborting a WritableStream should cause the writer\'s fulfilled ready promise to reset to a rejected one');38promise_test(t => {39  const ws = new WritableStream();40  const writer = ws.getWriter();41  writer.releaseLock();42  return promise_rejects(t, new TypeError(), writer.abort(), 'abort() should reject with a TypeError');43}, 'abort() on a released writer rejects');44promise_test(t => {45  const ws = recordingWritableStream();46  return delay(0)47    .then(() => {48      const writer = ws.getWriter();49      writer.abort();50      return Promise.all([51        promise_rejects(t, new TypeError(), writer.write(1), 'write(1) must reject with a TypeError'),52        promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError')53      ]);54    })55    .then(() => {56      assert_array_equals(ws.events, ['abort', undefined]);57    });58}, 'Aborting a WritableStream immediately prevents future writes');59promise_test(t => {60  const ws = recordingWritableStream();61  const results = [];62  return delay(0)63    .then(() => {64      const writer = ws.getWriter();65      results.push(66        writer.write(1),67        promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError'),68        promise_rejects(t, new TypeError(), writer.write(3), 'write(3) must reject with a TypeError')69      );70      const abortPromise = writer.abort();71      results.push(72        promise_rejects(t, new TypeError(), writer.write(4), 'write(4) must reject with a TypeError'),73        promise_rejects(t, new TypeError(), writer.write(5), 'write(5) must reject with a TypeError')74      );75      return abortPromise;76    }).then(() => {77      assert_array_equals(ws.events, ['write', 1, 'abort', undefined]);78      return Promise.all(results);79    });80}, 'Aborting a WritableStream prevents further writes after any that are in progress');81promise_test(() => {82  const ws = new WritableStream({83    abort() {84      return 'Hello';85    }86  });87  const writer = ws.getWriter();88  return writer.abort('a').then(value => {89    assert_equals(value, undefined, 'fulfillment value must be undefined');90  });91}, 'Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value');92promise_test(t => {93  const ws = new WritableStream({94    abort() {95      throw error1;96    }97  });98  const writer = ws.getWriter();99  return promise_rejects(t, error1, writer.abort(undefined),100    'rejection reason of abortPromise must be the error thrown by abort');101}, 'WritableStream if sink\'s abort throws, the promise returned by writer.abort() rejects');102promise_test(t => {103  const ws = new WritableStream({104    abort() {105      throw error1;106    }107  });108  return promise_rejects(t, error1, ws.abort(undefined),109    'rejection reason of abortPromise must be the error thrown by abort');110}, 'WritableStream if sink\'s abort throws, the promise returned by ws.abort() rejects');111promise_test(t => {112  let resolveWritePromise;113  const ws = new WritableStream({114    write() {115      return new Promise(resolve => {116        resolveWritePromise = resolve;117      });118    },119    abort() {120      throw error1;121    }122  });123  const writer = ws.getWriter();124  writer.write().catch(() => {});125  return flushAsyncEvents().then(() => {126    const abortPromise = writer.abort(undefined);127    resolveWritePromise();128    return promise_rejects(t, error1, abortPromise,129      'rejection reason of abortPromise must be the error thrown by abort');130  });131}, 'WritableStream if sink\'s abort throws, for an abort performed during a write, the promise returned by ' +132   'ws.abort() rejects');133test(() => {134  const ws = recordingWritableStream();135  const writer = ws.getWriter();136  writer.abort(error1);137  assert_array_equals(ws.events, ['abort', error1]);138}, 'Aborting a WritableStream passes through the given reason');139promise_test(t => {140  const ws = new WritableStream();141  const writer = ws.getWriter();142  writer.abort(error1);143  const events = [];144  writer.ready.catch(() => {145    events.push('ready');146  });147  writer.closed.catch(() => {148    events.push('closed');149  });150  return Promise.all([151    promise_rejects(t, new TypeError(), writer.write(), 'writing should reject with a TypeError'),152    promise_rejects(t, new TypeError(), writer.close(), 'closing should reject with a TypeError'),153    promise_rejects(t, new TypeError(), writer.abort(), 'aborting should reject with a TypeError'),154    promise_rejects(t, new TypeError(), writer.ready, 'ready should reject with a TypeError'),155    promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError')156  ]).then(() => {157    assert_array_equals(['ready', 'closed'], events, 'ready should reject before closed');158  });159}, 'Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error');160promise_test(t => {161  const ws = new WritableStream();162  const writer = ws.getWriter();163  const writePromise = promise_rejects(t, new TypeError(), writer.write('a'),164    'writing should reject with a TypeError');165  writer.abort(error1);166  return writePromise;167}, 'Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError');168promise_test(t => {169  const ws = new WritableStream();170  const writer = ws.getWriter();171  const closePromise = writer.close();172  writer.abort(error1);173  return Promise.all([174    promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),175    promise_rejects(t, new TypeError(), closePromise, 'close() should reject with a TypeError')176  ]);177}, 'Closing but then immediately aborting a WritableStream causes the stream to error');178promise_test(t => {179  let resolveClose;180  const ws = new WritableStream({181    close() {182      return new Promise(resolve => {183        resolveClose = resolve;184      });185    }186  });187  const writer = ws.getWriter();188  const closePromise = writer.close();189  return delay(0).then(() => {190    const abortPromise = writer.abort(error1);191    resolveClose();192    return Promise.all([193      promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),194      abortPromise,195      closePromise196    ]);197  });198}, 'Closing a WritableStream and aborting it while it closes causes the stream to error');199promise_test(() => {200  const ws = new WritableStream();201  const writer = ws.getWriter();202  writer.close();203  return delay(0).then(() => writer.abort());204}, 'Aborting a WritableStream after it is closed is a no-op');205promise_test(t => {206  // Testing that per https://github.com/whatwg/streams/issues/620#issuecomment-263483953 the fallback to close was207  // removed.208  // Cannot use recordingWritableStream since it always has an abort209  let closeCalled = false;210  const ws = new WritableStream({211    close() {212      closeCalled = true;213    }214  });215  const writer = ws.getWriter();216  writer.abort();217  return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError').then(() => {218    assert_false(closeCalled, 'close must not have been called');219  });220}, 'WritableStream should NOT call underlying sink\'s close if no abort is supplied (historical)');221promise_test(() => {222  let thenCalled = false;223  const ws = new WritableStream({224    abort() {225      return {226        then(onFulfilled) {227          thenCalled = true;228          onFulfilled();229        }230      };231    }232  });233  const writer = ws.getWriter();234  return writer.abort().then(() => assert_true(thenCalled, 'then() should be called'));235}, 'returning a thenable from abort() should work');236promise_test(t => {237  const ws = new WritableStream({238    write() {239      return flushAsyncEvents();240    }241  });242  const writer = ws.getWriter();243  return writer.ready.then(() => {244    const writePromise = writer.write('a');245    writer.abort(error1);246    let closedResolved = false;247    return Promise.all([248      writePromise.then(() => assert_false(closedResolved, '.closed should not resolve before write()')),249      promise_rejects(t, new TypeError(), writer.closed, '.closed should reject').then(() => {250        closedResolved = true;251      })252    ]);253  });254}, '.closed should not resolve before fulfilled write()');255promise_test(t => {256  const ws = new WritableStream({257    write() {258      return Promise.reject(error1);259    }260  });261  const writer = ws.getWriter();262  return writer.ready.then(() => {263    const writePromise = writer.write('a');264    const abortPromise = writer.abort(error2);265    let closedResolved = false;266    return Promise.all([267      promise_rejects(t, error1, writePromise, 'write() should reject')268          .then(() => assert_false(closedResolved, '.closed should not resolve before write()')),269      promise_rejects(t, error1, writer.closed, '.closed should reject')270          .then(() => {271            closedResolved = true;272          }),273      promise_rejects(t, error1, abortPromise, 'abort() should reject')]);274  });275}, '.closed should not resolve before rejected write(); write() error should overwrite abort() error');276promise_test(t => {277  const ws = new WritableStream({278    write() {279      return flushAsyncEvents();280    }281  }, new CountQueuingStrategy(4));282  const writer = ws.getWriter();283  return writer.ready.then(() => {284    const settlementOrder = [];285    return Promise.all([286      writer.write('1').then(() => settlementOrder.push(1)),287      promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')288          .then(() => settlementOrder.push(2)),289      promise_rejects(t, new TypeError(), writer.write('3'), 'second queued write should be rejected')290          .then(() => settlementOrder.push(3)),291      writer.abort(error1)292    ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));293  });294}, 'writes should be satisfied in order when aborting');295promise_test(t => {296  const ws = new WritableStream({297    write() {298      return Promise.reject(error1);299    }300  }, new CountQueuingStrategy(4));301  const writer = ws.getWriter();302  return writer.ready.then(() => {303    const settlementOrder = [];304    return Promise.all([305      promise_rejects(t, error1, writer.write('1'), 'pending write should be rejected')306          .then(() => settlementOrder.push(1)),307      promise_rejects(t, error1, writer.write('2'), 'first queued write should be rejected')308          .then(() => settlementOrder.push(2)),309      promise_rejects(t, error1, writer.write('3'), 'second queued write should be rejected')310          .then(() => settlementOrder.push(3)),311      promise_rejects(t, error1, writer.abort(error1), 'abort should be rejected')312    ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));313  });314}, 'writes should be satisfied in order after rejected write when aborting');315promise_test(t => {316  const ws = new WritableStream({317    write() {318      return Promise.reject(error1);319    }320  });321  const writer = ws.getWriter();322  return writer.ready.then(() => {323    return Promise.all([324      promise_rejects(t, error1, writer.write('a'), 'writer.write() should reject with error from underlying write()'),325      promise_rejects(t, error1, writer.close(), 'writer.close() should reject with error from underlying write()'),326      promise_rejects(t, error1, writer.abort(), 'writer.abort() should reject with error from underlying write()')327    ]);328  });329}, 'close() should use error from underlying write() on abort');330promise_test(() => {331  let resolveWrite;332  let abortCalled = false;333  const ws = new WritableStream({334    write() {335      return new Promise(resolve => {336        resolveWrite = resolve;337      });338    },339    abort() {340      abortCalled = true;341    }342  });343  const writer = ws.getWriter();344  return writer.ready.then(() => {345    writer.write('a');346    const abortPromise = writer.abort();347    return flushAsyncEvents().then(() => {348      assert_false(abortCalled, 'abort should not be called while write is pending');349      resolveWrite();350      return abortPromise.then(() => assert_true(abortCalled, 'abort should be called'));351    });352  });353}, 'underlying abort() should not be called until underlying write() completes');354promise_test(() => {355  let resolveClose;356  let abortCalled = false;357  const ws = new WritableStream({358    close() {359      return new Promise(resolve => {360        resolveClose = resolve;361      });362    },363    abort() {364      abortCalled = true;365    }366  });367  const writer = ws.getWriter();368  return writer.ready.then(() => {369    writer.close();370    const abortPromise = writer.abort();371    return flushAsyncEvents().then(() => {372      assert_false(abortCalled, 'underlying abort should not be called while close is pending');373      resolveClose();374      return abortPromise.then(() => {375        assert_false(abortCalled, 'underlying abort should not be called after close completes');376      });377    });378  });379}, 'underlying abort() should not be called if underlying close() has started');380promise_test(t => {381  let rejectClose;382  let abortCalled = false;383  const ws = new WritableStream({384    close() {385      return new Promise((resolve, reject) => {386        rejectClose = reject;387      });388    },389    abort() {390      abortCalled = true;391    }392  });393  const writer = ws.getWriter();394  return writer.ready.then(() => {395    const closePromise = writer.close();396    const abortPromise = writer.abort();397    return flushAsyncEvents().then(() => {398      assert_false(abortCalled, 'underlying abort should not be called while close is pending');399      rejectClose(error1);400      return promise_rejects(t, error1, abortPromise, 'abort should reject with the same reason').then(() => {401        return promise_rejects(t, error1, closePromise, 'close should reject with the same reason');402      }).then(() => {403        assert_false(abortCalled, 'underlying abort should not be called after close completes');404      });405    });406  });407}, 'if underlying close() has started and then rejects, the abort() and close() promises should reject with the ' +408   'underlying close rejection reason');409promise_test(t => {410  let resolveWrite;411  let abortCalled = false;412  const ws = new WritableStream({413    write() {414      return new Promise(resolve => {415        resolveWrite = resolve;416      });417    },418    abort() {419      abortCalled = true;420    }421  });422  const writer = ws.getWriter();423  return writer.ready.then(() => {424    writer.write('a');425    const closePromise = writer.close();426    const abortPromise = writer.abort();427    return flushAsyncEvents().then(() => {428      assert_false(abortCalled, 'abort should not be called while write is pending');429      resolveWrite();430      return abortPromise.then(() => {431        assert_true(abortCalled, 'abort should be called after write completes');432        return promise_rejects(t, new TypeError(), closePromise, 'promise returned by close() should be rejected');433      });434    });435  });436}, 'underlying abort() should be called while closing if underlying close() has not started yet');437promise_test(() => {438  const ws = new WritableStream();439  const writer = ws.getWriter();440  return writer.ready.then(() => {441    const closePromise = writer.close();442    const abortPromise = writer.abort();443    let closeResolved = false;444    Promise.all([445      closePromise.then(() => { closeResolved = true; }),446      abortPromise.then(() => { assert_true(closeResolved, 'close() promise should resolve before abort() promise'); })447    ]);448  });449}, 'writer close() promise should resolve before abort() promise');450promise_test(t => {451  const ws = new WritableStream({452    write(chunk, controller) {453      controller.error(error1);454      return new Promise(() => {});455    }456  });457  const writer = ws.getWriter();458  return writer.ready.then(() => {459    writer.write('a');460    return promise_rejects(t, error1, writer.ready, 'writer.ready should reject');461  });462}, 'writer.ready should reject on controller error without waiting for underlying write');463promise_test(t => {464  let rejectWrite;465  const ws = new WritableStream({466    write() {467      return new Promise((resolve, reject) => {468        rejectWrite = reject;469      });470    }471  });472  let writePromise;473  let abortPromise;474  const events = [];475  const writer = ws.getWriter();476  writer.closed.catch(() => {477    events.push('closed');478  });479  // Wait for ws to start480  return flushAsyncEvents().then(() => {481    writePromise = writer.write('a');482    writePromise.catch(() => {483      events.push('writePromise');484    });485    abortPromise = writer.abort(error1);486    abortPromise.catch(() => {487      events.push('abortPromise');488    });489    const writePromise2 = writer.write('a');490    return Promise.all([491      promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),492      promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),493      flushAsyncEvents()494    ]);495  }).then(() => {496    assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be rejected yet');497    rejectWrite(error2);498    return Promise.all([499      promise_rejects(t, error2, writePromise,500                      'writePromise must reject with the error returned from the sink\'s write method'),501      promise_rejects(t, error2, abortPromise,502                      'abortPromise must reject with the error returned from the sink\'s write method'),503      promise_rejects(t, error2, writer.closed,504                      'writer.closed must reject with the error returned from the sink\'s write method'),505      flushAsyncEvents()506    ]);507  }).then(() => {508    assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],509                        'writePromise, abortPromise and writer.closed must reject');510    const writePromise3 = writer.write('a');511    return Promise.all([512      promise_rejects(t, new TypeError(), writePromise3,513                      'writePromise3 must reject with an error indicating the stream has already been errored'),514      promise_rejects(t, new TypeError(), writer.ready,515                      'writer.ready must be still rejected with the error indicating abort')516    ]);517  }).then(() => {518    writer.releaseLock();519    return Promise.all([520      promise_rejects(t, new TypeError(), writer.ready,521                      'writer.ready must be rejected with an error indicating release'),522      promise_rejects(t, new TypeError(), writer.closed,523                      'writer.closed must be rejected with an error indicating release')524    ]);525  });526}, 'writer.abort() while there is a pending write, and then finish the write with rejection');527promise_test(t => {528  let resolveWrite;529  let controller;530  const ws = new WritableStream({531    write(chunk, c) {532      controller = c;533      return new Promise(resolve => {534        resolveWrite = resolve;535      });536    }537  });538  let writePromise;539  let abortPromise;540  const events = [];541  const writer = ws.getWriter();542  writer.closed.catch(() => {543    events.push('closed');544  });545  // Wait for ws to start546  return flushAsyncEvents().then(() => {547    writePromise = writer.write('a');548    writePromise.then(() => {549      events.push('writePromise');550    });551    abortPromise = writer.abort(error1);552    abortPromise.catch(() => {553      events.push('abortPromise');554    });555    const writePromise2 = writer.write('a');556    return Promise.all([557      promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),558      promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),559      flushAsyncEvents()560    ]);561  }).then(() => {562    assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet');563    controller.error(error2);564    const writePromise3 = writer.write('a');565    return Promise.all([566      promise_rejects(t, new TypeError(), writePromise3,567                      'writePromise3 must reject with an error indicating the stream has already been errored'),568      promise_rejects(t, new TypeError(), writer.ready,569                      'writer.ready must be still rejected with the error indicating abort'),570      flushAsyncEvents()571    ]);572  }).then(() => {573    assert_array_equals(574        events, [],575        'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet even after '576            + 'controller.error() call');577    resolveWrite();578    return Promise.all([579      writePromise,580      promise_rejects(t, error2, abortPromise,581                      'abortPromise must reject with the error passed to the controller\'s error method'),582      promise_rejects(t, error2, writer.closed,583                      'writer.closed must reject with the error passed to the controller\'s error method'),584      flushAsyncEvents()585    ]);586  }).then(() => {587    assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],588                        'writePromise, abortPromise and writer.closed must reject');589    const writePromise4 = writer.write('a');590    return Promise.all([591      writePromise,592      promise_rejects(t, new TypeError(), writePromise4,593                      'writePromise4 must reject with an error indicating that the stream has already been errored'),594      promise_rejects(t, new TypeError(), writer.ready,595                      'writer.ready must be still rejected with the error indicating abort')596    ]);597  }).then(() => {598    writer.releaseLock();599    return Promise.all([600      promise_rejects(t, new TypeError(), writer.ready,601                      'writer.ready must be rejected with an error indicating release'),602      promise_rejects(t, new TypeError(), writer.closed,603                      'writer.closed must be rejected with an error indicating release')604    ]);605  });606}, 'writer.abort(), controller.error() while there is a pending write, and then finish the write');607promise_test(t => {608  let resolveWrite;609  let controller;610  const ws = new WritableStream({611    write(chunk, c) {612      controller = c;613      return new Promise(resolve => {614        resolveWrite = resolve;615      });616    }617  });618  let writePromise;619  let abortPromise;620  const events = [];621  const writer = ws.getWriter();622  writer.closed.catch(() => {623    events.push('closed');624  });625  // Wait for ws to start626  return flushAsyncEvents().then(() => {627    writePromise = writer.write('a');628    writePromise.then(() => {629      events.push('writePromise');630    });631    controller.error(error2);632    const writePromise2 = writer.write('a');633    return Promise.all([634      promise_rejects(t, new TypeError(), writePromise2,635                      'writePromise2 must reject with an error indicating the stream has already been errored'),636      promise_rejects(t, error2, writer.ready,637                      'writer.ready must reject with the error passed to the controller\'s error method'),638      flushAsyncEvents()639    ]);640  }).then(() => {641    assert_array_equals(events, [], 'writePromise and writer.closed must not be fulfilled/rejected yet');642    abortPromise = writer.abort(error1);643    abortPromise.catch(() => {644      events.push('abortPromise');645    });646    const writePromise3 = writer.write('a');647    return Promise.all([648      promise_rejects(t, error2, abortPromise,649                      'abortPromise must reject with the error passed to the controller\'s error method'),650      promise_rejects(t, new TypeError(), writePromise3,651                      'writePromise3 must reject with an error indicating the stream has already been errored'),652      flushAsyncEvents()653    ]);654  }).then(() => {655    assert_array_equals(656        events, ['abortPromise'],657        'writePromise and writer.closed must not be fulfilled/rejected yet even after writer.abort()');658    resolveWrite();659    return Promise.all([660      promise_rejects(t, error2, writer.closed,661                      'writer.closed must reject with the error passed to the controller\'s error method'),662      flushAsyncEvents()663    ]);664  }).then(() => {665    assert_array_equals(events, ['abortPromise', 'writePromise', 'closed'],666                        'writePromise, abortPromise and writer.closed must fulfill/reject');667    const writePromise4 = writer.write('a');668    return Promise.all([669      writePromise,670      promise_rejects(t, new TypeError(), writePromise4,671                      'writePromise4 must reject with an error indicating that the stream has already been errored'),672      promise_rejects(t, error2, writer.ready,673                      'writer.ready must be still rejected with the error passed to the controller\'s error method')674    ]);675  }).then(() => {676    writer.releaseLock();677    return Promise.all([678      promise_rejects(t, new TypeError(), writer.ready,679                      'writer.ready must be rejected with an error indicating release'),680      promise_rejects(t, new TypeError(), writer.closed,681                      'writer.closed must be rejected with an error indicating release')682    ]);683  });684}, 'controller.error(), writer.abort() while there is a pending write, and then finish the write');685promise_test(t => {686  let resolveWrite;687  const ws = new WritableStream({688    write() {689      return new Promise(resolve => {690        resolveWrite = resolve;691      });692    }693  });694  const writer = ws.getWriter();695  return writer.ready.then(() => {696    const writePromise = writer.write('a');697    const closed = writer.closed;698    const abortPromise = writer.abort();699    writer.releaseLock();700    resolveWrite();701    return Promise.all([702      writePromise,703      abortPromise,704      promise_rejects(t, new TypeError(), closed, 'closed should reject')]);705  });706}, 'releaseLock() while aborting should reject the original closed promise');707promise_test(t => {708  let resolveWrite;709  let resolveAbort;710  let resolveAbortStarted;711  const abortStarted = new Promise(resolve => {712    resolveAbortStarted = resolve;713  });714  const ws = new WritableStream({715    write() {716      return new Promise(resolve => {717        resolveWrite = resolve;718      });719    },720    abort() {721      resolveAbortStarted();722      return new Promise(resolve => {723        resolveAbort = resolve;724      });725    }726  });727  const writer = ws.getWriter();728  return writer.ready.then(() => {729    const writePromise = writer.write('a');730    const closed = writer.closed;731    const abortPromise = writer.abort();732    resolveWrite();733    return abortStarted.then(() => {734      writer.releaseLock();735      assert_not_equals(writer.closed, closed, 'closed promise should have changed');736      resolveAbort();737      return Promise.all([738        writePromise,739        abortPromise,740        promise_rejects(t, new TypeError(), closed, 'original closed should reject'),741        promise_rejects(t, new TypeError(), writer.closed, 'new closed should reject')]);742    });743  });744}, 'releaseLock() during delayed async abort() should create a new rejected closed promise');...

Using AI Code Generation

1var wpt = require('wpt');2wpt.writePromise4('test.txt', 'Hello World!')3.then(function(){4console.log('File written successfully');5})6.catch(function(err){7console.log(err);8});9var wpt = require('wpt');10wpt.writePromise5('test.txt', 'Hello World!', function(err){11if(err){12console.log(err);13}14else{15console.log('File written successfully');16}17});18var wpt = require('wpt');19wpt.writePromise6('test.txt', 'Hello World!')20.then(function(){21console.log('File written successfully');22})23.catch(function(err){24console.log(err);25});

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.