'use strict';

if (self.importScripts) {
  self.importScripts('/resources/testharness.js');
  self.importScripts('../resources/test-utils.js');
  self.importScripts('../resources/recording-streams.js');
}

const error1 = new Error('error1');
error1.name = 'error1';

const error2 = new Error('error2');
error2.name = 'error2';

promise_test(t => {
  const ws = new WritableStream({
    write: t.unreached_func('write() should not be called')
  });

  const writer = ws.getWriter();
  const writePromise = writer.write('a');

  const readyPromise = writer.ready;

  writer.abort(error1);

  assert_equals(writer.ready, readyPromise, 'the ready promise property should not change');

  return Promise.all([
    promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError'),
    promise_rejects(t, new TypeError(), writePromise, 'the write() promise should reject with a TypeError')
  ]);
}, 'Aborting a WritableStream before it starts should cause the writer\'s unsettled ready promise to reject');

promise_test(t => {
  const ws = new WritableStream();

  const writer = ws.getWriter();
  writer.write('a');

  const readyPromise = writer.ready;

  return readyPromise.then(() => {
    writer.abort(error1);

    assert_not_equals(writer.ready, readyPromise, 'the ready promise property should change');
    return promise_rejects(t, new TypeError(), writer.ready, 'the ready promise should reject with a TypeError');
  });
}, 'Aborting a WritableStream should cause the writer\'s fulfilled ready promise to reset to a rejected one');

promise_test(t => {
  const ws = new WritableStream();
  const writer = ws.getWriter();

  writer.releaseLock();

  return promise_rejects(t, new TypeError(), writer.abort(), 'abort() should reject with a TypeError');
}, 'abort() on a released writer rejects');

promise_test(t => {
  const ws = recordingWritableStream();

  return delay(0)
    .then(() => {
      const writer = ws.getWriter();

      const abortPromise = writer.abort();

      return Promise.all([
        promise_rejects(t, new TypeError(), writer.write(1), 'write(1) must reject with a TypeError'),
        promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError'),
        abortPromise
      ]);
    })
    .then(() => {
      assert_array_equals(ws.events, ['abort', undefined]);
    });
}, 'Aborting a WritableStream immediately prevents future writes');

promise_test(t => {
  const ws = recordingWritableStream();
  const results = [];

  return delay(0)
    .then(() => {
      const writer = ws.getWriter();

      results.push(
        writer.write(1),
        promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError'),
        promise_rejects(t, new TypeError(), writer.write(3), 'write(3) must reject with a TypeError')
      );

      const abortPromise = writer.abort();

      results.push(
        promise_rejects(t, new TypeError(), writer.write(4), 'write(4) must reject with a TypeError'),
        promise_rejects(t, new TypeError(), writer.write(5), 'write(5) must reject with a TypeError')
      );

      return abortPromise;
    }).then(() => {
      assert_array_equals(ws.events, ['write', 1, 'abort', undefined]);

      return Promise.all(results);
    });
}, 'Aborting a WritableStream prevents further writes after any that are in progress');

promise_test(() => {
  const ws = new WritableStream({
    abort() {
      return 'Hello';
    }
  });
  const writer = ws.getWriter();

  return writer.abort('a').then(value => {
    assert_equals(value, undefined, 'fulfillment value must be undefined');
  });
}, 'Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value');

promise_test(t => {
  const ws = new WritableStream({
    abort() {
      throw error1;
    }
  });
  const writer = ws.getWriter();

  return promise_rejects(t, error1, writer.abort(undefined),
    'rejection reason of abortPromise must be the error thrown by abort');
}, 'WritableStream if sink\'s abort throws, the promise returned by writer.abort() rejects');

promise_test(t => {
  const ws = new WritableStream({
    abort() {
      throw error1;
    }
  });

  return promise_rejects(t, error1, ws.abort(undefined),
    'rejection reason of abortPromise must be the error thrown by abort');
}, 'WritableStream if sink\'s abort throws, the promise returned by ws.abort() rejects');

