[aborting.dedicatedworker.html]
  [Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject]
    expected: FAIL

  [Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one]
    expected: FAIL

  [abort() on a released writer rejects]
    expected: FAIL

  [Aborting a WritableStream immediately prevents future writes]
    expected: FAIL

  [Aborting a WritableStream prevents further writes after any that are in progress]
    expected: FAIL

  [Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value]
    expected: FAIL

  [WritableStream if sink's abort throws, the promise returned by writer.abort() rejects]
    expected: FAIL

  [WritableStream if sink's abort throws, the promise returned by ws.abort() rejects]
    expected: FAIL

  [WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects]
    expected: FAIL

  [Aborting a WritableStream passes through the given reason]
    expected: FAIL

  [Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error]
    expected: FAIL

  [Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError]
    expected: FAIL

  [Closing but then immediately aborting a WritableStream causes the stream to error]
    expected: FAIL

  [Closing a WritableStream and aborting it while it closes causes the stream to error]
    expected: FAIL

  [Aborting a WritableStream after it is closed is a no-op]
    expected: FAIL

  [WritableStream should NOT call underlying sink's close if no abort is supplied (historical)]
    expected: FAIL

  [returning a thenable from abort() should work]
    expected: FAIL

  [.closed should not resolve before fulfilled write()]
    expected: FAIL

  [.closed should not resolve before rejected write(); write() error should overwrite abort() error]
    expected: FAIL

  [writes should be satisfied in order when aborting]
    expected: FAIL

  [writes should be satisfied in order after rejected write when aborting]
    expected: FAIL

  [close() should use error from underlying write() on abort]
    expected: FAIL

  [underlying abort() should not be called until underlying write() completes]
    expected: FAIL

  [underlying abort() should not be called if underlying close() has started]
    expected: FAIL

  [if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason]
    expected: FAIL

  [underlying abort() should be called while closing if underlying close() has not started yet]
    expected: FAIL

  [writer close() promise should resolve before abort() promise]
    expected: FAIL

  [writer.ready should reject on controller error without waiting for underlying write]
    expected: FAIL

  [writer.abort() while there is a pending write, and then finish the write with rejection]
    expected: FAIL

  [writer.abort(), controller.error() while there is a pending write, and then finish the write]
    expected: FAIL

  [controller.error(), writer.abort() while there is a pending write, and then finish the write]
    expected: FAIL

  [releaseLock() while aborting should reject the original closed promise]
    expected: FAIL

  [releaseLock() during delayed async abort() should create a new rejected closed promise]
    expected: FAIL

  [Closing a WritableStream and aborting it while it closes causes the stream to ignore the abort attempt]
    expected: FAIL

  [an abort() that happens during a write() should trigger the underlying abort() even with a close() queued]
    expected: FAIL

  [if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError]
    expected: FAIL

  [writer.abort() while there is an in-flight write, and then finish the write with rejection]
    expected: FAIL

  [writer.abort(), controller.error() while there is an in-flight write, and then finish the write]
    expected: FAIL

  [writer.abort(), controller.error() while there is an in-flight close, and then finish the close]
    expected: FAIL

  [controller.error(), writer.abort() while there is an in-flight write, and then finish the write]
    expected: FAIL

  [controller.error(), writer.abort() while there is an in-flight close, and then finish the close]
    expected: FAIL

  [sink abort() should not be called until sink start() is done]
    expected: FAIL

  [abort() promise should reject if start() errors the controller]
    expected: FAIL

  [stream abort() promise should reject if sink start() rejects]
    expected: FAIL

  [writer abort() during sink start() should replace the writer.ready promise synchronously]
    expected: FAIL

  [promises returned from other writer methods should be rejected when writer abort() happens during sink start()]
    expected: FAIL

  [abort() should be rejected with the error passed to controller.error() during pending write()]
    expected: FAIL

  [abort() should be rejected with the error passed to controller.error() during pending close()]
    expected: FAIL

  [.closed should not resolve before rejected write(); write() error should not overwrite abort() error]
    expected: FAIL

  [close() should reject with TypeError when abort() is first error]
    expected: FAIL

  [releaseLock() during delayed async abort() should reject the writer.closed promise]
    expected: FAIL

  [if start attempts to error the controller after abort() has been called, then it should lose]
    expected: FAIL

  [stream abort() promise should still resolve if sink start() rejects]
    expected: FAIL

  [abort() should succeed despite rejection from write]
    expected: FAIL

  [abort() should be rejected with the rejection returned from close()]
    expected: FAIL

  [a rejecting sink.write() should not prevent sink.abort() from being called]
    expected: FAIL

  [when start errors after stream abort(), underlying sink abort() should be called anyway]
    expected: FAIL

  [when calling abort() twice on the same stream, the second call should reject]
    expected: FAIL

  [sink abort() should not be called if stream was erroring due to controller.error() before abort() was called]
    expected: FAIL

  [sink abort() should not be called if stream was erroring due to bad strategy before abort() was called]
    expected: FAIL