promise_test(t => {
  let resolveWritePromise;
  const ws = new WritableStream({
    write() {
      return new Promise(resolve => {
        resolveWritePromise = resolve;
      });
    },
    abort() {
      throw error1;
    }
  });

  const writer = ws.getWriter();

  writer.write().catch(() => {});
  return flushAsyncEvents().then(() => {
    const abortPromise = writer.abort(undefined);

    resolveWritePromise();
    return promise_rejects(t, error1, abortPromise,
      'rejection reason of abortPromise must be the error thrown by abort');
  });
}, 'WritableStream if sink\'s abort throws, for an abort performed during a write, the promise returned by ' +
   'ws.abort() rejects');

promise_test(() => {
  const ws = recordingWritableStream();
  const writer = ws.getWriter();

  return writer.abort(error1).then(() => {
    assert_array_equals(ws.events, ['abort', error1]);
  });
}, 'Aborting a WritableStream passes through the given reason');

promise_test(t => {
  const ws = new WritableStream();
  const writer = ws.getWriter();

  const abortPromise = writer.abort(error1);

  const events = [];
  writer.ready.catch(() => {
    events.push('ready');
  });
  writer.closed.catch(() => {
    events.push('closed');
  });

  return Promise.all([
    abortPromise,
    promise_rejects(t, new TypeError(), writer.write(), 'writing should reject with a TypeError'),
    promise_rejects(t, new TypeError(), writer.close(), 'closing should reject with a TypeError'),
    promise_rejects(t, new TypeError(), writer.abort(), 'aborting should reject with a TypeError'),
    promise_rejects(t, new TypeError(), writer.ready, 'ready should reject with a TypeError'),
    promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError')
  ]).then(() => {
    assert_array_equals(['ready', 'closed'], events, 'ready should reject before closed');
  });
}, 'Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error');

promise_test(t => {
  const ws = new WritableStream();
  const writer = ws.getWriter();

  const writePromise = promise_rejects(t, new TypeError(), writer.write('a'),
    'writing should reject with a TypeError');

  writer.abort(error1);

  return writePromise;
}, 'Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError');

promise_test(t => {
  const ws = recordingWritableStream();
  const writer = ws.getWriter();

  const closePromise = writer.close();
  const abortPromise = writer.abort(error1);

  return Promise.all([
    promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),
    promise_rejects(t, new TypeError(), closePromise, 'close() should reject with a TypeError'),
    abortPromise
  ]).then(() => {
    assert_array_equals(ws.events, ['abort', error1]);
  });
}, 'Closing but then immediately aborting a WritableStream causes the stream to error');

promise_test(() => {
  let resolveClose;
  const ws = new WritableStream({
    close() {
      return new Promise(resolve => {
        resolveClose = resolve;
      });
    }
  });
  const writer = ws.getWriter();

  const closePromise = writer.close();

  return delay(0).then(() => {
    const abortPromise = writer.abort(error1);
    resolveClose();
    return Promise.all([
      writer.closed,
      abortPromise,
      closePromise
    ]);
  });
}, 'Closing a WritableStream and aborting it while it closes causes the stream to ignore the abort attempt');

promise_test(() => {
  const ws = new WritableStream();
  const writer = ws.getWriter();

  writer.close();

  return delay(0).then(() => writer.abort());
}, 'Aborting a WritableStream after it is closed is a no-op');

promise_test(t => {
  // Testing that per https://github.com/whatwg/streams/issues/620#issuecomment-263483953 the fallback to close was
  // removed.

  // Cannot use recordingWritableStream since it always has an abort
  let closeCalled = false;
  const ws = new WritableStream({
    close() {
      closeCalled = true;
    }
  });

  const writer = ws.getWriter();

  writer.abort();

  return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError').then(() => {
    assert_false(closeCalled, 'close must not have been called');
  });
}, 'WritableStream should NOT call underlying sink\'s close if no abort is supplied (historical)');

promise_test(() => {
  let thenCalled = false;
  const ws = new WritableStream({
    abort() {
      return {
        then(onFulfilled) {
          thenCalled = true;
          onFulfilled();
        }
      };
    }
  });
  const writer = ws.getWriter();
  return writer.abort().then(() => assert_true(thenCalled, 'then() should be called'));
}, 'returning a thenable from abort() should work');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return flushAsyncEvents();
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('a');
    writer.abort(error1);
    let closedRejected = false;
    return Promise.all([
      writePromise.then(() => assert_false(closedRejected, '.closed should not resolve before write()')),
      promise_rejects(t, new TypeError(), writer.closed, '.closed should reject').then(() => {
        closedRejected = true;
      })
    ]);
  });
}, '.closed should not resolve before fulfilled write()');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return Promise.reject(error1);
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('a');
    const abortPromise = writer.abort(error2);
    let closedRejected = false;
    return Promise.all([
      promise_rejects(t, error1, writePromise, 'write() should reject')
          .then(() => assert_false(closedRejected, '.closed should not resolve before write()')),
      promise_rejects(t, new TypeError(), writer.closed, '.closed should reject')
          .then(() => {
            closedRejected = true;
          }),
      abortPromise
    ]);
  });
}, '.closed should not resolve before rejected write(); write() error should not overwrite abort() error');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return flushAsyncEvents();
    }
  }, new CountQueuingStrategy(4));
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const settlementOrder = [];
    return Promise.all([
      writer.write('1').then(() => settlementOrder.push(1)),
      promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')
          .then(() => settlementOrder.push(2)),
      promise_rejects(t, new TypeError(), writer.write('3'), 'second queued write should be rejected')
          .then(() => settlementOrder.push(3)),
      writer.abort(error1)
    ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
  });
}, 'writes should be satisfied in order when aborting');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return Promise.reject(error1);
    }
  }, new CountQueuingStrategy(4));
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const settlementOrder = [];
    return Promise.all([
      promise_rejects(t, error1, writer.write('1'), 'in-flight write should be rejected')
          .then(() => settlementOrder.push(1)),
      promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')
          .then(() => settlementOrder.push(2)),
      promise_rejects(t, new TypeError(), writer.write('3'), 'second queued write should be rejected')
          .then(() => settlementOrder.push(3)),
      writer.abort(error2)
    ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
  });
}, 'writes should be satisfied in order after rejected write when aborting');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return Promise.reject(error1);
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    return Promise.all([
      promise_rejects(t, error1, writer.write('a'), 'writer.write() should reject with error from underlying write()'),
      promise_rejects(t, new TypeError(), writer.close(),
                      'writer.close() should reject with error from underlying write()'),
      writer.abort()
    ]);
  });
}, 'close() should reject with TypeError when abort() is first error');

promise_test(() => {
  let resolveWrite;
  const ws = recordingWritableStream({
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });

  const writer = ws.getWriter();
  return writer.ready.then(() => {
    writer.write('a');
    const abortPromise = writer.abort('b');
    return flushAsyncEvents().then(() => {
      assert_array_equals(ws.events, ['write', 'a'], 'abort should not be called while write is in-flight');
      resolveWrite();
      return abortPromise.then(() => {
        assert_array_equals(ws.events, ['write', 'a', 'abort', 'b'], 'abort should be called after the write finishes');
      });
    });
  });
}, 'underlying abort() should not be called until underlying write() completes');

promise_test(() => {
  let resolveClose;
  const ws = recordingWritableStream({
    close() {
      return new Promise(resolve => {
        resolveClose = resolve;
      });
    }
  });

  const writer = ws.getWriter();
  return writer.ready.then(() => {
    writer.close();
    const abortPromise = writer.abort();
    return flushAsyncEvents().then(() => {
      assert_array_equals(ws.events, ['close'], 'abort should not be called while close is in-flight');
      resolveClose();
      return abortPromise.then(() => {
        assert_array_equals(ws.events, ['close'], 'abort should not be called');
      });
    });
  });
}, 'underlying abort() should not be called if underlying close() has started');

promise_test(t => {
  let rejectClose;
  let abortCalled = false;
  const ws = new WritableStream({
    close() {
      return new Promise((resolve, reject) => {
        rejectClose = reject;
      });
    },
    abort() {
      abortCalled = true;
    }
  });

  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const closePromise = writer.close();
    const abortPromise = writer.abort();
    return flushAsyncEvents().then(() => {
      assert_false(abortCalled, 'underlying abort should not be called while close is in-flight');
      rejectClose(error1);
      return promise_rejects(t, error1, abortPromise, 'abort should reject with the same reason').then(() => {
        return promise_rejects(t, error1, closePromise, 'close should reject with the same reason');
      }).then(() => {
        assert_false(abortCalled, 'underlying abort should not be called after close completes');
      });
    });
  });
}, 'if underlying close() has started and then rejects, the abort() and close() promises should reject with the ' +
   'underlying close rejection reason');

promise_test(t => {
  let resolveWrite;
  const ws = recordingWritableStream({
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });

  const writer = ws.getWriter();
  return writer.ready.then(() => {
    writer.write('a');
    const closePromise = writer.close();
    const abortPromise = writer.abort('b');

    return flushAsyncEvents().then(() => {
      assert_array_equals(ws.events, ['write', 'a'], 'abort should not be called while write is in-flight');
      resolveWrite();
      return abortPromise.then(() => {
        assert_array_equals(ws.events, ['write', 'a', 'abort', 'b'], 'abort should be called after write completes');
        return promise_rejects(t, new TypeError(), closePromise, 'promise returned by close() should be rejected');
      });
    });
  });
}, 'an abort() that happens during a write() should trigger the underlying abort() even with a close() queued');

promise_test(t => {
  const ws = new WritableStream({
    write() {
      return new Promise(() => {});
    }
  });

  const writer = ws.getWriter();
  return writer.ready.then(() => {
    writer.write('a');
    writer.abort();
    writer.releaseLock();
    const writer2 = ws.getWriter();
    return promise_rejects(t, new TypeError(), writer2.ready,
                           'ready of the second writer should be rejected with a TypeError');
  });
}, 'if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError');

promise_test(() => {
  const ws = new WritableStream();
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const closePromise = writer.close();
    const abortPromise = writer.abort();
    const events = [];
    return Promise.all([
      closePromise.then(() => { events.push('close'); }),
      abortPromise.then(() => { events.push('abort'); })
    ]).then(() => {
      assert_array_equals(events, ['close', 'abort']);
    });
  });
}, 'writer close() promise should resolve before abort() promise');

promise_test(t => {
  const ws = new WritableStream({
    write(chunk, controller) {
      controller.error(error1);
      return new Promise(() => {});
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    writer.write('a');
    return promise_rejects(t, error1, writer.ready, 'writer.ready should reject');
  });
}, 'writer.ready should reject on controller error without waiting for underlying write');

promise_test(t => {
  let rejectWrite;
  const ws = new WritableStream({
    write() {
      return new Promise((resolve, reject) => {
        rejectWrite = reject;
      });
    }
  });

  let writePromise;
  let abortPromise;

  const events = [];

  const writer = ws.getWriter();

  writer.closed.catch(() => {
    events.push('closed');
  });

  // Wait for ws to start
  return flushAsyncEvents().then(() => {
    writePromise = writer.write('a');
    writePromise.catch(() => {
      events.push('writePromise');
    });

    abortPromise = writer.abort(error1);
    abortPromise.then(() => {
      events.push('abortPromise');
    });

    const writePromise2 = writer.write('a');

    return Promise.all([
      promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),
      promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be rejected yet');

    rejectWrite(error2);

    return Promise.all([
      promise_rejects(t, error2, writePromise,
                      'writePromise must reject with the error returned from the sink\'s write method'),
      abortPromise,
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must reject with an error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],
                        'writePromise, abortPromise and writer.closed must settle');

    const writePromise3 = writer.write('a');

    return Promise.all([
      promise_rejects(t, new TypeError(), writePromise3,
                      'writePromise3 must reject with an error indicating abort'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be still rejected with the error indicating abort')
    ]);
  }).then(() => {
    writer.releaseLock();

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be rejected with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must be rejected with an error indicating release')
    ]);
  });
}, 'writer.abort() while there is an in-flight write, and then finish the write with rejection');

promise_test(t => {
  let resolveWrite;
  let controller;
  const ws = new WritableStream({
    write(chunk, c) {
      controller = c;
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });

  let writePromise;
  let abortPromise;

  const events = [];

  const writer = ws.getWriter();

  writer.closed.catch(() => {
    events.push('closed');
  });

  // Wait for ws to start
  return flushAsyncEvents().then(() => {
    writePromise = writer.write('a');
    writePromise.then(() => {
      events.push('writePromise');
    });

    abortPromise = writer.abort(error1);
    abortPromise.then(() => {
      events.push('abortPromise');
    });

    const writePromise2 = writer.write('a');

    return Promise.all([
      promise_rejects(t, new TypeError(), writePromise2, 'writePromise2 must reject with an error indicating abort'),
      promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, [], 'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet');

    // This error is too late to change anything. abort() has already changed the stream state to 'erroring'.
    controller.error(error2);

    const writePromise3 = writer.write('a');

    return Promise.all([
      promise_rejects(t, new TypeError(), writePromise3,
                      'writePromise3 must reject with an error indicating abort'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be still rejected with the error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(
        events, [],
        'writePromise, abortPromise and writer.closed must not be fulfilled/rejected yet even after ' +
            'controller.error() call');

    resolveWrite();

    return Promise.all([
      writePromise,
      abortPromise,
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must reject with an error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],
                        'writePromise, abortPromise and writer.closed must settle');

    const writePromise4 = writer.write('a');

    return Promise.all([
      writePromise,
      promise_rejects(t, new TypeError(), writePromise4,
                      'writePromise4 must reject with an error indicating abort'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be still rejected with the error indicating abort')
    ]);
  }).then(() => {
    writer.releaseLock();

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be rejected with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must be rejected with an error indicating release')
    ]);
  });
}, 'writer.abort(), controller.error() while there is an in-flight write, and then finish the write');

promise_test(t => {
  let resolveClose;
  let controller;
  const ws = new WritableStream({
    start(c) {
      controller = c;
    },
    close() {
      return new Promise(resolve => {
        resolveClose = resolve;
      });
    }
  });

  let closePromise;
  let abortPromise;

  const events = [];

  const writer = ws.getWriter();

  writer.closed.then(() => {
    events.push('closed');
  });

  // Wait for ws to start
  return flushAsyncEvents().then(() => {
    closePromise = writer.close();
    closePromise.then(() => {
      events.push('closePromise');
    });

    abortPromise = writer.abort(error1);
    abortPromise.then(() => {
      events.push('abortPromise');
    });

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.close(),
        'writer.close() must reject with an error indicating already closing'),
      promise_rejects(t, new TypeError(), writer.ready, 'writer.ready must reject with an error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, [], 'closePromise, abortPromise and writer.closed must not be fulfilled/rejected yet');

    controller.error(error2);

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.close(),
        'writer.close() must reject with an error indicating already closing'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be still rejected with the error indicating abort'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(
        events, [],
        'closePromise, abortPromise and writer.closed must not be fulfilled/rejected yet even after ' +
            'controller.error() call');

    resolveClose();

    return Promise.all([
      closePromise,
      abortPromise,
      writer.closed,
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, ['closePromise', 'abortPromise', 'closed'],
                        'closedPromise, abortPromise and writer.closed must fulfill');

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.close(),
        'writer.close() must reject with an error indicating already closing'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be still rejected with the error indicating abort')
    ]);
  }).then(() => {
    writer.releaseLock();

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.close(),
        'writer.close() must reject with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be rejected with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must be rejected with an error indicating release')
    ]);
  });
}, 'writer.abort(), controller.error() while there is an in-flight close, and then finish the close');

promise_test(t => {
  let resolveWrite;
  let controller;
  const ws = recordingWritableStream({
    write(chunk, c) {
      controller = c;
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });

  let writePromise;
  let abortPromise;

  const events = [];

  const writer = ws.getWriter();

  writer.closed.catch(() => {
    events.push('closed');
  });

  // Wait for ws to start
  return flushAsyncEvents().then(() => {
    writePromise = writer.write('a');
    writePromise.then(() => {
      events.push('writePromise');
    });

    controller.error(error2);

    const writePromise2 = writer.write('a');

    return Promise.all([
      promise_rejects(t, error2, writePromise2,
                      'writePromise2 must reject with the error passed to the controller\'s error method'),
      promise_rejects(t, error2, writer.ready,
                      'writer.ready must reject with the error passed to the controller\'s error method'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, [], 'writePromise and writer.closed must not be fulfilled/rejected yet');

    abortPromise = writer.abort(error1);
    abortPromise.catch(() => {
      events.push('abortPromise');
    });

    const writePromise3 = writer.write('a');

    return Promise.all([
      promise_rejects(t, error2, writePromise3,
                      'writePromise3 must reject with the error passed to the controller\'s error method'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(
        events, [],
        'writePromise and writer.closed must not be fulfilled/rejected yet even after writer.abort()');

    resolveWrite();

    return Promise.all([
      promise_rejects(t, error2, abortPromise,
                      'abort() must reject with the error passed to the controller\'s error method'),
      promise_rejects(t, error2, writer.closed,
                      'writer.closed must reject with the error passed to the controller\'s error method'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, ['writePromise', 'abortPromise', 'closed'],
                        'writePromise, abortPromise and writer.closed must fulfill/reject');
    assert_array_equals(ws.events, ['write', 'a'], 'sink abort() should not be called');

    const writePromise4 = writer.write('a');

    return Promise.all([
      writePromise,
      promise_rejects(t, error2, writePromise4,
                      'writePromise4 must reject with the error passed to the controller\'s error method'),
      promise_rejects(t, error2, writer.ready,
                      'writer.ready must be still rejected with the error passed to the controller\'s error method')
    ]);
  }).then(() => {
    writer.releaseLock();

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be rejected with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must be rejected with an error indicating release')
    ]);
  });
}, 'controller.error(), writer.abort() while there is an in-flight write, and then finish the write');

promise_test(t => {
  let resolveClose;
  let controller;
  const ws = new WritableStream({
    start(c) {
      controller = c;
    },
    close() {
      return new Promise(resolve => {
        resolveClose = resolve;
      });
    }
  });

  let closePromise;
  let abortPromise;

  const events = [];

  const writer = ws.getWriter();

  writer.closed.then(() => {
    events.push('closed');
  });

  // Wait for ws to start
  return flushAsyncEvents().then(() => {
    closePromise = writer.close();
    closePromise.then(() => {
      events.push('closePromise');
    });

    controller.error(error2);

    return flushAsyncEvents();
  }).then(() => {
    assert_array_equals(events, [], 'closePromise must not be fulfilled/rejected yet');

    abortPromise = writer.abort(error1);
    abortPromise.then(() => {
      events.push('abortPromise');
    });

    return Promise.all([
      promise_rejects(t, error2, writer.ready,
                      'writer.ready must reject with the error passed to the controller\'s error method'),
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(
        events, [],
        'closePromise and writer.closed must not be fulfilled/rejected yet even after writer.abort()');

    resolveClose();

    return Promise.all([
      closePromise,
      promise_rejects(t, error2, writer.ready,
                      'writer.ready must be still rejected with the error passed to the controller\'s error method'),
      writer.closed,
      flushAsyncEvents()
    ]);
  }).then(() => {
    assert_array_equals(events, ['closePromise', 'abortPromise', 'closed'],
                        'abortPromise, closePromise and writer.closed must fulfill/reject');
  }).then(() => {
    writer.releaseLock();

    return Promise.all([
      promise_rejects(t, new TypeError(), writer.ready,
                      'writer.ready must be rejected with an error indicating release'),
      promise_rejects(t, new TypeError(), writer.closed,
                      'writer.closed must be rejected with an error indicating release')
    ]);
  });
}, 'controller.error(), writer.abort() while there is an in-flight close, and then finish the close');

promise_test(t => {
  let resolveWrite;
  const ws = new WritableStream({
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('a');
    const closed = writer.closed;
    const abortPromise = writer.abort();
    writer.releaseLock();
    resolveWrite();
    return Promise.all([
      writePromise,
      abortPromise,
      promise_rejects(t, new TypeError(), closed, 'closed should reject')]);
  });
}, 'releaseLock() while aborting should reject the original closed promise');

// TODO(ricea): Consider removing this test if it is no longer useful.
promise_test(t => {
  let resolveWrite;
  let resolveAbort;
  let resolveAbortStarted;
  const abortStarted = new Promise(resolve => {
    resolveAbortStarted = resolve;
  });
  const ws = new WritableStream({
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    },
    abort() {
      resolveAbortStarted();
      return new Promise(resolve => {
        resolveAbort = resolve;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('a');
    const closed = writer.closed;
    const abortPromise = writer.abort();
    resolveWrite();
    return abortStarted.then(() => {
      writer.releaseLock();
      assert_equals(writer.closed, closed, 'closed promise should not have changed');
      resolveAbort();
      return Promise.all([
        writePromise,
        abortPromise,
        promise_rejects(t, new TypeError(), closed, 'closed should reject')]);
    });
  });
}, 'releaseLock() during delayed async abort() should reject the writer.closed promise');

promise_test(() => {
  let resolveStart;
  const ws = recordingWritableStream({
    start() {
      return new Promise(resolve => {
        resolveStart = resolve;
      });
    }
  });
  const abortPromise = ws.abort('done');
  return flushAsyncEvents().then(() => {
    assert_array_equals(ws.events, [], 'abort() should not be called during start()');
    resolveStart();
    return abortPromise.then(() => {
      assert_array_equals(ws.events, ['abort', 'done'], 'abort() should be called after start() is done');
    });
  });
}, 'sink abort() should not be called until sink start() is done');

promise_test(() => {
  let resolveStart;
  let controller;
  const ws = recordingWritableStream({
    start(c) {
      controller = c;
      return new Promise(resolve => {
        resolveStart = resolve;
      });
    }
  });
  const abortPromise = ws.abort('done');
  controller.error(error1);
  resolveStart();
  return abortPromise.then(() =>
      assert_array_equals(ws.events, ['abort', 'done'],
                          'abort() should still be called if start() errors the controller'));
}, 'if start attempts to error the controller after abort() has been called, then it should lose');

promise_test(() => {
  const ws = recordingWritableStream({
    start() {
      return Promise.reject(error1);
    }
  });
  return ws.abort('done').then(() =>
      assert_array_equals(ws.events, ['abort', 'done'], 'abort() should still be called if start() rejects'));
}, 'stream abort() promise should still resolve if sink start() rejects');

promise_test(t => {
  const ws = new WritableStream();
  const writer = ws.getWriter();
  const writerReady1 = writer.ready;
  writer.abort('a');
  const writerReady2 = writer.ready;
  assert_not_equals(writerReady1, writerReady2, 'abort() should replace the ready promise with a rejected one');
  return Promise.all([writerReady1,
                      promise_rejects(t, new TypeError(), writerReady2, 'writerReady2 should reject')]);
}, 'writer abort() during sink start() should replace the writer.ready promise synchronously');

promise_test(t => {
  const events = [];
  const ws = recordingWritableStream();
  const writer = ws.getWriter();
  const writePromise1 = writer.write(1);
  const abortPromise = writer.abort('a');
  const writePromise2 = writer.write(2);
  const closePromise = writer.close();
  writePromise1.catch(() => events.push('write1'));
  abortPromise.then(() => events.push('abort'));
  writePromise2.catch(() => events.push('write2'));
  closePromise.catch(() => events.push('close'));
  return Promise.all([
    promise_rejects(t, new TypeError(), writePromise1, 'first write() should reject'),
    abortPromise,
    promise_rejects(t, new TypeError(), writePromise2, 'second write() should reject'),
    promise_rejects(t, new TypeError(), closePromise, 'close() should reject')
  ])
  .then(() => {
    assert_array_equals(events, ['write2', 'write1', 'abort', 'close'],
                        'promises should resolve in the standard order');
    assert_array_equals(ws.events, ['abort', 'a'], 'underlying sink write() should not be called');
  });
}, 'promises returned from other writer methods should be rejected when writer abort() happens during sink start()');

promise_test(t => {
  let writeReject;
  let controller;
  const ws = new WritableStream({
    write(chunk, c) {
      controller = c;
      return new Promise((resolve, reject) => {
        writeReject = reject;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('a');
    const abortPromise = writer.abort();
    controller.error(error1);
    writeReject(error2);
    return Promise.all([
      promise_rejects(t, error2, writePromise, 'write() should reject with error2'),
      abortPromise
    ]);
  });
}, 'abort() should succeed despite rejection from write');

promise_test(t => {
  let closeReject;
  let controller;
  const ws = new WritableStream({
    start(c) {
      controller = c;
    },
    close() {
      return new Promise((resolve, reject) => {
        closeReject = reject;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const closePromise = writer.close();
    const abortPromise = writer.abort();
    controller.error(error1);
    closeReject(error2);
    return Promise.all([
      promise_rejects(t, error2, closePromise, 'close() should reject with error2'),
      promise_rejects(t, error2, abortPromise, 'abort() should reject with error2')
    ]);
  });
}, 'abort() should be rejected with the rejection returned from close()');

promise_test(t => {
  let rejectWrite;
  const ws = recordingWritableStream({
    write() {
      return new Promise((resolve, reject) => {
        rejectWrite = reject;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('1');
    const abortPromise = writer.abort(error2);
    rejectWrite(error1);
    return Promise.all([
      promise_rejects(t, error1, writePromise, 'write should reject'),
      abortPromise,
      promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with TypeError')
    ]);
  }).then(() => {
    assert_array_equals(ws.events, ['write', '1', 'abort', error2], 'abort sink method should be called');
  });
}, 'a rejecting sink.write() should not prevent sink.abort() from being called');

promise_test(() => {
  const ws = recordingWritableStream({
    start() {
      return Promise.reject(error1);
    }
  });
  return ws.abort(error2)
      .then(() => {
        assert_array_equals(ws.events, ['abort', error2]);
      });
}, 'when start errors after stream abort(), underlying sink abort() should be called anyway');

promise_test(t => {
  const ws = new WritableStream();
  const abortPromise1 = ws.abort();
  const abortPromise2 = ws.abort();
  return Promise.all([
    abortPromise1,
    promise_rejects(t, new TypeError(), abortPromise2, 'second abort() should reject')
  ]);
}, 'when calling abort() twice on the same stream, the second call should reject');

promise_test(t => {
  let controller;
  let resolveWrite;
  const ws = recordingWritableStream({
    start(c) {
      controller = c;
    },
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise = writer.write('chunk');
    controller.error(error1);
    const abortPromise = writer.abort(error2);
    resolveWrite();
    return Promise.all([
      writePromise,
      promise_rejects(t, error1, abortPromise, 'abort() should reject')
    ]).then(() => {
      assert_array_equals(ws.events, ['write', 'chunk'], 'sink abort() should not be called');
    });
  });
}, 'sink abort() should not be called if stream was erroring due to controller.error() before abort() was called');

promise_test(t => {
  let resolveWrite;
  let size = 1;
  const ws = recordingWritableStream({
    write() {
      return new Promise(resolve => {
        resolveWrite = resolve;
      });
    }
  }, {
    size() {
      return size;
    },
    highWaterMark: 1
  });
  const writer = ws.getWriter();
  return writer.ready.then(() => {
    const writePromise1 = writer.write('chunk1');
    size = NaN;
    const writePromise2 = writer.write('chunk2');
    const abortPromise = writer.abort(error2);
    resolveWrite();
    return Promise.all([
      writePromise1,
      promise_rejects(t, new RangeError(), writePromise2, 'second write() should reject'),
      promise_rejects(t, new RangeError(), abortPromise, 'abort() should reject')
    ]).then(() => {
      assert_array_equals(ws.events, ['write', 'chunk1'], 'sink abort() should not be called');
    });
  });
}, 'sink abort() should not be called if stream was erroring due to bad strategy before abort() was called');

done();