From 2ee6a77d9fafbed0818273246720d2e0b99cd17c Mon Sep 17 00:00:00 2001
From: Domenic Denicola <d@domenic.me>
Date: Tue, 17 Feb 2015 21:54:33 -0500
Subject: [PATCH] Change the model for ReadableStream to have async read()

This replaces the dual ready + read() approach previously, which was derived from the epoll(7) + read(2) paradigm. In #253, we discussed about how the ready + read() model causes a conflict with the semantics we want for byte streams. Briefly, because some byte streams will demand to know the size of the buffer they must fill before doing any I/O (the fread(3) model), the readInto(arrayBuffer, ...) method for byte streams must be asynchronous. If such byte streams are then to conform to the readable stream interface, with a read() method derived from their readInto() method, then read() must also be async, across all readable streams.

This is a slight usability upgrade for consumers, in some cases. However, it potentially costs more microtasks when multiple chunks of data would be available synchronously.

In the process of updating the tests to reflect async read, they were given a number of small unrelated tweaks (e.g. to wording, or to eliminate some setTimeout(,0)s).

TODO:
- This commit eliminates ExclusiveStreamReader, but this was done in error based on mistaken assumptions. It will be reversed.
- Almost none of the spec is updated. Examples.md was updated and the examples in the spec were updated, but none of the algorithms or non-normative notes.
---
 Examples.md                                   |  48 +-
 index.bs                                      |  43 +-
 .../lib/exclusive-stream-reader.js            | 148 ---
 .../lib/readable-stream-abstract-ops.js       | 157 +---
 .../lib/readable-stream.js                    | 116 +--
 .../lib/transform-stream.js                   |   4 +-
 reference-implementation/run-tests.js         |  12 +-
 .../test/bad-underlying-sources.js            | 135 ++-
 reference-implementation/test/brand-checks.js |  87 +-
 .../test/count-queuing-strategy.js            | 120 ++-
 .../test/exclusive-stream-reader.js           | 531 -----------
 reference-implementation/test/pipe-through.js |   3 +-
 reference-implementation/test/pipe-to.js      | 520 ++++++-----
 .../test/readable-stream-cancel.js            | 239 +++--
 .../test/readable-stream.js                   | 875 +++++++++---------
 .../test/transform-stream-errors.js           |  41 +-
 .../test/transform-stream.js                  | 275 +++---
 .../test/utils/random-push-source.js          |  23 +-
 .../test/utils/readable-stream-to-array.js    |  18 +-
 19 files changed, 1266 insertions(+), 2129 deletions(-)
 delete mode 100644 reference-implementation/lib/exclusive-stream-reader.js
 delete mode 100644 reference-implementation/test/exclusive-stream-reader.js

diff --git a/Examples.md b/Examples.md
index c72a18da7..f47fff615 100644
--- a/Examples.md
+++ b/Examples.md
@@ -4,36 +4,6 @@ Many examples of using and creating streams are given in-line in the specificati
 
 ## Readable Streams
 
-### Getting the Next Piece of Available Data
-
-As another example, this helper function will return a promise for the next available piece of data from a given readable stream. This introduces an artificial delay if there is already data queued, but can provide a convenient interface for simple chunk-by-chunk consumption, as one might do e.g. when streaming database records. It uses an EOF sentinel to signal the end of the stream, and behaves poorly if called twice in parallel without waiting for the previously-returned promise to fulfill.
-
-```js
-const EOF = Symbol("ReadableStream getNext EOF");
-
-function getNext(stream) {
-  if (stream.state === "closed") {
-    return Promise.resolve(EOF);
-  }
-
-  return stream.ready.then(() => {
-    if (stream.state === "closed") {
-      return EOF;
-    }
-
-    // If stream is "errored", this will throw, causing the promise to be rejected.
-    return stream.read();
-  });
-}
-
-// Usage with proposed ES2016 async/await keywords:
-async function processStream(stream) {
-  while ((const chunk = await getNext(stream)) !== EOF) {
-    // do something with `chunk`.
-  }
-}
-```
-
 ### Buffering the Entire Stream Into Memory
 
 This function uses the reading APIs to buffer the entire stream in memory and give a promise for the results, defeating the purpose of streams but educating us while doing so:
@@ -42,19 +12,17 @@ This function uses the reading APIs to buffer the entire stream in memory and gi
 function readableStreamToArray(readable) {
   const chunks = [];
 
-  pump();
-  return readable.closed.then(() => chunks);
+  return pump();
 
   function pump() {
-    while (readable.state === "readable") {
-      chunks.push(readable.read());
-    }
-
-    if (readable.state === "waiting") {
-      readable.ready.then(pump);
-    }
+    return readable.read().then(chunk => {
+      if (chunk === ReadableStream.EOS) {
+        return chunks;
+      }
 
-    // Otherwise the stream is "closed" or "errored", which will be handled above.
+      chunks.push(chunk);
+      return pump();
+    });
   }
 }
 
diff --git a/index.bs b/index.bs
index 9844d75af..c3f70c12d 100644
--- a/index.bs
+++ b/index.bs
@@ -189,23 +189,18 @@ associated reader will automatically release its lock.
 </div>
 
 <div class="example">
-  Although readable streams will usually be used by piping them to a writable stream, you can also "pump" them
-  directly, alternating between using the <code>read()</code> method and the <code>ready</code> getter according to the
-  current value of the <code>state</code> property. For example, this function writes the contents of a readable stream
-  to the console as fast as they are available.
+  Although readable streams will usually be used by piping them to a writable stream, you can also read them directly,
+  using their <code>read()</code> method to get successive chunks. For example, this function writes the contents of a
+  readable stream to the console as fast as they are available.
 
   <pre><code class="lang-javascript">
     function logChunks(readableStream) {
-      while (readableStream.state === "readable") {
-        console.log(readableStream.read());
-      }
-
-      if (readableStream.state === "waiting") {
-        console.log("--- waiting for more data to be available...");
-        readableStream.ready.then(() => logChunks(readableStream));
+      return readable.read().then(chunk => {
+        if (chunk !=== ReadableStream.EOS) {
+          console.log(chunk);
+          return logChunks(readableStream);
+        }
       }
-
-      return readableStream.closed;
     }
 
     logChunks(readableStream)
@@ -228,7 +223,6 @@ would look like
     constructor(underlyingSource = {})
 
     get closed()
-    get ready()
     get state()
 
     cancel(reason)
@@ -477,18 +471,17 @@ Instances of <code>ReadableStream</code> are created with the internal slots des
       const reader = readableStream.getReader();
       const chunks = [];
 
-      pump();
-
-      return reader.closed.then(() => chunks);
+      return pump();
 
       function pump() {
-        while (reader.state === "readable") {
-          chunks.push(reader.read());
-        }
+        return readable.read().then(chunk => {
+          if (chunk === ReadableStream.EOS) {
+            return chunks;
+          }
 
-        if (reader.state === "waiting") {
-          reader.ready.then(pump);
-        }
+          chunks.push(chunk);
+          return pump();
+        });
       }
     }
   </code></pre>
@@ -2206,8 +2199,8 @@ APIs:
   streamyWS.writable.write("Hello");
   streamyWS.writable.write("web socket!");
 
-  streamyWS.readable.ready.then(() => {
-    console.log("The web socket says: ", streamyWS.readable.read());
+  streamyWS.readable.read().then(chunk => {
+    console.log("The web socket says: ", chunk);
   });
 </code></pre>
 
diff --git a/reference-implementation/lib/exclusive-stream-reader.js b/reference-implementation/lib/exclusive-stream-reader.js
deleted file mode 100644
index 5fc7cfb01..000000000
--- a/reference-implementation/lib/exclusive-stream-reader.js
+++ /dev/null
@@ -1,148 +0,0 @@
-const assert = require('assert');
-import { ReadFromReadableStream, CancelReadableStream, CloseReadableStreamReader, IsExclusiveStreamReader,
-  IsReadableStreamLocked } from './readable-stream-abstract-ops';
-
-export default class ExclusiveStreamReader {
-  constructor(stream) {
-    if (!('_readableStreamReader' in stream)) {
-      throw new TypeError('ExclusiveStreamReader can only be used with ReadableStream objects or subclasses');
-    }
-
-    if (IsReadableStreamLocked(stream)) {
-      throw new TypeError('This stream has already been locked for exclusive reading by another reader');
-    }
-
-    assert(stream._state === 'waiting' || stream._state === 'readable');
-
-    // Update the states of the encapsulated stream to represent a locked stream.
-    if (stream._state === 'readable') {
-      stream._initReadyPromise();
-    }
-    stream._readableStreamReader = this;
-
-    // Sync the states of this reader with the encapsulated stream.
-    this._state = stream._state;
-    if (stream._state === 'waiting') {
-      this._initReadyPromise();
-    } else {
-      this._readyPromise = Promise.resolve(undefined);
-    }
-    this._initClosedPromise();
-
-    this._encapsulatedReadableStream = stream;
-  }
-
-  get ready() {
-    if (!IsExclusiveStreamReader(this)) {
-      return Promise.reject(new TypeError('ExclusiveStreamReader.prototype.ready can only be used on a ' +
-        'ExclusiveStreamReader'));
-    }
-
-    return this._readyPromise;
-  }
-
-  get state() {
-    if (!IsExclusiveStreamReader(this)) {
-      throw new TypeError('ExclusiveStreamReader.prototype.state can only be used on a ExclusiveStreamReader');
-    }
-
-    return this._state;
-  }
-
-  get closed() {
-    if (!IsExclusiveStreamReader(this)) {
-      return Promise.reject(new TypeError('ExclusiveStreamReader.prototype.closed can only be used on a ' +
-        'ExclusiveStreamReader'));
-    }
-
-    return this._closedPromise;
-  }
-
-  get isActive() {
-    if (!IsExclusiveStreamReader(this)) {
-      throw new TypeError('ExclusiveStreamReader.prototype.isActive can only be used on a ExclusiveStreamReader');
-    }
-
-    return this._encapsulatedReadableStream._readableStreamReader === this;
-  }
-
-  read() {
-    if (!IsExclusiveStreamReader(this)) {
-      throw new TypeError('ExclusiveStreamReader.prototype.read can only be used on a ExclusiveStreamReader');
-    }
-
-    if (this._encapsulatedReadableStream._readableStreamReader !== this) {
-      throw new TypeError('This stream reader has released its lock on the stream and can no longer be used');
-    }
-
-    // Bypass lock check.
-    return ReadFromReadableStream(this._encapsulatedReadableStream);
-  }
-
-  cancel(reason) {
-    if (!IsExclusiveStreamReader(this)) {
-      return Promise.reject(new TypeError('ExclusiveStreamReader.prototype.cancel can only be used on a ' +
-        'ExclusiveStreamReader'));
-    }
-
-    if (this._encapsulatedReadableStream._readableStreamReader !== this) {
-      return this._closedPromise;
-    }
-
-    // Bypass lock check.
-    return CancelReadableStream(this._encapsulatedReadableStream, reason);
-  }
-
-  releaseLock() {
-    if (!IsExclusiveStreamReader(this)) {
-      throw new TypeError('ExclusiveStreamReader.prototype.releaseLock can only be used on a ExclusiveStreamReader');
-    }
-
-    if (this._encapsulatedReadableStream._readableStreamReader !== this) {
-      return undefined;
-    }
-
-    // When the stream is errored or closed, the reader is released automatically. So, here, this._state is neither
-    // 'closed' nor 'errored'.
-    assert(this._state === 'waiting' || this._state === 'readable');
-
-    CloseReadableStreamReader(this);
-
-    if (this._encapsulatedReadableStream._state === 'readable') {
-      this._encapsulatedReadableStream._resolveReadyPromise(undefined);
-    }
-    this._encapsulatedReadableStream._readableStreamReader = undefined;
-  }
-
-  // Utility functions
-
-  _initReadyPromise() {
-    this._readyPromise = new Promise((resolve, reject) => {
-      this._readyPromise_resolve = resolve;
-    });
-  }
-
-  _initClosedPromise() {
-    this._closedPromise = new Promise((resolve, reject) => {
-      this._closedPromise_resolve = resolve;
-      this._closedPromise_reject = reject;
-    });
-  }
-
-  _resolveReadyPromise(value) {
-    this._readyPromise_resolve(value);
-    this._readyPromise_resolve = null;
-  }
-
-  _resolveClosedPromise(value) {
-    this._closedPromise_resolve(value);
-    this._closedPromise_resolve = null;
-    this._closedPromise_reject = null;
-  }
-
-  _rejectClosedPromise(reason) {
-    this._closedPromise_reject(reason);
-    this._closedPromise_resolve = null;
-    this._closedPromise_reject = null;
-  }
-}
diff --git a/reference-implementation/lib/readable-stream-abstract-ops.js b/reference-implementation/lib/readable-stream-abstract-ops.js
index 65abcb44d..c9d8014bf 100644
--- a/reference-implementation/lib/readable-stream-abstract-ops.js
+++ b/reference-implementation/lib/readable-stream-abstract-ops.js
@@ -1,18 +1,8 @@
 const assert = require('assert');
-import ExclusiveStreamReader from './exclusive-stream-reader';
 import { DequeueValue, EnqueueValueWithSize, GetTotalQueueSize } from './queue-with-sizes';
 import { PromiseInvokeOrNoop, typeIsObject } from './helpers';
 
-export function AcquireExclusiveStreamReader(stream) {
-  if (stream._state === 'closed') {
-    throw new TypeError('The stream has already been closed, so a reader cannot be acquired.');
-  }
-  if (stream._state === 'errored') {
-    throw stream._storedError;
-  }
-
-  return new ExclusiveStreamReader(stream);
-}
+export const ReadableStreamEOS = Symbol('ReadableStream.EOS');
 
 export function CallReadableStreamPull(stream) {
   if (stream._draining === true || stream._started === false ||
@@ -57,17 +47,7 @@ export function CancelReadableStream(stream, reason) {
 }
 
 function CloseReadableStream(stream) {
-  if (IsReadableStreamLocked(stream)) {
-    CloseReadableStreamReader(stream._readableStreamReader);
-
-    stream._readableStreamReader = undefined;
-
-    // rs.ready() was pending because there was a reader.
-    stream._resolveReadyPromise(undefined);
-  } else if (stream._state === 'waiting') {
-    stream._resolveReadyPromise(undefined);
-  }
-
+  stream._readyPromise_resolve(undefined);
   stream._resolveClosedPromise(undefined);
 
   stream._state = 'closed';
@@ -75,21 +55,15 @@ function CloseReadableStream(stream) {
   return undefined;
 }
 
-export function CloseReadableStreamReader(reader) {
-  if (reader._state === 'waiting') {
-    reader._resolveReadyPromise(undefined);
-  }
-  reader._resolveClosedPromise(undefined);
-  reader._state = 'closed';
-}
-
 export function CreateReadableStreamCloseFunction(stream) {
   return () => {
-    if (stream._state === 'waiting') {
-      CloseReadableStream(stream);
-    }
     if (stream._state === 'readable') {
-      stream._draining = true;
+      // TODO: refactor draining to a 'close' readRecord, like WritableStream uses!?
+      if (stream._queue.length === 0) {
+        CloseReadableStream(stream);
+      } else {
+        stream._draining = true;
+      }
     }
   };
 }
@@ -127,6 +101,7 @@ export function CreateReadableStreamEnqueueFunction(stream) {
       }
     }
 
+    const queueWasEmpty = stream._queue.length === 0;
     try {
       EnqueueValueWithSize(stream._queue, chunk, chunkSize);
     } catch (enqueueE) {
@@ -137,8 +112,8 @@ export function CreateReadableStreamEnqueueFunction(stream) {
 
     const shouldApplyBackpressure = ShouldReadableStreamApplyBackpressure(stream);
 
-    if (stream._state === 'waiting') {
-      MarkReadableStreamReadable(stream);
+    if (queueWasEmpty) {
+      stream._readyPromise_resolve(undefined);
     }
 
     if (shouldApplyBackpressure === true) {
@@ -154,26 +129,10 @@ export function CreateReadableStreamErrorFunction(stream) {
       return;
     }
 
-    if (stream._state === 'readable') {
-      stream._queue = [];
-    }
-
-    if (IsReadableStreamLocked(stream)) {
-      if (stream._state === 'waiting') {
-        stream._readableStreamReader._resolveReadyPromise(undefined);
-      }
-
-      // rs.ready() was pending because there was a reader.
-      stream._resolveReadyPromise(undefined);
+    assert(stream._state === 'readable', `stream state ${stream._state} is invalid`);
 
-      stream._readableStreamReader._rejectClosedPromise(e);
-
-      stream._readableStreamReader._state = 'errored';
-
-      stream._readableStreamReader = undefined;
-    } else if (stream._state === 'waiting') {
-      stream._resolveReadyPromise(undefined);
-    }
+    stream._queue = [];
+    stream._readyPromise_resolve(undefined);
     stream._rejectClosedPromise(e);
 
     stream._storedError = e;
@@ -183,28 +142,6 @@ export function CreateReadableStreamErrorFunction(stream) {
   };
 }
 
-export function IsExclusiveStreamReader(x) {
-  if (!typeIsObject(x)) {
-    return false;
-  }
-
-  if (!Object.prototype.hasOwnProperty.call(x, '_encapsulatedReadableStream')) {
-    return false;
-  }
-
-  return true;
-}
-
-export function IsReadableStreamLocked(stream) {
-  assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known readable streams');
-
-  if (stream._readableStreamReader === undefined) {
-    return false;
-  }
-
-  return true;
-}
-
 export function IsReadableStream(x) {
   if (!typeIsObject(x)) {
     return false;
@@ -217,61 +154,41 @@ export function IsReadableStream(x) {
   return true;
 }
 
-function MarkReadableStreamReadable(stream) {
-  if (IsReadableStreamLocked(stream)) {
-    stream._readableStreamReader._resolveReadyPromise(undefined);
-
-    stream._readableStreamReader._state = 'readable';
-  } else {
-    stream._resolveReadyPromise(undefined);
-  }
-
-  stream._state = 'readable';
-
-  return undefined;
-}
-
-function MarkReadableStreamWaiting(stream) {
-  if (IsReadableStreamLocked(stream)) {
-    stream._readableStreamReader._initReadyPromise();
-
-    stream._readableStreamReader._state = 'waiting';
-  } else {
-    stream._initReadyPromise();
-  }
-
-  stream._state = 'waiting';
-
-  return undefined;
-}
-
 export function ReadFromReadableStream(stream) {
-  if (stream._state === 'waiting') {
-    throw new TypeError('no chunks available (yet)');
+  if (stream._state === 'errored') {
+    return Promise.reject(stream._storedError);
   }
+
   if (stream._state === 'closed') {
-    throw new TypeError('stream has already been consumed');
-  }
-  if (stream._state === 'errored') {
-    throw stream._storedError;
+    return Promise.resolve(ReadableStreamEOS);
   }
 
   assert(stream._state === 'readable', `stream state ${stream._state} is invalid`);
-  assert(stream._queue.length > 0, 'there must be chunks available to read');
 
-  const chunk = DequeueValue(stream._queue);
+  stream._reading = true;
 
-  if (stream._queue.length === 0) {
-    if (stream._draining === true) {
-      CloseReadableStream(stream);
-    } else {
-      MarkReadableStreamWaiting(stream);
+  if (stream._queue.length > 0) {
+    const chunk = DequeueValue(stream._queue);
+
+    if (stream._queue.length === 0) {
+      if (stream._draining === true) {
+        CloseReadableStream(stream);
+      } else {
+        stream._initReadyPromise();
+      }
     }
+
+    CallReadableStreamPull(stream);
+    const chunkPromise = Promise.resolve(chunk);
+    chunkPromise.then(() => {
+      stream._reading = false;
+    });
+    return chunkPromise;
   }
 
-  CallReadableStreamPull(stream);
+  // assert: stream._readyPromise is not fulfilled
 
-  return chunk;
+  return stream._readyPromise.then(() => ReadFromReadableStream(stream));
 }
 
 export function ShouldReadableStreamApplyBackpressure(stream) {
diff --git a/reference-implementation/lib/readable-stream.js b/reference-implementation/lib/readable-stream.js
index 1ab33e700..30107f390 100644
--- a/reference-implementation/lib/readable-stream.js
+++ b/reference-implementation/lib/readable-stream.js
@@ -1,7 +1,7 @@
 const assert = require('assert');
 import * as helpers from './helpers';
 import { AcquireExclusiveStreamReader, CallReadableStreamPull, CancelReadableStream, CreateReadableStreamCloseFunction,
-  CreateReadableStreamEnqueueFunction, CreateReadableStreamErrorFunction, IsReadableStream, IsReadableStreamLocked,
+  CreateReadableStreamEnqueueFunction, CreateReadableStreamErrorFunction, IsReadableStream, ReadableStreamEOS,
   ReadFromReadableStream, ShouldReadableStreamApplyBackpressure } from './readable-stream-abstract-ops';
 
 export default class ReadableStream {
@@ -10,9 +10,10 @@ export default class ReadableStream {
     this._initReadyPromise();
     this._initClosedPromise();
     this._queue = [];
-    this._state = 'waiting';
+    this._state = 'readable';
     this._started = false;
     this._draining = false;
+    this._reading = false;
     this._pullScheduled = false;
     this._pullingPromise = undefined;
     this._readableStreamReader = undefined;
@@ -44,10 +45,6 @@ export default class ReadableStream {
       throw new TypeError('ReadableStream.prototype.state can only be used on a ReadableStream');
     }
 
-    if (IsReadableStreamLocked(this)) {
-      return 'waiting';
-    }
-
     return this._state;
   }
 
@@ -56,22 +53,9 @@ export default class ReadableStream {
       return Promise.reject(new TypeError('ReadableStream.prototype.cancel can only be used on a ReadableStream'));
     }
 
-    if (IsReadableStreamLocked(this)) {
-      return Promise.reject(
-        new TypeError('This stream is locked to a single exclusive reader and cannot be cancelled directly'));
-    }
-
     return CancelReadableStream(this, reason);
   }
 
-  getReader() {
-    if (!IsReadableStream(this)) {
-      throw new TypeError('ReadableStream.prototype.getReader can only be used on a ReadableStream');
-    }
-
-    return AcquireExclusiveStreamReader(this);
-  }
-
   pipeThrough({ writable, readable }, options) {
     if (!helpers.typeIsObject(writable)) {
       throw new TypeError('A transform stream must have an writable property that is an object.');
@@ -90,7 +74,9 @@ export default class ReadableStream {
     preventAbort = Boolean(preventAbort);
     preventCancel = Boolean(preventCancel);
 
-    let source;
+    const source = this;
+    const EOS = source.constructor.EOS;
+    let closedPurposefully = false;
     let resolvePipeToPromise;
     let rejectPipeToPromise;
 
@@ -98,57 +84,45 @@ export default class ReadableStream {
       resolvePipeToPromise = resolve;
       rejectPipeToPromise = reject;
 
-      source = this.getReader();
+      source.closed.catch(abortDest);
+      dest.closed.then(
+        () => {
+          if (!closedPurposefully) {
+            cancelSource(new TypeError('destination is closing or closed and cannot be piped to anymore'));
+          }
+        },
+        cancelSource
+      );
+
       doPipe();
     });
 
     function doPipe() {
-      for (;;) {
-        const ds = dest.state;
-        if (ds === 'writable') {
-          if (source.state === 'readable') {
-            dest.write(source.read());
-            continue;
-          } else if (source.state === 'waiting') {
-            Promise.race([source.ready, dest.closed]).then(doPipe, doPipe);
-          } else if (source.state === 'errored') {
-            source.closed.catch(abortDest);
-          } else if (source.state === 'closed') {
-            closeDest();
-          }
-        } else if (ds === 'waiting') {
-          if (source.state === 'readable') {
-            Promise.race([source.closed, dest.ready]).then(doPipe, doPipe);
-          } else if (source.state === 'waiting') {
-            Promise.race([source.ready, dest.ready]).then(doPipe);
-          } else if (source.state === 'errored') {
-            source.closed.catch(abortDest);
-          } else if (source.state === 'closed') {
-            closeDest();
-          }
-        } else if (ds === 'errored' && (source.state === 'readable' || source.state === 'waiting')) {
-          dest.closed.catch(cancelSource);
-        } else if ((ds === 'closing' || ds === 'closed') &&
-            (source.state === 'readable' || source.state === 'waiting')) {
-          cancelSource(new TypeError('destination is closing or closed and cannot be piped to anymore'));
+      Promise.all([source.read(), dest.ready]).then(([chunk]) => {
+        if (chunk === EOS) {
+          closeDest();
+        } else {
+          dest.write(chunk);
+          doPipe();
         }
-        return;
-      }
+      });
+
+      // Any failures will be handled by listening to source.closed and dest.closed above.
+      // TODO: handle malicious dest.write/dest.close?
     }
 
     function cancelSource(reason) {
-      if (preventCancel === false) {
-        // implicitly releases the lock
+      const sourceState = source.state;
+      if (preventCancel === false && sourceState === 'readable') {
         source.cancel(reason);
-      } else {
-        source.releaseLock();
       }
       rejectPipeToPromise(reason);
     }
 
     function closeDest() {
-      source.releaseLock();
-      if (preventClose === false) {
+      const destState = dest.state;
+      if (preventClose === false && (destState === 'waiting' || destState === 'writable')) {
+        closedPurposefully = true;
         dest.close().then(resolvePipeToPromise, rejectPipeToPromise);
       } else {
         resolvePipeToPromise();
@@ -156,7 +130,6 @@ export default class ReadableStream {
     }
 
     function abortDest(reason) {
-      source.releaseLock();
       if (preventAbort === false) {
         dest.abort(reason);
       }
@@ -166,26 +139,19 @@ export default class ReadableStream {
 
   read() {
     if (!IsReadableStream(this)) {
-      throw new TypeError('ReadableStream.prototype.read can only be used on a ReadableStream');
+      return Promise.reject(new TypeError('ReadableStream.prototype.read can only be used on a ReadableStream'));
     }
 
-    if (IsReadableStreamLocked(this)) {
-      throw new TypeError('This stream is locked to a single exclusive reader and cannot be read from directly');
+    if (this._reading) {
+      return Promise.reject(new TypeError('A concurrent read is already in progress for this stream'));
     }
 
     return ReadFromReadableStream(this);
   }
 
-  get ready() {
-    if (!IsReadableStream(this)) {
-      return Promise.reject(new TypeError('ReadableStream.prototype.ready can only be used on a ReadableStream'));
-    }
-
-    return this._readyPromise;
-  }
 
   _initReadyPromise() {
-    this._readyPromise = new Promise((resolve, reject) => {
+    this._readyPromise = new Promise((resolve) => {
       this._readyPromise_resolve = resolve;
     });
   }
@@ -203,11 +169,6 @@ export default class ReadableStream {
   // detect unexpected extra resolve/reject calls that may be caused by bugs in
   // the algorithm.
 
-  _resolveReadyPromise(value) {
-    this._readyPromise_resolve(value);
-    this._readyPromise_resolve = null;
-  }
-
   _resolveClosedPromise(value) {
     this._closedPromise_resolve(value);
     this._closedPromise_resolve = null;
@@ -220,3 +181,10 @@ export default class ReadableStream {
     this._closedPromise_reject = null;
   }
 }
+
+Object.defineProperty(ReadableStream, 'EOS', {
+  value: ReadableStreamEOS,
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
diff --git a/reference-implementation/lib/transform-stream.js b/reference-implementation/lib/transform-stream.js
index 6ad82b6a7..c3ef2bff6 100644
--- a/reference-implementation/lib/transform-stream.js
+++ b/reference-implementation/lib/transform-stream.js
@@ -19,9 +19,7 @@ export default class TransformStream {
         chunkWrittenButNotYetTransformed = true;
 
         const p = new Promise(resolve => writeDone = resolve);
-        if (readable.state === 'waiting') {
-          maybeDoTransform();
-        }
+        maybeDoTransform();
         return p;
       },
       close() {
diff --git a/reference-implementation/run-tests.js b/reference-implementation/run-tests.js
index 7d6e1463d..c6befec97 100644
--- a/reference-implementation/run-tests.js
+++ b/reference-implementation/run-tests.js
@@ -16,6 +16,12 @@ global.CountQueuingStrategy = CountQueuingStrategy;
 global.TransformStream = TransformStream;
 
 
-const tests = glob.sync(path.resolve(__dirname, 'test/*.js'));
-const experimentalTests = glob.sync(path.resolve(__dirname, 'test/experimental/*.js'));
-tests.concat(experimentalTests).forEach(require);
+if (process.argv.length === 3) {
+    const tests = glob.sync(path.resolve(__dirname, 'test/*.js'));
+
+    // disable experimental tests while we figure out impact of async read on ReadableByteStream
+    const experimentalTests = []; // glob.sync(path.resolve(__dirname, 'test/experimental/*.js'));
+    tests.concat(experimentalTests).forEach(require);
+} else {
+    glob.sync(path.resolve(process.argv[3])).forEach(require);
+}
diff --git a/reference-implementation/test/bad-underlying-sources.js b/reference-implementation/test/bad-underlying-sources.js
index aecdf6f91..4453cb4fa 100644
--- a/reference-implementation/test/bad-underlying-sources.js
+++ b/reference-implementation/test/bad-underlying-sources.js
@@ -1,6 +1,6 @@
 const test = require('tape-catch');
 
-test('Throwing underlying source start getter', t => {
+test('Underlying source start: throwing getter', t => {
   const theError = new Error('a unique string');
 
   t.throws(() => {
@@ -9,11 +9,11 @@ test('Throwing underlying source start getter', t => {
         throw theError;
       }
     });
-  }, /a unique string/);
+  }, /a unique string/, 'constructing the stream should re-throw the error');
   t.end();
 });
 
-test('Throwing underlying source start method', t => {
+test('Underlying source start: throwing method', t => {
   const theError = new Error('a unique string');
 
   t.throws(() => {
@@ -22,11 +22,11 @@ test('Throwing underlying source start method', t => {
         throw theError;
       }
     });
-  }, /a unique string/);
+  }, /a unique string/, 'constructing the stream should re-throw the error');
   t.end();
 });
 
-test('Throwing underlying source pull getter (initial pull)', t => {
+test('Underlying source: throwing pull getter (initial pull)', t => {
   t.plan(1);
 
   const theError = new Error('a unique string');
@@ -42,7 +42,7 @@ test('Throwing underlying source pull getter (initial pull)', t => {
   );
 });
 
-test('Throwing underlying source pull method (initial pull)', t => {
+test('Underlying source: throwing pull method (initial pull)', t => {
   t.plan(1);
 
   const theError = new Error('a unique string');
@@ -58,8 +58,8 @@ test('Throwing underlying source pull method (initial pull)', t => {
   );
 });
 
-test('Throwing underlying source pull getter (second pull)', t => {
-  t.plan(3);
+test('Underlying source: throwing pull getter (second pull)', t => {
+  t.plan(4);
 
   const theError = new Error('a unique string');
   let counter = 0;
@@ -74,9 +74,11 @@ test('Throwing underlying source pull getter (second pull)', t => {
     }
   });
 
-  rs.ready.then(() => {
-    t.equal(rs.state, 'readable', 'sanity check: the stream becomes readable without issue');
-    t.equal(rs.read(), 'a', 'the initially-enqueued chunk can be read from the stream');
+  t.equal(rs.state, 'readable', 'the stream should start readable');
+
+  rs.read().then(v => {
+    t.equal(rs.state, 'errored', 'the stream should be errored after the first read');
+    t.equal(v, 'a', 'the chunk read should be correct');
   });
 
   rs.closed.then(
@@ -85,8 +87,8 @@ test('Throwing underlying source pull getter (second pull)', t => {
   );
 });
 
-test('Throwing underlying source pull method (second pull)', t => {
-  t.plan(3);
+test('Underlying source: throwing pull method (second pull)', t => {
+  t.plan(4);
 
   const theError = new Error('a unique string');
   let counter = 0;
@@ -101,9 +103,11 @@ test('Throwing underlying source pull method (second pull)', t => {
     }
   });
 
-  rs.ready.then(() => {
-    t.equal(rs.state, 'readable', 'sanity check: the stream becomes readable without issue');
-    t.equal(rs.read(), 'a', 'the initially-enqueued chunk can be read from the stream');
+  t.equal(rs.state, 'readable', 'the stream should start readable');
+
+  rs.read().then(v => {
+    t.equal(rs.state, 'errored', 'the stream should be errored after the first read');
+    t.equal(v, 'a', 'the chunk read should be correct');
   });
 
   rs.closed.then(
@@ -112,7 +116,7 @@ test('Throwing underlying source pull method (second pull)', t => {
   );
 });
 
-test('Throwing underlying source cancel getter', t => {
+test('Underlying source: throwing cancel getter', t => {
   t.plan(1);
 
   const theError = new Error('a unique string');
@@ -128,7 +132,7 @@ test('Throwing underlying source cancel getter', t => {
   );
 });
 
-test('Throwing underlying source cancel method', t => {
+test('Underlying source: throwing cancel method', t => {
   t.plan(1);
 
   const theError = new Error('a unique string');
@@ -144,14 +148,14 @@ test('Throwing underlying source cancel method', t => {
   );
 });
 
-test('Throwing underlying source strategy getter', t => {
+test('Underlying source: throwing strategy getter', t => {
   t.plan(2);
 
   const theError = new Error('a unique string');
 
   const rs = new ReadableStream({
     start(enqueue) {
-      t.throws(() => enqueue('a'), /a unique string/);
+      t.throws(() => enqueue('a'), /a unique string/, 'enqueue should throw the error');
     },
     get strategy() {
       throw theError;
@@ -161,13 +165,13 @@ test('Throwing underlying source strategy getter', t => {
   t.equal(rs.state, 'errored', 'state should be errored');
 });
 
-test('Throwing underlying source strategy.size getter', t => {
+test('Underlying source: throwing strategy.size getter', t => {
   t.plan(2);
 
   const theError = new Error('a unique string');
   const rs = new ReadableStream({
     start(enqueue) {
-      t.throws(() => enqueue('a'), /a unique string/);
+      t.throws(() => enqueue('a'), /a unique string/, 'enqueue should throw the error');
     },
     strategy: {
       get size() {
@@ -182,13 +186,13 @@ test('Throwing underlying source strategy.size getter', t => {
   t.equal(rs.state, 'errored', 'state should be errored');
 });
 
-test('Throwing underlying source strategy.size method', t => {
+test('Underlying source: throwing strategy.size method', t => {
   t.plan(2);
 
   const theError = new Error('a unique string');
   const rs = new ReadableStream({
     start(enqueue) {
-      t.throws(() => enqueue('a'), /a unique string/);
+      t.throws(() => enqueue('a'), /a unique string/, 'enqueue should throw the error');
     },
     strategy: {
       size() {
@@ -203,13 +207,13 @@ test('Throwing underlying source strategy.size method', t => {
   t.equal(rs.state, 'errored', 'state should be errored');
 });
 
-test('Throwing underlying source strategy.shouldApplyBackpressure getter', t => {
+test('Underlying source: throwing strategy.shouldApplyBackpressure getter', t => {
   t.plan(2);
 
   const theError = new Error('a unique string');
   const rs = new ReadableStream({
     start(enqueue) {
-      t.throws(() => enqueue('a'), /a unique string/);
+      t.throws(() => enqueue('a'), /a unique string/, 'enqueue should throw the error');
     },
     strategy: {
       size() {
@@ -224,13 +228,13 @@ test('Throwing underlying source strategy.shouldApplyBackpressure getter', t =>
   t.equal(rs.state, 'errored', 'state should be errored');
 });
 
-test('Throwing underlying source strategy.shouldApplyBackpressure method', t => {
+test('Underlying source: throwing strategy.shouldApplyBackpressure method', t => {
   t.plan(2);
 
   const theError = new Error('a unique string');
   const rs = new ReadableStream({
     start(enqueue) {
-      t.throws(() => enqueue('a'), /a unique string/);
+      t.throws(() => enqueue('a'), /a unique string/, 'enqueue should throw the error');
     },
     strategy: {
       size() {
@@ -244,3 +248,78 @@ test('Throwing underlying source strategy.shouldApplyBackpressure method', t =>
 
   t.equal(rs.state, 'errored', 'state should be errored');
 });
+
+test('Underlying source: strategy.size returning NaN', t => {
+  t.plan(2);
+
+  const rs = new ReadableStream({
+    start(enqueue) {
+      try {
+        enqueue('hi');
+        t.fail('enqueue didn\'t throw');
+      } catch (error) {
+        t.equal(error.constructor, RangeError, 'enqueue should throw a RangeError');
+      }
+    },
+    strategy: {
+      size() {
+        return NaN;
+      },
+      shouldApplyBackpressure() {
+        return true;
+      }
+    }
+  });
+
+  t.equal(rs.state, 'errored', 'state should be errored');
+});
+
+test('Underlying source: strategy.size returning -Infinity', t => {
+  t.plan(2);
+
+  const rs = new ReadableStream({
+    start(enqueue) {
+      try {
+        enqueue('hi');
+        t.fail('enqueue didn\'t throw');
+      } catch (error) {
+        t.equal(error.constructor, RangeError, 'enqueue should throw a RangeError');
+      }
+    },
+    strategy: {
+      size() {
+        return -Infinity;
+      },
+      shouldApplyBackpressure() {
+        return true;
+      }
+    }
+  });
+
+  t.equal(rs.state, 'errored', 'state should be errored');
+});
+
+test('Underlying source: strategy.size returning +Infinity', t => {
+  t.plan(2);
+
+  const rs = new ReadableStream({
+    start(enqueue) {
+      try {
+        enqueue('hi');
+        t.fail('enqueue didn\'t throw');
+      } catch (error) {
+        t.equal(error.constructor, RangeError, 'enqueue should throw a RangeError');
+      }
+    },
+    strategy: {
+      size() {
+        return +Infinity;
+      },
+      shouldApplyBackpressure() {
+        return true;
+      }
+    }
+  });
+
+  t.equal(rs.state, 'errored', 'state should be errored');
+});
diff --git a/reference-implementation/test/brand-checks.js b/reference-implementation/test/brand-checks.js
index fb4103bb5..3a9aaaa48 100644
--- a/reference-implementation/test/brand-checks.js
+++ b/reference-implementation/test/brand-checks.js
@@ -1,25 +1,16 @@
 const test = require('tape-catch');
 
-let ExclusiveStreamReader;
-
-test('Can get the ExclusiveStreamReader constructor indirectly', t => {
-  t.doesNotThrow(() => {
-    // It's not exposed globally, but we test a few of its properties here.
-    ExclusiveStreamReader = (new ReadableStream()).getReader().constructor;
-  });
-  t.end();
-});
-
 function fakeReadableStream() {
   return {
     get closed() { return Promise.resolve(); },
-    get ready() { return Promise.resolve(); },
     get state() { return 'closed' },
     cancel(reason) { return Promise.resolve(); },
-    getReader() { return new ExclusiveStreamReader(new ReadableStream()); },
     pipeThrough({ writable, readable }, options) { return readable; },
     pipeTo(dest, { preventClose, preventAbort, preventCancel } = {}) { return Promise.resolve(); },
-    read() { return ''; }
+    read() { return Promise.resolve(ReadableStream.EOS); },
+    constructor: {
+      EOS: ReadableStream.EOS
+    }
   };
 }
 
@@ -42,18 +33,6 @@ function realWritableStream() {
   return new WritableStream();
 }
 
-function fakeExclusiveStreamReader() {
-  return {
-    get closed() { return Promise.resolve(); },
-    get isActive() { return false; },
-    get ready() { return Promise.resolve(); },
-    get state() { return 'closed' },
-    cancel(reason) { return Promise.resolve(); },
-    read() { return ''; },
-    releaseLock() { return; }
-  };
-}
-
 function fakeByteLengthQueuingStrategy() {
   return {
     shouldApplyBackpressure(queueSize) {
@@ -120,12 +99,6 @@ test('ReadableStream.prototype.closed enforces a brand check', t => {
   getterRejects(t, ReadableStream.prototype, 'closed', realWritableStream());
 });
 
-test('ReadableStream.prototype.ready enforces a brand check', t => {
-  t.plan(2);
-  getterRejects(t, ReadableStream.prototype, 'ready', fakeReadableStream());
-  getterRejects(t, ReadableStream.prototype, 'ready', realWritableStream());
-});
-
 test('ReadableStream.prototype.state enforces a brand check', t => {
   t.plan(2);
   getterThrows(t, ReadableStream.prototype, 'state', fakeReadableStream());
@@ -138,12 +111,6 @@ test('ReadableStream.prototype.cancel enforces a brand check', t => {
   methodRejects(t, ReadableStream.prototype, 'cancel', realWritableStream());
 });
 
-test('ReadableStream.prototype.getReader enforces a brand check', t => {
-  t.plan(2);
-  methodThrows(t, ReadableStream.prototype, 'getReader', fakeReadableStream());
-  methodThrows(t, ReadableStream.prototype, 'getReader', realWritableStream());
-});
-
 test('ReadableStream.prototype.pipeThrough works generically on its this and its arguments', t => {
   t.plan(2);
 
@@ -172,50 +139,8 @@ test('ReadableStream.prototype.pipeTo works generically on its this and its argu
 
 test('ReadableStream.prototype.read enforces a brand check', t => {
   t.plan(2);
-  methodThrows(t, ReadableStream.prototype, 'read', fakeReadableStream());
-  methodThrows(t, ReadableStream.prototype, 'read', realWritableStream());
-});
-
-
-test('ExclusiveStreamReader enforces a brand check on its argument', t => {
-  t.plan(1);
-  t.throws(() => new ExclusiveStreamReader(fakeReadableStream()), /TypeError/, 'Contructing an ExclusiveStreamReader ' +
-    'should throw');
-});
-
-test('ExclusiveStreamReader.prototype.closed enforces a brand check', t => {
-  t.plan(1);
-  getterRejects(t, ExclusiveStreamReader.prototype, 'closed', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.isActive enforces a brand check', t => {
-  t.plan(1);
-  getterThrows(t, ExclusiveStreamReader.prototype, 'isActive', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.ready enforces a brand check', t => {
-  t.plan(1);
-  getterRejects(t, ExclusiveStreamReader.prototype, 'ready', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.state enforces a brand check', t => {
-  t.plan(1);
-  getterThrows(t, ExclusiveStreamReader.prototype, 'state', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.cancel enforces a brand check', t => {
-  t.plan(1);
-  methodRejects(t, ExclusiveStreamReader.prototype, 'cancel', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.read enforces a brand check', t => {
-  t.plan(1);
-  methodThrows(t, ExclusiveStreamReader.prototype, 'read', fakeExclusiveStreamReader());
-});
-
-test('ExclusiveStreamReader.prototype.releaseLock enforces a brand check', t => {
-  t.plan(1);
-  methodThrows(t, ExclusiveStreamReader.prototype, 'releaseLock', fakeExclusiveStreamReader());
+  methodRejects(t, ReadableStream.prototype, 'read', fakeReadableStream());
+  methodRejects(t, ReadableStream.prototype, 'read', realWritableStream());
 });
 
 
diff --git a/reference-implementation/test/count-queuing-strategy.js b/reference-implementation/test/count-queuing-strategy.js
index c68035218..a15c78757 100644
--- a/reference-implementation/test/count-queuing-strategy.js
+++ b/reference-implementation/test/count-queuing-strategy.js
@@ -36,19 +36,30 @@ test('Correctly governs the return value of a ReadableStream\'s enqueue function
   t.equal(enqueue('c'), false, 'After 0 reads, 3rd enqueue should return false (queue now contains 3 chunks)');
   t.equal(enqueue('d'), false, 'After 0 reads, 4th enqueue should return false (queue now contains 4 chunks)');
 
-  t.equal(rs.read(), 'a', '1st read gives back the 1st chunk enqueued (queue now contains 3 chunks)');
-  t.equal(rs.read(), 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 2 chunks)');
-  t.equal(rs.read(), 'c', '3rd read gives back the 2nd chunk enqueued (queue now contains 1 chunk)');
-
-  t.equal(enqueue('e'), false, 'After 3 reads, 5th enqueue should return false (queue now contains 2 chunks)');
-
-  t.equal(rs.read(), 'd', '4th read gives back the 3rd chunk enqueued (queue now contains 1 chunks)');
-  t.equal(rs.read(), 'e', '5th read gives back the 4th chunk enqueued (queue now contains 0 chunks)');
-
-  t.equal(enqueue('f'), false, 'After 5 reads, 6th enqueue should return false (queue now contains 1 chunk)');
-  t.equal(enqueue('g'), false, 'After 5 reads, 7th enqueue should return false (queue now contains 2 chunks)');
-
-  t.end();
+  rs.read().then(chunk => {
+    t.equal(chunk, 'a', '1st read gives back the 1st chunk enqueued (queue now contains 3 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 2 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'c', '3rd read gives back the 2nd chunk enqueued (queue now contains 1 chunk)');
+    t.equal(enqueue('e'), false, 'After 3 reads, 5th enqueue should return false (queue now contains 2 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'd', '4th read gives back the 3rd chunk enqueued (queue now contains 1 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'e', '5th read gives back the 4th chunk enqueued (queue now contains 0 chunks)');
+    t.equal(enqueue('f'), false, 'After 5 reads, 6th enqueue should return false (queue now contains 1 chunk)');
+    t.equal(enqueue('g'), false, 'After 5 reads, 7th enqueue should return false (queue now contains 2 chunks)');
+    t.end();
+  })
+  .catch(e => t.error(e));
 });
 
 test('Correctly governs the return value of a ReadableStream\'s enqueue function (HWM = 1)', t => {
@@ -63,19 +74,30 @@ test('Correctly governs the return value of a ReadableStream\'s enqueue function
   t.equal(enqueue('c'), false, 'After 0 reads, 3rd enqueue should return false (queue now contains 3 chunks)');
   t.equal(enqueue('d'), false, 'After 0 reads, 4th enqueue should return false (queue now contains 4 chunks)');
 
-  t.equal(rs.read(), 'a', '1st read gives back the 1st chunk enqueued (queue now contains 3 chunks)');
-  t.equal(rs.read(), 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 2 chunks)');
-  t.equal(rs.read(), 'c', '3rd read gives back the 2nd chunk enqueued (queue now contains 1 chunk)');
-
-  t.equal(enqueue('e'), false, 'After 3 reads, 5th enqueue should return false (queue now contains 2 chunks)');
-
-  t.equal(rs.read(), 'd', '4th read gives back the 3rd chunk enqueued (queue now contains 1 chunks)');
-  t.equal(rs.read(), 'e', '5th read gives back the 4th chunk enqueued (queue now contains 0 chunks)');
-
-  t.equal(enqueue('f'), true, 'After 5 reads, 6th enqueue should return true (queue now contains 1 chunk)');
-  t.equal(enqueue('g'), false, 'After 5 reads, 7th enqueue should return false (queue now contains 2 chunks)');
-
-  t.end();
+  rs.read().then(chunk => {
+    t.equal(chunk, 'a', '1st read gives back the 1st chunk enqueued (queue now contains 3 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 2 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'c', '3rd read gives back the 2nd chunk enqueued (queue now contains 1 chunk)');
+    t.equal(enqueue('e'), false, 'After 3 reads, 5th enqueue should return false (queue now contains 2 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'd', '4th read gives back the 3rd chunk enqueued (queue now contains 1 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'e', '5th read gives back the 4th chunk enqueued (queue now contains 0 chunks)');
+    t.equal(enqueue('f'), true, 'After 5 reads, 6th enqueue should return true (queue now contains 1 chunk)');
+    t.equal(enqueue('g'), false, 'After 5 reads, 7th enqueue should return false (queue now contains 2 chunks)');
+    t.end();
+  })
+  .catch(e => t.error(e));
 });
 
 test('Correctly governs the return value of a ReadableStream\'s enqueue function (HWM = 4)', t => {
@@ -92,22 +114,36 @@ test('Correctly governs the return value of a ReadableStream\'s enqueue function
   t.equal(enqueue('e'), false, 'After 0 reads, 5th enqueue should return false (queue now contains 5 chunks)');
   t.equal(enqueue('f'), false, 'After 0 reads, 6th enqueue should return false (queue now contains 6 chunks)');
 
-  t.equal(rs.read(), 'a', '1st read gives back the 1st chunk enqueued (queue now contains 5 chunks)');
-  t.equal(rs.read(), 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 4 chunks)');
-
-  t.equal(enqueue('g'), false, 'After 2 reads, 7th enqueue should return false (queue now contains 5 chunks)');
-
-  t.equal(rs.read(), 'c', '3rd read gives back the 3rd chunk enqueued (queue now contains 4 chunks)');
-  t.equal(rs.read(), 'd', '4th read gives back the 4th chunk enqueued (queue now contains 3 chunks)');
-  t.equal(rs.read(), 'e', '5th read gives back the 5th chunk enqueued (queue now contains 2 chunks)');
-  t.equal(rs.read(), 'f', '6th read gives back the 6th chunk enqueued (queue now contains 1 chunk)');
-
-  t.equal(enqueue('h'), true, 'After 6 reads, 8th enqueue should return true (queue now contains 2 chunks)');
-  t.equal(enqueue('i'), true, 'After 6 reads, 9th enqueue should return true (queue now contains 3 chunks)');
-  t.equal(enqueue('j'), true, 'After 6 reads, 10th enqueue should return true (queue now contains 4 chunks)');
-  t.equal(enqueue('k'), false, 'After 6 reads, 11th enqueue should return false (queue now contains 5 chunks)');
-
-  t.end();
+  rs.read().then(chunk => {
+    t.equal(chunk, 'a', '1st read gives back the 1st chunk enqueued (queue now contains 5 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'b', '2nd read gives back the 2nd chunk enqueued (queue now contains 4 chunks)');
+    t.equal(enqueue('g'), false, 'After 2 reads, 7th enqueue should return false (queue now contains 5 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'c', '3rd read gives back the 3rd chunk enqueued (queue now contains 4 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'd', '4th read gives back the 4th chunk enqueued (queue now contains 3 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'e', '5th read gives back the 5th chunk enqueued (queue now contains 2 chunks)');
+    return rs.read();
+  })
+  .then(chunk => {
+    t.equal(chunk, 'f', '6th read gives back the 6th chunk enqueued (queue now contains 1 chunk)');
+    t.equal(enqueue('h'), true, 'After 6 reads, 8th enqueue should return true (queue now contains 2 chunks)');
+    t.equal(enqueue('i'), true, 'After 6 reads, 9th enqueue should return true (queue now contains 3 chunks)');
+    t.equal(enqueue('j'), true, 'After 6 reads, 10th enqueue should return true (queue now contains 4 chunks)');
+    t.equal(enqueue('k'), false, 'After 6 reads, 11th enqueue should return false (queue now contains 5 chunks)');
+    t.end();
+  })
+  .catch(e => t.error(e));
 });
 
 test('Can construct a writable stream with a valid CountQueuingStrategy', t => {
diff --git a/reference-implementation/test/exclusive-stream-reader.js b/reference-implementation/test/exclusive-stream-reader.js
deleted file mode 100644
index a596e4495..000000000
--- a/reference-implementation/test/exclusive-stream-reader.js
+++ /dev/null
@@ -1,531 +0,0 @@
-const test = require('tape-catch');
-
-test('Using the reader directly on a mundane stream', t => {
-  t.plan(22);
-
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      enqueue('a');
-      setTimeout(() => enqueue('b'), 30);
-      setTimeout(close, 60);
-    }
-  });
-
-  t.equal(rs.state, 'readable', 'stream starts out readable');
-
-  const reader = rs.getReader();
-
-  t.equal(reader.isActive, true, 'reader isActive is true');
-
-  t.equal(rs.state, 'waiting', 'after getting a reader, the stream state is waiting');
-  t.equal(reader.state, 'readable', 'the reader state is readable');
-
-  t.throws(() => rs.read(), /TypeError/, 'trying to read from the stream directly throws a TypeError');
-  t.equal(reader.read(), 'a', 'trying to read from the reader works and gives back the first enqueued value');
-  t.equal(reader.state, 'waiting', 'the reader state is now waiting since the queue has been drained');
-  rs.cancel().then(
-    () => t.fail('cancel() should not be fulfilled'),
-    e => t.equal(e.constructor, TypeError, 'cancel() should be rejected with a TypeError')
-  );
-
-  reader.ready.then(() => {
-    t.equal(reader.state, 'readable', 'ready for reader is fulfilled when second chunk is enqueued');
-    t.equal(rs.state, 'waiting', 'the stream state is still waiting');
-    t.equal(reader.read(), 'b', 'you can read the second chunk from the reader');
-  });
-
-  reader.closed.then(() => {
-    t.pass('closed for the reader is fulfilled');
-    t.equal(reader.state, 'closed', 'the reader state is closed');
-    t.equal(rs.state, 'closed', 'the stream state is closed');
-    t.equal(reader.isActive, false, 'the reader is no longer active');
-
-    t.doesNotThrow(() => reader.releaseLock(), 'trying to release the lock twice does nothing');
-  });
-
-  rs.ready.then(() => {
-    t.equal(rs.state, 'closed', 'ready for stream is not fulfilled until the stream closes');
-    t.equal(reader.isActive, false, 'the reader is no longer active after the stream has closed');
-  });
-
-  rs.closed.then(() => {
-    t.pass('closed for the stream is fulfilled');
-    t.equal(rs.state, 'closed', 'the stream state is closed');
-    t.equal(reader.state, 'closed', 'the reader state is closed');
-    t.equal(reader.isActive, false, 'the reader is no longer active');
-  });
-});
-
-test('Reading from a reader for an empty stream throws but doesn\'t break anything', t => {
-  let enqueue;
-  const rs = new ReadableStream({
-    start(e) {
-      enqueue = e;
-    }
-  });
-  const reader = rs.getReader();
-
-  t.equal(reader.isActive, true, 'reader is active to start with');
-  t.equal(reader.state, 'waiting', 'reader state is waiting to start with');
-  t.throws(() => reader.read(), /TypeError/, 'calling reader.read() throws a TypeError');
-  t.equal(reader.isActive, true, 'reader is still active');
-  t.equal(reader.state, 'waiting', 'reader state is still waiting');
-
-  enqueue('a');
-
-  reader.ready.then(() => {
-    t.equal(reader.state, 'readable', 'after enqueuing the reader state is readable');
-    t.equal(reader.read(), 'a', 'the enqueued chunk can be read back through the reader');
-    t.end();
-  });
-});
-
-test('A released reader should present like a closed stream', t => {
-  t.plan(7);
-
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-  reader.releaseLock();
-
-  t.equal(reader.isActive, false, 'isActive returns false');
-  t.equal(reader.state, 'closed', 'reader.state returns closed');
-  t.equal(rs.state, 'waiting', 'rs.state returns waiting');
-
-  t.throws(() => reader.read(), /TypeError/, 'trying to read gives a TypeError');
-  reader.cancel().then(
-    v => t.equal(v, undefined, 'reader.cancel() should fulfill with undefined'),
-    e => t.fail('reader.cancel() should not reject')
-  );
-
-  reader.ready.then(() => t.pass('reader.ready should be fulfilled'));
-  reader.closed.then(() => t.pass('reader.closed should be fulfilled'));
-});
-
-test('cancel() on a reader implicitly releases the reader before calling through', t => {
-  t.plan(3);
-
-  const passedReason = new Error('it wasn\'t the right time, sorry');
-  const rs = new ReadableStream({
-    cancel(reason) {
-      t.equal(reader.isActive, false, 'canceling via the reader should release the reader\'s lock');
-      t.equal(reason, passedReason, 'the cancellation reason is passed through to the underlying source');
-    }
-  });
-
-  const reader = rs.getReader();
-  reader.cancel(passedReason).then(
-    () => t.pass('reader.cancel() should fulfill'),
-    e => t.fail('reader.cancel() should not reject')
-  );
-});
-
-test('getReader() on a closed stream should fail', t => {
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      close();
-    }
-  });
-
-  t.equal(rs.state, 'closed', 'the stream should be closed');
-  t.throws(() => rs.getReader(), /TypeError/, 'getReader() threw a TypeError');
-  t.end();
-});
-
-test('getReader() on a cancelled stream should fail (since cancelling closes)', t => {
-  const rs = new ReadableStream();
-  rs.cancel(new Error('fun time is over'));
-
-  t.equal(rs.state, 'closed', 'the stream should be closed');
-  t.throws(() => rs.getReader(), /TypeError/, 'getReader() threw a TypeError');
-  t.end();
-});
-
-test('getReader() on an errored stream should rethrow the error', t => {
-  const theError = new Error('don\'t say i didn\'t warn ya');
-  const rs = new ReadableStream({
-    start(enqueue, close, error) {
-      error(theError);
-    }
-  });
-
-  t.equal(rs.state, 'errored', 'the stream should be errored');
-  t.throws(() => rs.getReader(), /don't say i didn't warn ya/, 'getReader() threw the error');
-  t.end();
-});
-
-test('closed should be fulfilled after stream is closed (both .closed accesses after acquiring)', t => {
-  t.plan(2);
-
-  let doClose;
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      doClose = close;
-    }
-  });
-
-  const reader = rs.getReader();
-  doClose();
-
-  reader.closed.then(() => {
-    t.equal(reader.isActive, false, 'reader is no longer active when reader closed is fulfilled');
-  });
-
-  rs.closed.then(() => {
-    t.equal(reader.isActive, false, 'reader is no longer active when stream closed is fulfilled');
-  });
-});
-
-test('closed should be fulfilled after stream is closed (stream .closed access before acquiring)', t => {
-  t.plan(2);
-
-  let doClose;
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      doClose = close;
-    }
-  });
-
-  rs.closed.then(() => {
-    t.equal(reader.isActive, false, 'reader is no longer active when stream closed is fulfilled');
-  });
-
-  const reader = rs.getReader();
-  doClose();
-
-  reader.closed.then(() => {
-    t.equal(reader.isActive, false, 'reader is no longer active when reader closed is fulfilled');
-  });
-});
-
-test('reader.closed should be fulfilled after reader releases its lock (.closed access before release)', t => {
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-  reader.closed.then(() => t.end());
-  reader.releaseLock();
-});
-
-test('reader.closed should be fulfilled after reader releases its lock (.closed access after release)', t => {
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-  reader.releaseLock();
-  reader.closed.then(() => t.end());
-});
-
-test('closed should be fulfilled after reader releases its lock (multiple stream locks)', t => {
-  t.plan(6);
-
-  let doClose;
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      doClose = close;
-    }
-  });
-
-  const reader1 = rs.getReader();
-
-  rs.closed.then(() => {
-    t.equal(reader1.isActive, false, 'reader1 is no longer active when stream closed is fulfilled');
-    t.equal(reader2.isActive, false, 'reader2 is no longer active when stream closed is fulfilled');
-  });
-
-  reader1.releaseLock();
-
-  const reader2 = rs.getReader();
-  doClose();
-
-  reader1.closed.then(() => {
-    t.equal(reader1.isActive, false, 'reader1 is no longer active when reader1 closed is fulfilled');
-    t.equal(reader2.isActive, false, 'reader2 is no longer active when reader1 closed is fulfilled');
-  });
-
-  reader2.closed.then(() => {
-    t.equal(reader1.isActive, false, 'reader1 is no longer active when reader2 closed is fulfilled');
-    t.equal(reader2.isActive, false, 'reader2 is no longer active when reader2 closed is fulfilled');
-  });
-});
-
-test('ready should fulfill after reader releases its lock and stream is waiting (.ready access before releasing)',
-    t => {
-  t.plan(5);
-
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-
-  t.equal(rs.state, 'waiting', 'the stream\'s state is initially waiting');
-  t.equal(reader.state, 'waiting', 'the reader\'s state is initially waiting');
-  reader.ready.then(() => {
-    t.pass('reader ready should be fulfilled');
-    t.equal(rs.state, 'waiting', 'the stream\'s state is still waiting');
-    t.equal(reader.state, 'closed', 'the reader\'s state is now closed');
-  });
-  reader.releaseLock();
-});
-
-test('ready should fulfill after reader releases its lock and stream is waiting (.ready access after releasing)',
-    t => {
-  t.plan(5);
-
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-
-  t.equal(rs.state, 'waiting', 'the stream\'s state is initially waiting');
-  t.equal(reader.state, 'waiting', 'the reader\'s state is initially waiting');
-  reader.releaseLock();
-  reader.ready.then(() => {
-    t.pass('reader ready should be fulfilled');
-    t.equal(rs.state, 'waiting', 'the stream\'s state is still waiting');
-    t.equal(reader.state, 'closed', 'the reader\'s state is now closed');
-  });
-});
-
-test('stream\'s ready should not fulfill when acquiring, then releasing, a reader', t => {
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-
-  rs.ready.then(() => t.fail('stream ready should not be fulfilled'));
-  reader.releaseLock();
-
-  setTimeout(() => t.end(), 20);
-});
-
-test('stream\'s ready should not fulfill while locked, even if accessed before locking', t => {
-  let doEnqueue;
-  const rs = new ReadableStream({
-    start(enqueue) {
-      doEnqueue = enqueue;
-    }
-  });
-  const ready = rs.ready;
-
-  const reader = rs.getReader();
-
-  ready.then(() => {
-    t.equal(rs.state, 'waiting', 'ready fulfilled but the state was waiting; next assert will fail');
-    t.fail('stream ready should not be fulfilled');
-  });
-
-  doEnqueue();
-  setTimeout(() => t.end(), 20);
-});
-
-test('stream\'s ready accessed before locking should not fulfill if stream becomes readable while locked, becomes ' +
-    'waiting again and then is released', t => {
-  let doEnqueue;
-  const rs = new ReadableStream({
-    start(enqueue) {
-      doEnqueue = enqueue;
-    }
-  });
-  const ready = rs.ready;
-
-  const reader = rs.getReader();
-
-  ready.then(() => {
-    t.fail('stream ready should not be fulfilled');
-  });
-
-  doEnqueue();
-  t.equal(reader.state, 'readable', 'reader should be readable after enqueue');
-  reader.read();
-  t.equal(reader.state, 'waiting', 'reader should be waiting again after read');
-  reader.releaseLock();
-  t.equal(rs.state, 'waiting', 'stream should be waiting again after read');
-  setTimeout(() => t.end(), 20);
-});
-
-test('stream\'s ready accessed before locking should not fulfill if stream becomes readable while locked, becomes ' +
-    'waiting again and then is released in another microtask', t => {
-  let doEnqueue;
-  const rs = new ReadableStream({
-    start(enqueue) {
-      doEnqueue = enqueue;
-    }
-  });
-  const ready = rs.ready;
-
-  const reader = rs.getReader();
-
-  ready.then(() => {
-    t.fail('stream ready should not be fulfilled');
-  });
-
-  doEnqueue();
-  t.equal(reader.state, 'readable', 'reader should be readable after enqueue');
-  reader.read();
-  t.equal(reader.state, 'waiting', 'reader should be waiting again after read');
-
-  // Let the fulfillment callback used in the algorithm of rs.ready run. This
-  // covers the code path in rs.ready which is run when
-  // this._readableStreamReader is not undefined.
-  Promise.resolve().then(() => {
-    reader.releaseLock();
-    t.equal(rs.state, 'waiting', 'stream should be waiting again after read');
-    setTimeout(() => t.end(), 20);
-  });
-});
-
-test('stream\'s ready should not fulfill when acquiring a reader, accessing ready, releasing the reader, acquiring ' +
-    'another reader, then enqueuing a chunk', t => {
-  // https://github.com/whatwg/streams/pull/262#discussion_r22990833
-
-  let doEnqueue;
-  const rs = new ReadableStream({
-    start(enqueue) {
-      doEnqueue = enqueue;
-    }
-  });
-
-  const reader = rs.getReader();
-  rs.ready.then(() => {
-    t.equal(rs.state, 'waiting', 'ready fulfilled but the state was waiting; next assert will fail');
-    t.fail('stream ready should not be fulfilled')
-  });
-
-  reader.releaseLock();
-  rs.getReader();
-  doEnqueue('a');
-
-  setTimeout(() => t.end(), 20);
-});
-
-test('Multiple readers can access the stream in sequence', t => {
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      enqueue('a');
-      enqueue('b');
-      enqueue('c');
-      enqueue('d');
-      enqueue('e');
-      close();
-    }
-  });
-
-  t.equal(rs.read(), 'a', 'reading the first chunk directly from the stream works');
-
-  const reader1 = rs.getReader();
-  t.equal(reader1.read(), 'b', 'reading the second chunk from reader1 works');
-  reader1.releaseLock();
-  t.equal(reader1.state, 'closed', 'reader1 is closed after being released');
-
-  t.equal(rs.read(), 'c', 'reading the third chunk from the stream after releasing reader1 works');
-
-  const reader2 = rs.getReader();
-  t.equal(reader2.read(), 'd', 'reading the fourth chunk from reader2 works');
-  reader2.releaseLock();
-  t.equal(reader2.state, 'closed', 'reader2 is closed after being released');
-
-  t.equal(rs.read(), 'e', 'reading the fifth chunk from the stream after releasing reader2 works');
-
-  t.end();
-});
-
-test('A stream that errors has that reflected in the reader and the stream', t => {
-  t.plan(9);
-
-  let error;
-  const rs = new ReadableStream({
-    start(enqueue, close, error_) {
-      error = error_;
-    }
-  });
-
-  const reader = rs.getReader();
-
-  const passedError = new Error('too exclusive');
-  error(passedError);
-
-  t.equal(reader.isActive, false, 'the reader should have lost its lock');
-  t.throws(() => reader.read(), /TypeError/,
-    'reader.read() should throw a TypeError since the reader no longer has a lock');
-  t.equal(reader.state, 'errored', 'the reader\'s state should be errored');
-  reader.ready.then(() => t.pass('reader.ready should fulfill'));
-  reader.closed.then(
-    () => t.fail('reader.closed should not be fulfilled'),
-    e => t.equal(e, passedError, 'reader.closed should be rejected with the stream error')
-  );
-
-  t.throws(() => rs.read(), /too exclusive/, 'rs.read() should throw the stream error');
-  t.equal(rs.state, 'errored', 'the stream\'s state should be errored');
-  rs.ready.then(() => t.pass('rs.ready should fulfill'));
-  rs.closed.then(
-    () => t.fail('rs.closed should not be fulfilled'),
-    e => t.equal(e, passedError, 'rs.closed should be rejected with the stream error')
-  );
-});
-
-test('Cannot use an already-released reader to unlock a stream again', t => {
-  t.plan(2);
-
-  const rs = new ReadableStream();
-
-  const reader1 = rs.getReader();
-  reader1.releaseLock();
-
-  const reader2 = rs.getReader();
-  t.equal(reader2.isActive, true, 'reader2 state is active before releasing reader1');
-
-  reader1.releaseLock();
-  t.equal(reader2.isActive, true, 'reader2 state is still active after releasing reader1 again');
-});
-
-test('stream\'s ready returns the same instance as long as there\'s no state transition visible on stream even ' +
-    'if the reader became readable while the stream was locked', t => {
-  let enqueue;
-  const rs = new ReadableStream({
-    start(enqueue_) {
-      enqueue = enqueue_
-    }
-  });
-
-  const ready = rs.ready;
-
-  const reader = rs.getReader();
-
-  enqueue('a');
-  t.equal(reader.state, 'readable', 'reader should be readable after enqueuing');
-  t.equal(reader.read(), 'a', 'the enqueued data should be read');
-
-  reader.releaseLock();
-
-  t.equal(ready, rs.ready, 'rs.ready should return the same instance as before locking');
-  t.end();
-});
-
-test('reader\'s ready and close returns the same instance as long as there\'s no state transition',
-    t => {
-  const rs = new ReadableStream();
-  const reader = rs.getReader();
-
-  const ready = reader.ready;
-  const closed = reader.closed;
-
-  reader.releaseLock();
-
-  t.equal(ready, reader.ready, 'reader.ready should return the same instance as before releasing');
-  t.equal(closed, reader.closed, 'reader.ready should return the same instance as before releasing');
-  t.end();
-});
-
-test('reader\'s ready and close returns the same instance as long as there\'s no state transition to waiting',
-    t => {
-  let enqueue;
-  const rs = new ReadableStream({
-    start(enqueue_) {
-      enqueue = enqueue_
-    }
-  });
-
-  const reader = rs.getReader();
-
-  const ready = reader.ready;
-  const closed = reader.closed;
-
-  enqueue('a');
-  t.equal(reader.state, 'readable', 'reader should be readable after enqueuing');
-
-  reader.releaseLock();
-
-  t.equal(ready, reader.ready, 'reader.ready should return the same instance as before releasing');
-  t.equal(closed, reader.closed, 'reader.ready should return the same instance as before releasing');
-  t.end();
-});
diff --git a/reference-implementation/test/pipe-through.js b/reference-implementation/test/pipe-through.js
index 84ec86433..feb833b97 100644
--- a/reference-implementation/test/pipe-through.js
+++ b/reference-implementation/test/pipe-through.js
@@ -36,7 +36,8 @@ test('Piping through an identity transform stream will close the destination whe
   rs.pipeThrough(ts).pipeTo(ws).then(() => {
     t.equal(rs.state, 'closed', 'the readable stream was closed');
     t.equal(ws.state, 'closed', 'the writable stream was closed');
-  });
+  })
+  .catch(e => t.error(e));
 });
 
 // FIXME: expected results here will probably change as we fix https://github.com/whatwg/streams/issues/190
diff --git a/reference-implementation/test/pipe-to.js b/reference-implementation/test/pipe-to.js
index 0732543ae..7f04b1a30 100644
--- a/reference-implementation/test/pipe-to.js
+++ b/reference-implementation/test/pipe-to.js
@@ -2,7 +2,11 @@ const test = require('tape-catch');
 
 import sequentialReadableStream from './utils/sequential-rs';
 
+// TODO: many asserts in this file are unlabeled; we should label them.
+
 test('Piping from a ReadableStream from which lots of data are readable synchronously', t => {
+  t.plan(5);
+
   const rs = new ReadableStream({
     start(enqueue, close) {
       for (let i = 0; i < 1000; ++i) {
@@ -11,57 +15,67 @@ test('Piping from a ReadableStream from which lots of data are readable synchron
       close();
     }
   });
-  t.equal(rs.state, 'readable');
+
+  t.equal(rs.state, 'readable', 'readable stream state should start out readable');
 
   const ws = new WritableStream({
     strategy: new CountQueuingStrategy({
       highWaterMark: 1000
     })
   });
-  t.equal(ws.state, 'writable');
 
-  rs.pipeTo(ws);
-  t.equal(rs.state, 'closed', 'all data must be read out from rs');
-  t.equal(ws.state, 'closing', 'close must have been called after accepting all data from rs');
+  t.equal(ws.state, 'writable', 'writable stream state should start out writable');
+
+  let pipeFinished = false;
+  rs.pipeTo(ws).then(
+    () => {
+      pipeFinished = true;
+      t.equal(rs.state, 'closed', 'readable stream state should be closed after pipe finishes');
+      t.equal(ws.state, 'closed', 'writable stream state should be closed after pipe finishes');
+    },
+    e => t.error(e)
+  );
 
-  t.end();
+  setTimeout(() => {
+    t.equal(pipeFinished, true, 'pipe should have finished before a setTimeout(,0) since it should only be microtasks');
+  }, 0);
 });
 
 test('Piping from a ReadableStream in readable state to a WritableStream in closing state', t => {
-  let pullCount = 0;
-  let cancelCalled = false;
+  t.plan(5);
+
+  let cancelReason;
   const rs = new ReadableStream({
     start(enqueue, close) {
-      enqueue("Hello");
-    },
-    pull() {
-      ++pullCount;
+      enqueue('Hello');
     },
-    cancel() {
-      t.assert(!cancelCalled);
-      cancelCalled = true;
+    cancel(reason) {
+      t.equal(reason.constructor, TypeError, 'underlying source cancel should have been called with a TypeError');
+      cancelReason = reason;
     }
   });
-  t.equal(rs.state, 'readable');
+  t.equal(rs.state, 'readable', 'readable stream should start in the readable state');
 
   const ws = new WritableStream({
     write() {
       t.fail('Unexpected write call');
-      t.end();
     },
     abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
 
   ws.close();
-  t.equal(ws.state, 'closing');
-
-  rs.pipeTo(ws);
-  t.assert(cancelCalled);
-  t.equal(rs.state, 'closed');
-  t.end();
+  t.equal(ws.state, 'closing', 'writable stream should be closing immediately after closing it');
+
+  rs.pipeTo(ws).then(
+    () => t.fail('promise returned by pipeTo should not fulfill'),
+    r => {
+      t.equal(r, cancelReason,
+        'the pipeTo promise should reject with the same error as the underlying source cancel was called with');
+      t.equal(rs.state, 'closed', 'the readable stream should be closed when the pipe finishes');
+    }
+  );
 });
 
 test('Piping from a ReadableStream in readable state to a WritableStream in errored state', t => {
@@ -70,7 +84,7 @@ test('Piping from a ReadableStream in readable state to a WritableStream in erro
   const passedError = new Error('horrible things');
   const rs = new ReadableStream({
     start(enqueue, close) {
-      enqueue("Hello");
+      enqueue('Hello');
     },
     pull() {
       ++pullCount;
@@ -124,8 +138,8 @@ test('Piping from a ReadableStream in readable state to a WritableStream in erro
   }, 0);
 });
 
-test('Piping from a ReadableStream in closed state to a WritableStream in writable state', t => {
-  t.plan(3);
+test('Piping from a ReadableStream in the closed state to a WritableStream in the writable state', t => {
+  t.plan(4);
 
   const rs = new ReadableStream({
     start(enqueue, close) {
@@ -140,31 +154,31 @@ test('Piping from a ReadableStream in closed state to a WritableStream in writab
   });
   t.equal(rs.state, 'closed');
 
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write() {
       t.fail('Unexpected write call');
     },
     close() {
-      t.fail('Unexpected close call');
+      t.pass('underlying sink close should be called');
     },
     abort() {
       t.fail('Unexpected abort call');
     }
   });
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'writable');
 
-    rs.pipeTo(ws).then(
-      () => t.fail('pipeTo promise should not be fulfilled'),
-      e => t.equal(e.constructor, TypeError, 'pipeTo promise should be rejected with a TypeError')
-    );
-  }, 0);
+    rs.pipeTo(ws).then(v => t.equal(v, undefined, 'pipeTo promise should be fulfilled with undefined'));
+  });
 });
 
-test('Piping from a ReadableStream in errored state to a WritableStream in writable state', t => {
-  t.plan(3);
+test('Piping from a ReadableStream in the errored state to a WritableStream in the writable state', t => {
+  t.plan(4);
 
   const theError = new Error('piping is too hard today');
   const rs = new ReadableStream({
@@ -180,7 +194,11 @@ test('Piping from a ReadableStream in errored state to a WritableStream in writa
   });
   t.equal(rs.state, 'errored');
 
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write() {
       t.fail('Unexpected write call');
     },
@@ -188,23 +206,24 @@ test('Piping from a ReadableStream in errored state to a WritableStream in writa
       t.fail('Unexpected close call');
     },
     abort() {
-      t.fail('Unexpected abort call');
+      t.pass('underlying sink abort should be called');
     }
   });
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'writable');
 
     rs.pipeTo(ws).then(
       () => t.fail('pipeTo promise should not be fulfilled'),
       e => t.equal(e, theError, 'pipeTo promise should be rejected with the passed error')
     );
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in readable state which becomes closed after pipeTo call to a WritableStream in ' +
-    'writable state', t => {
+test('Piping from a ReadableStream in the readable state which becomes closed after pipeTo call to a WritableStream ' +
+     'in the writable state', t => {
+  t.plan(5);
+
   let closeReadableStream;
   let pullCount = 0;
   const rs = new ReadableStream({
@@ -217,51 +236,50 @@ test('Piping from a ReadableStream in readable state which becomes closed after
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
-  t.equal(rs.state, 'readable');
+  t.equal(rs.state, 'readable', 'readable stream should start in the readable state');
 
   let writeCalled = false;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       if (!writeCalled) {
-        t.equal(chunk, 'Hello');
+        t.equal(chunk, 'Hello', 'chunk written to writable stream should be the one enqueued into the readable stream');
         writeCalled = true;
       } else {
         t.fail('Unexpected extra write call');
-        t.end();
       }
     },
     close() {
-      t.assert(writeCalled);
-      t.equal(pullCount, 2);
-
-      t.end();
+      t.pass('underlying sink close should be called');
+      t.equal(pullCount, 1, 'underlying source pull should have been called once');
     },
     abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'value must leave readable state synchronously');
-    t.equal(ws.state, 'waiting', 'writable stream must be written to, entering a waiting state');
+    t.equal(ws.state, 'writable', 'writable stream should still be writable immediately after pipeTo');
 
     closeReadableStream();
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in readable state which becomes errored after pipeTo call to a WritableStream in ' +
-    'writable state', t => {
+test('Piping from a ReadableStream in the readable state which becomes errored after pipeTo call to a WritableStream ' +
+     'in the writable state', t => {
+  t.plan(4);
+
   let errorReadableStream;
   let pullCount = 0;
   const rs = new ReadableStream({
     start(enqueue, close, error) {
-      enqueue("Hello");
+      enqueue('Hello');
       errorReadableStream = error;
     },
     pull() {
@@ -269,48 +287,38 @@ test('Piping from a ReadableStream in readable state which becomes errored after
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
-  t.equal(rs.state, 'readable');
+  t.equal(rs.state, 'readable', 'readable stream should start in the readable state');
 
-  let writeCalled = false;
   let passedError = new Error('horrible things');
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
-      if (!writeCalled) {
-        t.equal(chunk, 'Hello');
-        writeCalled = true;
-      } else {
-        t.fail('Unexpected extra write call');
-        t.end();
-      }
+      t.fail('Unexpected extra write call');
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
     abort(reason) {
-      t.equal(reason, passedError);
-      t.assert(writeCalled);
-      t.equal(pullCount, 2);
-
-      t.end();
+      t.equal(reason, passedError, 'underlying sink abort should receive the error from the readable stream');
+      t.equal(pullCount, 1, 'underlying source pull should have been called once');
     }
   });
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'value must leave readable state synchronously');
-    t.equal(ws.state, 'waiting', 'writable stream must be written to, entering a waiting state');
+    t.equal(ws.state, 'writable', 'writable stream should still be writable immediately after pipeTo');
 
     errorReadableStream(passedError);
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in waiting state which becomes readable after pipeTo call to a WritableStream in ' +
-    'writable state', t => {
+test('Piping from an empty ReadableStream which becomes non-empty after pipeTo call to a WritableStream in the ' +
+     'writable state', t => {
   let enqueue;
   let pullCount = 0;
   const rs = new ReadableStream({
@@ -343,13 +351,13 @@ test('Piping from a ReadableStream in waiting state which becomes readable after
   });
 
   rs.pipeTo(ws);
-  t.equal(rs.state, 'waiting');
+  t.equal(rs.state, 'readable');
   t.equal(ws.state, 'writable');
 
   enqueue('Hello');
 });
 
-test('Piping from a ReadableStream in waiting state which becomes errored after pipeTo call to a WritableStream in ' +
+test('Piping from an empty ReadableStream which becomes errored after pipeTo call to a WritableStream in the ' +
     'writable state', t => {
   t.plan(4);
 
@@ -379,72 +387,67 @@ test('Piping from a ReadableStream in waiting state which becomes errored after
       t.end();
     },
     abort(reason) {
-      t.equal(reason, passedError);
+      t.equal(reason, passedError, 'underlying sink abort should receive the error from the readable stream');
     }
   });
 
   rs.pipeTo(ws);
-  t.equal(rs.state, 'waiting');
-  t.equal(ws.state, 'writable');
+  t.equal(rs.state, 'readable', 'readable stream should start out readable');
+  t.equal(ws.state, 'writable', 'writable stream should start out writable');
 
   errorReadableStream(passedError);
-  t.equal(rs.state, 'errored');
+  t.equal(rs.state, 'errored', 'readable stream should become errored');
 });
 
-test('Piping from a ReadableStream in waiting state to a WritableStream in writable state which becomes errored ' +
-    'after pipeTo call', t => {
-  let writeCalled = false;
+test('Piping from an empty ReadableStream to a WritableStream in the writable state which becomes errored after a ' +
+     'pipeTo call', t => {
+  t.plan(6);
+
+  const theError = new Error('cancel with me!');
 
   let pullCount = 0;
   const rs = new ReadableStream({
     pull() {
       ++pullCount;
     },
-    cancel() {
+    cancel(reason) {
+      t.equal(reason, theError, 'underlying source cancellation reason should be the writable stream error');
       t.equal(pullCount, 1, 'pull should have been called once by cancel-time');
-      t.assert(writeCalled, 'write should have been called by cancel-time');
-      t.end();
     }
   });
 
   let errorWritableStream;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
     start(error) {
       errorWritableStream = error;
+      return startPromise;
     },
     write(chunk) {
-      t.assert(!writeCalled, 'write should not have been called more than once');
-      writeCalled = true;
-
-      t.equal(chunk, 'Hello', 'the chunk passed to write should be the one written');
+      t.fail('Unexpected write call');
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
     abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
-  // Needed to prepare errorWritableStream
-  ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'writable', 'ws should start writable');
 
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'rs should be waiting after pipe');
+    t.equal(rs.state, 'readable', 'rs should be readable after pipe');
     t.equal(ws.state, 'writable', 'ws should be writable after pipe');
 
-    errorWritableStream();
+    errorWritableStream(theError);
     t.equal(ws.state, 'errored', 'ws should be errored after erroring it');
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in readable state to a WritableStream in waiting state which becomes writable ' +
-    'after pipeTo call', t => {
+test('Piping from a non-empty ReadableStream to a WritableStream in the waiting state which becomes writable after a ' +
+     'pipeTo call', t => {
   let enqueue;
   let pullCount = 0;
   const rs = new ReadableStream({
@@ -456,54 +459,52 @@ test('Piping from a ReadableStream in readable state to a WritableStream in wait
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
   t.equal(rs.state, 'readable');
 
   let resolveWritePromise;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       if (!resolveWritePromise) {
         t.equal(chunk, 'Hello');
         return new Promise(resolve => resolveWritePromise = resolve);
       } else {
         t.equal(chunk, 'World');
-
         t.equal(pullCount, 2);
-
         t.end();
       }
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
     abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'waiting');
 
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'readable stream must say it is waitable while piping (even with a nonempty queue)');
+    t.equal(rs.state, 'readable', 'readable stream must say it is readable while piping');
     t.equal(ws.state, 'waiting');
 
     resolveWritePromise();
     ws.ready.then(() => {
       t.equal(ws.state, 'writable');
     })
-    .catch(t.error);
-  }, 0);
+    .catch(e => t.error(e));
+  });
 });
 
-test('Piping from a ReadableStream in readable state to a WritableStream in waiting state which becomes errored ' +
-    'after pipeTo call', t => {
+test('Piping from a non-empty ReadableStream to a WritableStream in waiting state which becomes errored after a ' +
+     'pipeTo call', t => {
   let writeCalled = false;
 
   let enqueue;
@@ -517,16 +518,18 @@ test('Piping from a ReadableStream in readable state to a WritableStream in wait
     },
     cancel() {
       t.assert(writeCalled);
-      t.equal(pullCount, 1);
+      t.equal(pullCount, 2);
       t.end();
     }
   });
   t.equal(rs.state, 'readable');
 
   let errorWritableStream;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
     start(error) {
       errorWritableStream = error;
+      return startPromise;
     },
     write(chunk) {
       t.assert(!writeCalled);
@@ -545,22 +548,21 @@ test('Piping from a ReadableStream in readable state to a WritableStream in wait
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'waiting');
 
     t.equal(rs.state, 'readable', 'readable stream should be readable before piping starts');
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'readable stream must say it is waitable while piping (even with a nonempty queue)');
+    t.equal(rs.state, 'readable', 'readable stream must say it is readable while piping');
     t.equal(ws.state, 'waiting');
 
     errorWritableStream();
     t.equal(ws.state, 'errored');
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in readable state which becomes errored after pipeTo call to a WritableStream in ' +
-    'waiting state', t => {
+test('Piping from a non-empty ReadableStream which becomes errored after pipeTo call to a WritableStream in the ' +
+     'waiting state', t => {
   t.plan(10);
 
   let errorReadableStream;
@@ -581,7 +583,11 @@ test('Piping from a ReadableStream in readable state which becomes errored after
   t.equal(rs.state, 'readable');
 
   let writeCalled = false;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       t.assert(!writeCalled);
       writeCalled = true;
@@ -599,23 +605,22 @@ test('Piping from a ReadableStream in readable state which becomes errored after
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'waiting');
     t.equal(pullCount, 1);
 
     t.equal(rs.state, 'readable', 'readable stream should be readable before piping starts');
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting', 'readable stream must say it is waitable while piping (even with a nonempty queue)');
+    t.equal(rs.state, 'readable', 'readable stream must say it is readable while piping');
     t.equal(ws.state, 'waiting');
 
     errorReadableStream();
     t.equal(rs.state, 'errored');
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in waiting state to a WritableStream in waiting state where both become ready ' +
-    'after pipeTo', t => {
+test('Piping from a non-empty ReadableStream to a WritableStream in the waiting state where both become ready ' +
+     'after a pipeTo', t => {
   let enqueue;
   let pullCount = 0;
   const rs = new ReadableStream({
@@ -627,14 +632,17 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
 
   let checkSecondWrite = false;
 
   let resolveWritePromise;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       if (checkSecondWrite) {
         t.equal(chunk, 'Goodbye');
@@ -647,17 +655,14 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
     abort(reason) {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.assert(resolveWritePromise);
     t.equal(ws.state, 'waiting');
 
@@ -668,17 +673,17 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
     // Check that nothing happens before calling done(), and then call done()
     // to check that pipeTo is woken up.
     setTimeout(() => {
-      t.equal(pullCount, 1);
+      t.equal(pullCount, 2);
 
       checkSecondWrite = true;
 
       resolveWritePromise();
     }, 100);
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in waiting state to a WritableStream in waiting state which becomes writable ' +
-    'after pipeTo call', t => {
+test('Piping from an empty ReadableStream to a WritableStream in the waiting state which becomes writable after a ' +
+     'pipeTo call', t => {
   let pullCount = 0;
   const rs = new ReadableStream({
     pull() {
@@ -691,7 +696,11 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
   });
 
   let resolveWritePromise;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       t.assert(!resolveWritePromise);
       t.equal(chunk, 'Hello');
@@ -699,21 +708,18 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
-    abort(reason) {
+    abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
+  startPromise.then(() => {
     t.equal(ws.state, 'waiting');
 
     rs.pipeTo(ws);
-    t.equal(rs.state, 'waiting');
+    t.equal(rs.state, 'readable');
     t.equal(ws.state, 'waiting');
 
     resolveWritePromise();
@@ -723,11 +729,11 @@ test('Piping from a ReadableStream in waiting state to a WritableStream in waiti
 
       t.end();
     }, 100);
-  }, 0);
+  });
 });
 
-test('Piping from a ReadableStream in waiting state which becomes closed after pipeTo call to a WritableStream in ' +
-    'waiting state', t => {
+test('Piping from an empty ReadableStream which becomes closed after a pipeTo call to a WritableStream in the ' +
+     'waiting state whose writes never complete', t => {
   t.plan(5);
 
   let closeReadableStream;
@@ -741,54 +747,50 @@ test('Piping from a ReadableStream in waiting state which becomes closed after p
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
 
   let writeCalled = false;
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
       if (!writeCalled) {
-        t.equal(chunk, 'Hello');
+        t.equal(chunk, 'Hello', 'the chunk should be written to the writable stream');
         writeCalled = true;
+        closeReadableStream();
       } else {
         t.fail('Unexpected extra write call');
-        t.end();
       }
       return new Promise(() => {});
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
-    abort(reason) {
+    abort() {
       t.fail('Unexpected abort call');
-      t.end();
     }
   });
   ws.write('Hello');
 
-  // Wait for ws to start.
-  setTimeout(() => {
-    t.equal(ws.state, 'waiting');
+  startPromise.then(() => {
+    t.equal(ws.state, 'waiting', 'the writable stream should be in the waiting state after starting');
 
     rs.pipeTo(ws);
 
-    closeReadableStream();
-
-    t.equal(rs.state, 'closed');
+    t.equal(rs.state, 'closed', 'the readable stream should be closed after closing it');
 
-    // Check that nothing happens.
     setTimeout(() => {
-      t.equal(ws.state, 'closing');
-
-      t.equal(pullCount, 1);
-    }, 100);
+      t.equal(ws.state, 'waiting', 'the writable stream should still be waiting since the write never completed');
+      t.equal(pullCount, 1, 'pull should have been called only once');
+    }, 50);
   });
 });
 
-test('Piping from a ReadableStream in waiting state which becomes errored after pipeTo call to a WritableStream in ' +
-    'waiting state', t => {
+test('Piping from an empty ReadableStream which becomes errored after a pipeTo call to a WritableStream in the ' +
+     'waiting state', t => {
   t.plan(6);
 
   let errorReadableStream;
@@ -802,7 +804,6 @@ test('Piping from a ReadableStream in waiting state which becomes errored after
     },
     cancel() {
       t.fail('Unexpected cancel call');
-      t.end();
     }
   });
 
@@ -815,13 +816,11 @@ test('Piping from a ReadableStream in waiting state which becomes errored after
         writeCalled = true;
       } else {
         t.fail('Unexpected extra write call');
-        t.end();
       }
       return new Promise(() => {});
     },
     close() {
       t.fail('Unexpected close call');
-      t.end();
     },
     abort(reason) {
       t.equal(reason, passedError);
@@ -951,17 +950,17 @@ test('Piping to a stream and then closing it propagates a TypeError cancellation
   }, 10);
 });
 
-test('Piping to a stream that synchronously errors passes through the error as the cancellation reason', t => {
+test('Piping to a stream that errors on write should pass through the error as the cancellation reason', t => {
   let recordedReason;
   const rs = new ReadableStream({
     start(enqueue, close) {
       enqueue('a');
       enqueue('b');
       enqueue('c');
-      close();
     },
     cancel(reason) {
-      recordedReason = reason;
+      t.equal(reason, passedError, 'the recorded cancellation reason must be the passed error');
+      t.end();
     }
   });
 
@@ -980,15 +979,10 @@ test('Piping to a stream that synchronously errors passes through the error as t
   });
 
   rs.pipeTo(ws);
-
-  setTimeout(() => {
-    t.equal(recordedReason, passedError, 'the recorded cancellation reason must be the passed error');
-    t.end();
-  }, 10);
 });
 
-test('Piping to a stream that asynchronously errors passes through the error as the cancellation reason', t => {
-  let recordedReason;
+test('Piping to a stream that errors on write should not pass through the error if the stream is already closed', t => {
+  let cancelCalled = false;
   const rs = new ReadableStream({
     start(enqueue, close) {
       enqueue('a');
@@ -996,8 +990,8 @@ test('Piping to a stream that asynchronously errors passes through the error as
       enqueue('c');
       close();
     },
-    cancel(reason) {
-      recordedReason = reason;
+    cancel() {
+      cancelCalled = true;
     }
   });
 
@@ -1007,7 +1001,7 @@ test('Piping to a stream that asynchronously errors passes through the error as
     write(chunk) {
       return new Promise((resolve, reject) => {
         if (++written > 1) {
-          setTimeout(() => reject(passedError), 10);
+          reject(passedError);
         } else {
           resolve();
         }
@@ -1015,24 +1009,27 @@ test('Piping to a stream that asynchronously errors passes through the error as
     }
   });
 
-  rs.pipeTo(ws);
-
-  setTimeout(() => {
-    t.equal(recordedReason, passedError, 'the recorded cancellation reason must be the passed error');
-    t.end();
-  }, 20);
+  rs.pipeTo(ws).then(
+    () => t.fail('pipeTo should not fulfill'),
+    r => {
+      t.equal(r, passedError, 'pipeTo should reject with the same error as the write');
+      t.equal(cancelCalled, false, 'cancel should not have been called');
+      t.end();
+    }
+  );
 });
 
-test('Piping to a stream that errors on the last chunk passes through the error to a non-closed producer', t => {
+test('Piping to a stream that errors soon after writing should pass through the error as the cancellation reason', t => {
   let recordedReason;
   const rs = new ReadableStream({
     start(enqueue, close) {
       enqueue('a');
       enqueue('b');
-      setTimeout(close, 10);
+      enqueue('c');
     },
     cancel(reason) {
-      recordedReason = reason;
+      t.equal(reason, passedError, 'the recorded cancellation reason must be the passed error');
+      t.end();
     }
   });
 
@@ -1042,41 +1039,7 @@ test('Piping to a stream that errors on the last chunk passes through the error
     write(chunk) {
       return new Promise((resolve, reject) => {
         if (++written > 1) {
-          reject(passedError);
-        } else {
-          resolve();
-        }
-      });
-    }
-  });
-
-  rs.pipeTo(ws);
-
-  setTimeout(() => {
-    t.equal(recordedReason, passedError, 'the recorded cancellation reason must be the passed error');
-    t.end();
-  }, 20);
-});
-
-test('Piping to a stream that errors on the last chunk does not pass through the error to a closed producer', t => {
-  let cancelCalled = false;
-  const rs = new ReadableStream({
-    start(enqueue, close) {
-      enqueue('a');
-      enqueue('b');
-      close();
-    },
-    cancel() {
-      cancelCalled = true;
-    }
-  });
-
-  let written = 0;
-  const ws = new WritableStream({
-    write(chunk) {
-      return new Promise((resolve, reject) => {
-        if (++written > 1) {
-          reject(new Error('producer will not see this'));
+          setTimeout(() => reject(passedError), 10);
         } else {
           resolve();
         }
@@ -1085,44 +1048,95 @@ test('Piping to a stream that errors on the last chunk does not pass through the
   });
 
   rs.pipeTo(ws);
-
-  setTimeout(() => {
-    t.equal(cancelCalled, false, 'cancel must not be called');
-    t.equal(ws.state, 'errored');
-    t.end();
-  }, 20);
 });
 
-test('Piping to a writable stream that does not consume the writes fast enough exerts backpressure on the source', t => {
-  t.plan(2);
-
+test('Piping to a writable stream that does not consume the writes fast enough exerts backpressure on the source',
+     t => {
   const enqueueReturnValues = [];
   const rs = new ReadableStream({
     start(enqueue, close) {
-      setTimeout(() => enqueueReturnValues.push(enqueue('a')), 10);
-      setTimeout(() => enqueueReturnValues.push(enqueue('b')), 20);
-      setTimeout(() => enqueueReturnValues.push(enqueue('c')), 30);
-      setTimeout(() => enqueueReturnValues.push(enqueue('d')), 40);
-      setTimeout(() => close(), 50);
+      setTimeout(() => enqueueReturnValues.push(enqueue('a')), 100);
+      setTimeout(() => enqueueReturnValues.push(enqueue('b')), 200);
+      setTimeout(() => enqueueReturnValues.push(enqueue('c')), 300);
+      setTimeout(() => enqueueReturnValues.push(enqueue('d')), 400);
+      setTimeout(() => close(), 500);
     }
   });
 
-  let writtenValues = [];
+  const chunksGivenToWrite = [];
+  const chunksFinishedWriting = [];
+  const startPromise = Promise.resolve();
   const ws = new WritableStream({
+    start() {
+      return startPromise;
+    },
     write(chunk) {
+      chunksGivenToWrite.push(chunk);
       return new Promise(resolve => {
         setTimeout(() => {
-          writtenValues.push(chunk);
+          chunksFinishedWriting.push(chunk);
           resolve();
-        }, 25);
+        }, 350);
       });
     }
   });
 
-  setTimeout(() => {
+  startPromise.then(() => {
     rs.pipeTo(ws).then(() => {
-      t.deepEqual(enqueueReturnValues, [true, true, false, false], 'backpressure was correctly exerted at the source');
-      t.deepEqual(writtenValues, ['a', 'b', 'c', 'd'], 'all chunks were written');
+      t.deepEqual(enqueueReturnValues, [true, true, true, false], 'backpressure was correctly exerted at the source');
+      t.deepEqual(chunksFinishedWriting, ['a', 'b', 'c', 'd'], 'all chunks were written');
+      t.end();
     });
-  }, 0);
+
+    t.equal(ws.state, 'writable', 'at t = 0 ms, ws should be writable');
+
+    setTimeout(() => {
+      t.equal(ws.state, 'waiting', 'at t = 125 ms, ws should be waiting');
+      t.deepEqual(chunksGivenToWrite, ['a'], 'at t = 125 ms, ws.write should have been called with one chunk');
+      t.deepEqual(chunksFinishedWriting, [], 'at t = 125 ms, no chunks should have finished writing');
+
+      // The queue was empty when 'a' (the very first chunk) was enqueued
+      t.deepEqual(enqueueReturnValues, [true],
+        'at t = 125 ms, the one enqueued chunk in rs did not cause backpressure');
+    }, 125);
+
+    setTimeout(() => {
+      t.equal(ws.state, 'waiting', 'at t = 225 ms, ws should be waiting');
+      t.deepEqual(chunksGivenToWrite, ['a'], 'at t = 225 ms, ws.write should have been called with one chunk');
+      t.deepEqual(chunksFinishedWriting, [], 'at t = 225 ms, no chunks should have finished writing');
+
+      // When 'b' was enqueued at 200 ms, the queue was also empty, since immediately after enqueuing 'a' at
+      // t = 100 ms, it was dequeued in order to fulfill the read() call that was made at time t = 0.
+      t.deepEqual(enqueueReturnValues, [true, true],
+        'at t = 225 ms, the two enqueued chunks in rs did not cause backpressure');
+    }, 225);
+
+    setTimeout(() => {
+      t.equal(ws.state, 'waiting', 'at t = 325 ms, ws should be waiting');
+      t.deepEqual(chunksGivenToWrite, ['a'], 'at t = 325 ms, ws.write should have been called with one chunk');
+      t.deepEqual(chunksFinishedWriting, [], 'at t = 325 ms, no chunks should have finished writing');
+
+      // When 'c' was enqueued at 300 ms, the queue was again empty, since at time t = 200 ms when 'b' was enqueued,
+      // it was immediately dequeued in order to fulfill the second read() call that was made at time t = 0.
+      t.deepEqual(enqueueReturnValues, [true, true, true],
+        'at t = 325 ms, the three enqueued chunks in rs did not cause backpressure');
+    }, 325);
+
+    setTimeout(() => {
+      t.equal(ws.state, 'waiting', 'at t = 425 ms, ws should be waiting');
+      t.deepEqual(chunksGivenToWrite, ['a'], 'at t = 425 ms, ws.write should have been called with one chunk');
+      t.deepEqual(chunksFinishedWriting, [], 'at t = 425 ms, no chunks should have finished writing');
+
+      // When 'd' was enqueued at 400 ms, the queue was *not* empty. 'c' was still in it, since the write() of 'b' will
+      // not finish until t = 100 ms + 350 ms = 450 ms. Thus backpressure should have been exerted.
+      t.deepEqual(enqueueReturnValues, [true, true, true, false],
+        'at t = 425 ms, the fourth enqueued chunks in rs did cause backpressure');
+    }, 425);
+
+    setTimeout(() => {
+      t.equal(ws.state, 'waiting', 'at t = 475 ms, ws should be waiting');
+      t.deepEqual(chunksGivenToWrite, ['a', 'b'], 'at t = 475 ms, ws.write should have been called with two chunks');
+      t.deepEqual(chunksFinishedWriting, ['a'], 'at t = 475 ms, one chunk should have finished writing');
+    }, 475);
+  });
 });
diff --git a/reference-implementation/test/readable-stream-cancel.js b/reference-implementation/test/readable-stream-cancel.js
index 59e7f3da3..17801a6a8 100644
--- a/reference-implementation/test/readable-stream-cancel.js
+++ b/reference-implementation/test/readable-stream-cancel.js
@@ -4,10 +4,10 @@ import RandomPushSource from './utils/random-push-source';
 import readableStreamToArray from './utils/readable-stream-to-array';
 import sequentialReadableStream from './utils/sequential-rs';
 
-test('ReadableStream canceling an infinite stream', t => {
+test('ReadableStream cancellation: integration test on an infinite stream derived from a random push source', t => {
   const randomSource = new RandomPushSource();
 
-  let cancelationFinished = false;
+  let cancellationFinished = false;
   const rs = new ReadableStream({
     start(enqueue, close, error) {
       randomSource.ondata = enqueue;
@@ -24,99 +24,92 @@ test('ReadableStream canceling an infinite stream', t => {
       randomSource.onend();
 
       return new Promise(resolve => setTimeout(() => {
-        cancelationFinished = true;
+        cancellationFinished = true;
         resolve();
       }, 50));
     }
   });
 
   readableStreamToArray(rs).then(
-    storage => {
+    chunks => {
       t.equal(rs.state, 'closed', 'stream should be closed');
-      t.equal(cancelationFinished, false, 'it did not wait for the cancellation process to finish before closing');
-      t.ok(storage.length > 0, 'should have gotten some data written through the pipe');
-      for (let i = 0; i < storage.length; i++) {
-        t.equal(storage[i].length, 128, 'each chunk has 128 bytes');
+      t.equal(cancellationFinished, false, 'it did not wait for the cancellation process to finish before closing');
+      t.ok(chunks.length > 0, 'at least one chunk should be read');
+      for (let i = 0; i < chunks.length; i++) {
+        t.equal(chunks[i].length, 128, `chunk ${i + 1} should have 128 bytes`);
       }
     },
-    () => {
-      t.fail('the stream should be successfully read to the end');
-      t.end();
-    }
+    e => t.error(e)
   );
 
   setTimeout(() => {
     rs.cancel().then(() => {
-      t.equal(cancelationFinished, true, 'it returns a promise that is fulfilled when the cancellation finishes');
+      t.equal(cancellationFinished, true, 'it returns a promise that is fulfilled when the cancellation finishes');
       t.end();
     });
   }, 150);
 });
 
-test('ReadableStream cancellation puts the stream in a closed state (no chunks pulled yet)', t => {
+test('ReadableStream cancellation: cancelling immediately should put the stream in a closed state', t => {
   const rs = sequentialReadableStream(5);
 
-  t.plan(5);
+  t.plan(4);
 
   rs.closed.then(
-    () => t.assert(true, 'closed promise vended before the cancellation should fulfill'),
-    () => t.fail('closed promise vended before the cancellation should not be rejected')
-  );
-
-  rs.ready.then(
-    () => t.assert(true, 'ready promise vended before the cancellation should fulfill'),
-    () => t.fail('ready promise vended before the cancellation should not be rejected')
+    () => t.pass('closed promise vended before the cancellation should fulfill'),
+    () => t.fail('closed promise vended before the cancellation should not reject')
   );
 
   rs.cancel();
 
-  t.equal(rs.state, 'closed', 'state should be closed');
+  t.equal(rs.state, 'closed', 'state should be closed immediately after cancel() call');
 
   rs.closed.then(
-    () => t.assert(true, 'closed promise vended after the cancellation should fulfill'),
+    () => t.pass('closed promise vended after the cancellation should fulfill'),
     () => t.fail('closed promise vended after the cancellation should not be rejected')
   );
-  rs.ready.then(
-    () => t.assert(true, 'ready promise vended after the cancellation should fulfill'),
-    () => t.fail('ready promise vended after the cancellation should not be rejected')
+
+  rs.read().then(
+    chunk => t.equal(chunk, ReadableStream.EOS, 'read() promise vended after the cancellation should fulfill with EOS'),
+    () => t.fail('read() promise vended after the cancellation should not be rejected')
   );
 });
 
-test('ReadableStream cancellation puts the stream in a closed state (after waiting for chunks)', t => {
+
+test('ReadableStream cancellation: cancelling after reading should put the stream in a closed state', t => {
   const rs = sequentialReadableStream(5);
 
   t.plan(5);
 
-  rs.ready.then(
-    () => {
-      rs.closed.then(
-        () => t.assert(true, 'closed promise vended before the cancellation should fulfill'),
-        () => t.fail('closed promise vended before the cancellation should not be rejected')
-      );
+  rs.closed.then(
+    () => t.pass('closed promise vended before the cancellation should fulfill'),
+    () => t.fail('closed promise vended before the cancellation should not reject')
+  );
 
-      rs.ready.then(
-        () => t.assert(true, 'ready promise vended before the cancellation should fulfill'),
-        () => t.fail('ready promise vended before the cancellation should not be rejected')
-      );
+  rs.read().then(
+    chunk => {
+      t.equal(chunk, 1, 'read() promise vended before the cancellation should fulfill with the first chunk');
 
       rs.cancel();
 
-      t.equal(rs.state, 'closed', 'state should be closed');
+      t.equal(rs.state, 'closed', 'state should be closed immediately after cancel() call');
 
       rs.closed.then(
-        () => t.assert(true, 'closed promise vended after the cancellation should fulfill'),
+        () => t.pass('closed promise vended after the cancellation should fulfill'),
         () => t.fail('closed promise vended after the cancellation should not be rejected')
       );
-      rs.ready.then(
-        () => t.assert(true, 'ready promise vended after the cancellation should fulfill'),
-        () => t.fail('ready promise vended after the cancellation should not be rejected')
+
+      rs.read().then(
+        chunk => t.equal(chunk, ReadableStream.EOS,
+          'read() promise vended after the cancellation should fulfill with EOS'),
+        () => t.fail('read() promise vended after the cancellation should not be rejected')
       );
     },
-    r => t.ifError(r)
+    () => t.fail('read() promise vended after the cancellation should not be rejected')
   );
 });
 
-test('ReadableStream explicit cancellation passes through the given reason', t => {
+test('ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source', t => {
   let recordedReason;
   const rs = new ReadableStream({
     cancel(reason) {
@@ -127,29 +120,32 @@ test('ReadableStream explicit cancellation passes through the given reason', t =
   const passedReason = new Error('Sorry, it just wasn\'t meant to be.');
   rs.cancel(passedReason);
 
-  t.equal(recordedReason, passedReason);
+  t.equal(recordedReason, passedReason,
+    'the error passed to the underlying source\'s cancel method should equal the one passed to the stream\'s cancel');
   t.end();
 });
 
-test('ReadableStream rs.cancel() on a closed stream returns a promise resolved with undefined', t => {
+test('ReadableStream cancellation: cancel() on a closed stream should return a promise resolved with undefined', t => {
+  t.plan(2);
+
   const rs = new ReadableStream({
     start(enqueue, close) {
       close();
     }
   });
 
-  t.equal(rs.state, 'closed');
-  const cancelPromise = rs.cancel(undefined);
-  cancelPromise.then(value => {
-    t.equal(value, undefined, 'fulfillment value of cancelPromise must be undefined');
-    t.end();
-  }).catch(r => {
-    t.fail('cancelPromise is rejected');
-    t.end();
-  });
+  t.equal(rs.state, 'closed', 'state should be closed already');
+
+  rs.cancel().then(
+    v => t.equal(v, undefined, 'cancel() return value should be fulfilled with undefined'),
+    () => t.fail('cancel() return value should not be rejected')
+  );
 });
 
-test('ReadableStream rs.cancel() on an errored stream returns a promise rejected with the error', t => {
+test('ReadableStream cancellation: cancel() on an errored stream should return a promise rejected with the error',
+     t => {
+  t.plan(2);
+
   const passedError = new Error('aaaugh!!');
 
   const rs = new ReadableStream({
@@ -158,133 +154,112 @@ test('ReadableStream rs.cancel() on an errored stream returns a promise rejected
     }
   });
 
-  t.equal(rs.state, 'errored');
-  const cancelPromise = rs.cancel(undefined);
-  cancelPromise.then(() => {
-    t.fail('cancelPromise is fulfilled');
-    t.end();
-  }).catch(r => {
-    t.equal(r, passedError, 'cancelPromise must be rejected with passedError');
-    t.end();
-  });
-});
-
-test('ReadableStream the fulfillment value of the promise rs.cancel() returns must be undefined', t => {
-  const rs = new ReadableStream({
-    cancel(reason) {
-      return "Hello";
-    }
-  });
+  t.equal(rs.state, 'errored', 'state should be errored already');
 
-  const cancelPromise = rs.cancel(undefined);
-  cancelPromise.then(value => {
-    t.equal(value, undefined, 'fulfillment value of cancelPromise must be undefined');
-    t.end();
-  }).catch(r => {
-    t.fail('cancelPromise is rejected');
-    t.end();
-  });
+  rs.cancel().then(
+    () => t.fail('cancel() return value should not be fulfilled'),
+    r => t.equal(r, passedError, 'cancel() return value should be rejected with passedError')
+  );
 });
 
-test('ReadableStream if source\'s cancel throws, the promise returned by rs.cancel() rejects', t => {
-  const errorInCancel = new Error('Sorry, it just wasn\'t meant to be.');
+test('ReadableStream cancellation: returning a value from the underlying source\'s cancel should not affect the ' +
+     'fulfillment value of the promise returned by the stream\'s cancel', t => {
+  t.plan(1);
+
   const rs = new ReadableStream({
     cancel(reason) {
-      throw errorInCancel;
+      return 'Hello';
     }
   });
 
-  const cancelPromise = rs.cancel(undefined);
-  cancelPromise.then(
-    () => {
-      t.fail('cancelPromise is fulfilled unexpectedly');
-      t.end();
-    },
-    r => {
-      t.equal(r, errorInCancel, 'rejection reason of cancelPromise must be errorInCancel');
-      t.end();
-    }
+  rs.cancel().then(
+    v => t.equal(v, undefined, 'cancel() return value should be fulfilled with undefined'),
+    () => t.fail('cancel() return value should not be rejected')
   );
 });
 
-test('ReadableStream onCancel returns a promise that will be resolved asynchronously', t => {
+test('ReadableStream cancellation: if the underlying source\'s cancel method returns a promise, the promise returned ' +
+     'by the stream\'s cancel should fulfill when that one does', t => {
+
   let resolveSourceCancelPromise;
+  let sourceCancelPromiseHasFulfilled = false;
   const rs = new ReadableStream({
     cancel() {
-      return new Promise((resolve, reject) => {
+      const sourceCancelPromise = new Promise((resolve, reject) => {
         resolveSourceCancelPromise = resolve;
       });
+
+      sourceCancelPromise.then(() => {
+        sourceCancelPromiseHasFulfilled = true;
+      });
+
+      return sourceCancelPromise;
     }
   });
 
-  let hasResolvedSourceCancelPromise = false;
 
-  const cancelPromise = rs.cancel();
-  cancelPromise.then(
+  rs.cancel().then(
     value => {
-      t.equal(hasResolvedSourceCancelPromise, true,
-              'cancelPromise must not be resolved before the promise returned by onCancel is resolved');
-      t.equal(value, undefined, 'cancelPromise must be fulfilled with undefined');
+      t.equal(sourceCancelPromiseHasFulfilled, true,
+        'cancel() return value should be fulfilled only after the promise returned by the underlying source\'s cancel');
+      t.equal(value, undefined, 'cancel() return value should be fulfilled with undefined');
       t.end();
-    }
-  ).catch(
-    r => {
-      t.fail('cancelPromise is rejected');
-      t.end();
-    }
+    },
+    () => t.fail('cancel() return value should not be rejected')
   );
 
   setTimeout(() => {
-    hasResolvedSourceCancelPromise = true;
     resolveSourceCancelPromise('Hello');
-  }, 0);
+  }, 30);
 });
 
-test('ReadableStream onCancel returns a promise that will be rejected asynchronously', t => {
+test('ReadableStream cancellation: if the underlying source\'s cancel method returns a promise, the promise returned ' +
+     'by the stream\'s cancel should reject when that one does', t => {
   let rejectSourceCancelPromise;
+  let sourceCancelPromiseHasRejected = false;
   const rs = new ReadableStream({
     cancel() {
-      return new Promise((resolve, reject) => {
+      const sourceCancelPromise = new Promise((resolve, reject) => {
         rejectSourceCancelPromise = reject;
       });
+
+      sourceCancelPromise.catch(() => {
+        sourceCancelPromiseHasRejected = true;
+      });
+
+      return sourceCancelPromise;
     }
   });
 
-  let hasRejectedSourceCancelPromise = false;
   const errorInCancel = new Error('Sorry, it just wasn\'t meant to be.');
 
-  const cancelPromise = rs.cancel();
-  cancelPromise.then(
-    value => {
-      t.fail('cancelPromise is fulfilled');
-      t.end();
-    },
+  rs.cancel().then(
+    () => t.fail('cancel() return value should not be rejected'),
     r => {
-      t.equal(hasRejectedSourceCancelPromise, true,
-              'cancelPromise must not be resolved before the promise returned by onCancel is resolved');
-      t.equal(r, errorInCancel, 'cancelPromise must be rejected with errorInCancel');
+      t.equal(sourceCancelPromiseHasRejected, true,
+        'cancel() return value should be rejected only after the promise returned by the underlying source\'s cancel');
+      t.equal(r, errorInCancel,
+        'cancel() return value should be rejected with the underlying source\'s rejection reason');
       t.end();
     }
   );
 
   setTimeout(() => {
-    hasRejectedSourceCancelPromise = true;
     rejectSourceCancelPromise(errorInCancel);
-  }, 0);
+  }, 30);
 });
 
-test('ReadableStream cancelation before start finishes prevents pull() from being called', t => {
+test('ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called', t => {
   const rs = new ReadableStream({
     pull() {
-      t.fail('unexpected pull call');
+      t.fail('pull should not have been called');
       t.end();
     }
   });
 
-  rs.cancel();
-
-  setTimeout(() => {
-    t.pass('pull was never called');
+  Promise.all([rs.cancel(), rs.closed]).then(() => {
+    t.pass('pull should never have been called');
     t.end();
-  }, 0);
+  })
+  .catch(e => t.error(e));
 });
diff --git a/reference-implementation/test/readable-stream.js b/reference-implementation/test/readable-stream.js
index 8de5d7476..5da57b5fd 100644
--- a/reference-implementation/test/readable-stream.js
+++ b/reference-implementation/test/readable-stream.js
@@ -5,13 +5,26 @@ import readableStreamToArray from './utils/readable-stream-to-array';
 import sequentialReadableStream from './utils/sequential-rs';
 
 test('ReadableStream can be constructed with no arguments', t => {
-  t.plan(1);
   t.doesNotThrow(() => new ReadableStream(), 'ReadableStream constructed with no errors');
+  t.end();
 });
 
-test('ReadableStream instances have the correct methods and properties', t => {
-  t.plan(9);
+// Traceur-troubles, skip for now
+test.skip('ReadableStream has an EOS static property', t => {
+  const props = Object.getOwnPropertyNames(ReadableStream);
+  t.deepEqual(props, ['EOS']);
+
+  const propDesc = Object.getOwnPropertyDescriptor(ReadableStream, 'EOS');
+  t.equal(propDesc.enumerable, false);
+  t.equal(propDesc.writable, false);
+  t.equal(propDesc.configurable, false);
+  t.equal(typeof propDesc.value, 'symbol');
+  t.equal(String(propDesc.value), 'ReadableStream.EOS');
+
+  t.end();
+});
 
+test('ReadableStream instances have the correct methods and properties', t => {
   const rs = new ReadableStream();
 
   t.equal(typeof rs.read, 'function', 'has a read method');
@@ -19,17 +32,17 @@ test('ReadableStream instances have the correct methods and properties', t => {
   t.equal(typeof rs.pipeTo, 'function', 'has a pipeTo method');
   t.equal(typeof rs.pipeThrough, 'function', 'has a pipeThrough method');
 
-  t.equal(rs.state, 'waiting', 'state starts out waiting');
+  t.equal(rs.state, 'readable', 'state starts out readable');
 
-  t.ok(rs.ready, 'has a ready property');
-  t.ok(rs.ready.then, 'ready property is a thenable');
   t.ok(rs.closed, 'has a closed property');
   t.ok(rs.closed.then, 'closed property is thenable');
+
+  t.end();
 });
 
-test('ReadableStream closing puts the stream in a closed state, fulfilling the ready and closed promises with ' +
-    'undefined', t => {
-  t.plan(3);
+test('ReadableStream: immediately closing should put the stream in a closed state and fulfill closed with undefined',
+     t => {
+  t.plan(2);
 
   const rs = new ReadableStream({
     start(enqueue, close) {
@@ -39,28 +52,26 @@ test('ReadableStream closing puts the stream in a closed state, fulfilling the r
 
   t.equal(rs.state, 'closed', 'The stream should be in closed state');
 
-  rs.ready.then(
-    v => t.equal(v, undefined, 'ready should return a promise fulfilled with undefined'),
-    () => t.fail('ready should not return a rejected promise')
-  );
-
   rs.closed.then(
-    v => t.equal(v, undefined, 'closed should return a promise fulfilled with undefined'),
-    () => t.fail('closed should not return a rejected promise')
+    v => t.equal(v, undefined, 'closed should fulfill with undefined'),
+    () => t.fail('closed should not reject')
   );
 });
 
-test('ReadableStream reading a waiting stream throws a TypeError', t => {
-  t.plan(2);
-
+test('ReadableStream: leaving a stream empty leaves it in a readable state, causing read() to never settle', t => {
   const rs = new ReadableStream();
+  t.equal(rs.state, 'readable');
+
+  rs.read().then(
+    () => t.fail('read() should not fulfill'),
+    () => t.fail('read() should not reject')
+  );
 
-  t.equal(rs.state, 'waiting');
-  t.throws(() => rs.read(), /TypeError/);
+  setTimeout(() => t.end(), 100);
 });
 
-test('ReadableStream reading a closed stream throws a TypeError', t => {
-  t.plan(2);
+test('ReadableStream: reading a closed stream fulfills with EOS', t => {
+  t.plan(1);
 
   const rs = new ReadableStream({
     start(enqueue, close) {
@@ -68,15 +79,16 @@ test('ReadableStream reading a closed stream throws a TypeError', t => {
     }
   });
 
-  t.equal(rs.state, 'closed');
-  t.throws(() => rs.read(), /TypeError/);
+  rs.read().then(
+    v => t.equal(v, ReadableStream.EOS, 'read() should return a promise fulfilled with EOS'),
+    () => t.fail('read() should not return a rejected promise')
+  );
 });
 
-test('ReadableStream reading an errored stream throws the stored error', t => {
+test('ReadableStream: reading an errored stream rejects with the stored error', t => {
   t.plan(2);
 
   const passedError = new Error('aaaugh!!');
-
   const rs = new ReadableStream({
     start(enqueue, close, error) {
       error(passedError);
@@ -84,66 +96,272 @@ test('ReadableStream reading an errored stream throws the stored error', t => {
   });
 
   t.equal(rs.state, 'errored');
-  try {
-    rs.read();
-    t.fail('rs.read() didn\'t throw');
-  } catch (e) {
-    t.equal(e, passedError);
-  }
+
+  rs.read().then(
+    () => t.fail('read() should not fulfill'),
+    e => t.equal(e, passedError, 'read() should reject with the passed error')
+  );
 });
 
-test('ReadableStream reading a stream makes ready and closed return a promise fulfilled with undefined when the ' +
-    'stream is fully drained', t => {
-  t.plan(6);
+test('ReadableStream: reading a forever-empty stream while a read is still ongoing rejects', t => {
+  t.plan(1);
+
+  const rs = new ReadableStream();
+
+  rs.read().then(
+    () => t.fail('first read() should not fulfill'),
+    e => t.fail('first read() should not reject')
+  );
+
+  rs.read().then(
+    () => t.fail('second read() should not fulfill'),
+    e => t.equal(e.constructor, TypeError, 'second read() should reject with a TypeError')
+  );
+});
+
+test('ReadableStream: reading a nonempty stream while a read is still ongoing rejects', t => {
+  t.plan(2);
+
+  const rs = new ReadableStream({
+    start(enqueue) {
+      enqueue('a');
+      enqueue('b');
+    }
+  });
+
+  rs.read().then(
+    v => t.equal(v, 'a', 'first read() should fulfill with the first chunk'),
+    e => t.fail('first read() should not reject')
+  );
+
+  rs.read().then(
+    () => t.fail('second read() should not fulfill'),
+    e => t.equal(e.constructor, TypeError, 'second read() should reject with a TypeError')
+  );
+});
+
+test('ReadableStream: reading a nonempty stream with appropriate waiting works fine', t => {
+  t.plan(2);
+
+  const rs = new ReadableStream({
+    start(enqueue) {
+      enqueue('a');
+      enqueue('b');
+    }
+  });
+
+  rs.read()
+    .then(
+      v => {
+        t.equal(v, 'a', 'first read() should fulfill with the first chunk');
+        return rs.read();
+      },
+      e => t.fail('first read() should not reject')
+    )
+    .then(
+      v => t.equal(v, 'b', 'second read() should fulfill with the second chunk'),
+      e => t.fail('second read() should not reject')
+    );
+});
+
+test('ReadableStream: reading a nonempty stream to the end works fine', t => {
+  t.plan(3);
 
   const rs = new ReadableStream({
     start(enqueue, close) {
-      enqueue('test');
+      enqueue('a');
+      enqueue('b');
       close();
     }
   });
 
-  t.equal(rs.state, 'readable', 'The stream should be in readable state');
-  t.equal(rs.read(), 'test', 'A test string should be read');
-  t.equal(rs.state, 'closed', 'The stream should be in closed state');
+  rs.read()
+    .then(
+      v => {
+        t.equal(v, 'a', 'first read() should fulfill with the first chunk');
+        return rs.read();
+      },
+      e => t.fail('first read() should not reject')
+    )
+    .then(
+      v => {
+        t.equal(v, 'b', 'second read() should fulfill with the second chunk');
+        return rs.read();
+      },
+      e => t.fail('second read() should not reject')
+    )
+    .then(
+      v => t.equal(v, ReadableStream.EOS, 'third read() should fulfill with EOS'),
+      e => t.fail('third read() should not reject')
+    );
+});
 
-  t.throws(() => rs.read(), /TypeError/);
+test('ReadableStream: draining a stream via read() causes the closed promise to fulfill', t => {
+  t.plan(5);
+
+  const rs = new ReadableStream({
+    start(enqueue, close) {
+      enqueue('test');
+      close();
+    }
+  });
+
+  t.equal(rs.state, 'readable', 'The stream should be in readable state to start with');
 
-  rs.ready.then(
-    v => t.equal(v, undefined, 'ready should return a promise fulfilled with undefined'),
-    () => t.fail('ready should not return a rejected promise')
+  rs.read().then(
+    v => {
+      t.equal(v, 'test', 'the enqueued chunk should be read');
+      t.equal(rs.state, 'closed', 'the stream should still be in a closed state');
+    },
+    e => t.fail('read() should not reject')
   );
 
+  t.equal(rs.state, 'closed', 'The stream should be in a closed state immediately after reading');
+
   rs.closed.then(
-    v => t.equal(v, undefined, 'closed should return a promise fulfilled with undefined'),
-    () => t.fail('closed should not return a rejected promise')
+    v => t.equal(v, undefined, 'closed should fulfill with undefined'),
+    () => t.fail('closed should not reject')
   );
 });
 
-test('ReadableStream avoid redundant pull call', t => {
+test('ReadableStream: should only call underlying source pull() once upon starting the stream', t => {
+  t.plan(2);
+
+  let pullCount = 0;
+  const startPromise = Promise.resolve();
+  const rs = new ReadableStream({
+    start() {
+      return startPromise;
+    },
+    pull() {
+      pullCount++;
+    }
+  });
+
+  startPromise.then(() => {
+    t.equal(pullCount, 1, 'pull should be called once start finishes');
+  });
+
+  setTimeout(() => t.equal(pullCount, 1, 'pull should be called exactly once'), 50);
+});
+
+test('ReadableStream: should only call underlying source pull() once on a forever-empty stream, even after reading',
+     t => {
+  t.plan(2);
+
   let pullCount = 0;
+  const startPromise = Promise.resolve();
   const rs = new ReadableStream({
+    start() {
+      return startPromise;
+    },
     pull() {
       pullCount++;
+    }
+  });
+
+  startPromise.then(() => {
+    t.equal(pullCount, 1, 'pull should be called once start finishes');
+  });
+
+  rs.read();
+
+  setTimeout(() => t.equal(pullCount, 1, 'pull should be called exactly once'), 50);
+});
+
+test('ReadableStream: should only call underlying source pull() once on a non-empty stream read from before start ' +
+     'fulfills', t => {
+  t.plan(5);
+
+  let pullCount = 0;
+  const startPromise = Promise.resolve();
+  const rs = new ReadableStream({
+    start(enqueue) {
+      enqueue('a');
+      return startPromise;
     },
+    pull() {
+      pullCount++;
+    }
+  });
 
-    cancel() {
-      t.fail('cancel should not be called');
+  startPromise.then(() => {
+    t.equal(pullCount, 1, 'pull should be called once start finishes');
+  });
+
+  rs.read().then(v => {
+    t.equal(v, 'a', 'first read() should return first chunk');
+    t.equal(pullCount, 1, 'pull should not have been called again');
+  });
+
+  t.equal(pullCount, 0, 'calling read() should not cause pull to be called yet');
+
+  setTimeout(() => t.equal(pullCount, 1, 'pull should be called exactly once'), 50);
+});
+
+test('ReadableStream: should only call underlying source pull() twice on a non-empty stream read from after start ' +
+     'fulfills', t => {
+  t.plan(5);
+
+  let pullCount = 0;
+  const startPromise = Promise.resolve();
+  const rs = new ReadableStream({
+    start(enqueue) {
+      enqueue('a');
+      return startPromise;
+    },
+    pull() {
+      pullCount++;
     }
   });
 
-  rs.ready;
-  rs.ready;
-  rs.ready;
+  startPromise.then(() => {
+    t.equal(pullCount, 1, 'pull should be called once start finishes');
 
-  // Use setTimeout to ensure we run after any promises.
-  setTimeout(() => {
-    t.equal(pullCount, 1, 'pull should not be called more than once');
-    t.end();
-  }, 50);
+    rs.read().then(v => {
+      t.equal(v, 'a', 'first read() should return first chunk');
+      t.equal(pullCount, 2, 'pull should be called again once read fulfills');
+    });
+  });
+
+  t.equal(pullCount, 0, 'calling read() should not cause pull to be called yet');
+
+  setTimeout(() => t.equal(pullCount, 2, 'pull should be called exactly twice'), 50);
+});
+
+test('ReadableStream: should call underlying source pull() in reaction to read()ing the last chunk', t => {
+  t.plan(6);
+
+  let pullCount = 0;
+  const startPromise = Promise.resolve();
+  const rs = new ReadableStream({
+    start() {
+      return startPromise;
+    },
+    pull(enqueue) {
+      enqueue(++pullCount);
+    }
+  });
+
+  startPromise.then(() => {
+    t.equal(pullCount, 1, 'pull should be called once start finishes');
+  });
+
+  rs.read()
+    .then(v => {
+      t.equal(v, 1, 'first read() should return first chunk');
+      t.equal(pullCount, 2, 'pull should be called in reaction to reading');
+      return rs.read();
+    })
+    .then(v => {
+      t.equal(v, 2, 'second read() should return second chunk');
+      t.equal(pullCount, 3, 'pull should be called in reaction to reading, again');
+    });
+
+  setTimeout(() => t.equal(pullCount, 3, 'pull should be called exactly thrice'), 50);
 });
 
-test('ReadableStream start throws an error', t => {
+test('ReadableStream: if start throws an error, it should be re-thrown', t => {
   t.plan(1);
 
   const error = new Error('aaaugh!!');
@@ -156,37 +374,61 @@ test('ReadableStream start throws an error', t => {
   }
 });
 
-test('ReadableStream pull throws an error', t => {
-  t.plan(4);
+test('ReadableStream: if pull throws an error, it should error the stream', t => {
+  t.plan(5);
 
   const error = new Error('aaaugh!!');
-  const rs = new ReadableStream({ pull() { throw error; } });
+  const rs = new ReadableStream({
+    pull() {
+      throw error;
+    }
+  });
 
-  rs.closed.then(() => {
-    t.fail('the stream should not close successfully');
-    t.end();
+  t.equal(rs.state, 'readable', 'state should start out "readable" since pull isn\'t called immediately');
+
+  rs.closed.catch(e => {
+    t.equal(rs.state, 'errored', 'state should be "errored" in closed catch');
+    t.equal(e, error, 'closed should reject with the thrown error');
   });
 
-  rs.ready.then(v => {
-    t.equal(rs.state, 'errored', 'state is "errored" after waiting'),
-    t.equal(v, undefined, 'ready fulfills with undefined')
+  rs.read().catch(e => {
+    t.equal(rs.state, 'errored', 'state should be "errored" in read() catch');
+    t.equal(e, error, 'read() should reject with the thrown error');
   });
+});
 
-  rs.closed.catch(caught => {
-    t.equal(rs.state, 'errored', 'state is "errored" in closed catch');
-    t.equal(caught, error, 'error was passed through as rejection reason of closed property');
+test('ReadableStream: if pull rejects, it should error the stream', t => {
+  t.plan(5);
+
+  const error = new Error('pull failure');
+  const rs = new ReadableStream({
+    pull() {
+      return Promise.reject(error);
+    }
+  });
+
+  t.equal(rs.state, 'readable', 'state should start out "readable" since pull isn\'t called immediately');
+
+  rs.closed.catch(e => {
+    t.equal(rs.state, 'errored', 'state should be "errored" in closed catch');
+    t.equal(e, error, 'closed should reject with the thrown error');
+  });
+
+  rs.read().catch(e => {
+    t.equal(rs.state, 'errored', 'state should be "errored" in read() catch');
+    t.equal(e, error, 'read() should reject with the thrown error');
   });
 });
 
-test('ReadableStream adapting a push source', t => {
+test('ReadableStream integration test: adapting a random push source', t => {
   let pullChecked = false;
   const randomSource = new RandomPushSource(8);
 
   const rs = new ReadableStream({
     start(enqueue, close, error) {
-      t.equal(typeof enqueue,  'function', 'enqueue is a function in start');
-      t.equal(typeof close, 'function', 'close is a function in start');
-      t.equal(typeof error, 'function', 'error is a function in start');
+      t.equal(typeof enqueue,  'function', 'enqueue should be a function in start');
+      t.equal(typeof close, 'function', 'close should be a function in start');
+      t.equal(typeof error, 'function', 'error should be a function in start');
 
       randomSource.ondata = chunk => {
         if (!enqueue(chunk)) {
@@ -201,73 +443,53 @@ test('ReadableStream adapting a push source', t => {
     pull(enqueue, close) {
       if (!pullChecked) {
         pullChecked = true;
-        t.equal(typeof enqueue, 'function', 'enqueue is a function in pull');
-        t.equal(typeof close, 'function', 'close is a function in pull');
+        t.equal(typeof enqueue, 'function', 'enqueue should be a function in pull');
+        t.equal(typeof close, 'function', 'close should be a function in pull');
       }
 
       randomSource.readStart();
     }
   });
 
-  readableStreamToArray(rs).then(chunks => {
-    t.equal(rs.state, 'closed', 'should be closed');
-    t.equal(chunks.length, 8, 'got the expected 8 chunks');
-    for (let i = 0; i < chunks.length; i++) {
-      t.equal(chunks[i].length, 128, 'each chunk has 128 bytes');
-    }
+  readableStreamToArray(rs).then(
+    chunks => {
+      t.equal(rs.state, 'closed', 'stream should be closed after all chunks are read');
+      t.equal(chunks.length, 8, '8 chunks should be read');
+      for (let i = 0; i < chunks.length; i++) {
+        t.equal(chunks[i].length, 128, `chunk ${i + 1} should have 128 bytes`);
+      }
 
-    t.end();
-  });
+      t.end();
+    },
+    e => t.error(e)
+  );
 });
 
-test('ReadableStream adapting a sync pull source', t => {
+test('ReadableStream integration test: adapting a sync pull source', t => {
   const rs = sequentialReadableStream(10);
 
   readableStreamToArray(rs).then(chunks => {
-    t.equal(rs.state, 'closed', 'stream should be closed');
-    t.equal(rs.source.closed, true, 'source should be closed');
-    t.deepEqual(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'got the expected 10 chunks');
+    t.equal(rs.state, 'closed', 'stream should be closed after all chunks are read');
+    t.equal(rs.source.closed, true, 'source should be closed after all chunks are read');
+    t.deepEqual(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'the expected 10 chunks should be read');
 
     t.end();
   });
 });
 
-test('ReadableStream adapting an async pull source', t => {
+test('ReadableStream integration test: adapting an async pull source', t => {
   const rs = sequentialReadableStream(10, { async: true });
 
   readableStreamToArray(rs).then(chunks => {
-    t.equal(rs.state, 'closed', 'stream should be closed');
-    t.equal(rs.source.closed, true, 'source should be closed');
-    t.deepEqual(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'got the expected 10 chunks');
+    t.equal(rs.state, 'closed', 'stream should be closed after all chunks are read');
+    t.equal(rs.source.closed, true, 'source should be closed after all chunks are read');
+    t.deepEqual(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'the expected 10 chunks should be read');
 
     t.end();
   });
 });
 
-test('ReadableStream is able to enqueue lots of data in a single pull, making it available synchronously', t => {
-  let i = 0;
-  const rs = new ReadableStream({
-    pull(enqueue, close) {
-      while (++i <= 10) {
-        enqueue(i);
-      }
-
-      close();
-    }
-  });
-
-  rs.ready.then(() => {
-    const data = [];
-    while (rs.state === 'readable') {
-      data.push(rs.read());
-    }
-
-    t.deepEqual(data, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    t.end();
-  });
-});
-
-test('ReadableStream does not call pull until previous pull\'s promise fulfills', t => {
+test('ReadableStream: should not call pull until the previous pull call\'s promise fulfills', t => {
   let resolve;
   let returnedPromise;
   let timesCalled = 0;
@@ -280,35 +502,33 @@ test('ReadableStream does not call pull until previous pull\'s promise fulfills'
     }
   });
 
-  t.equal(rs.state, 'waiting', 'stream starts out waiting');
-
-  rs.ready.then(() => {
-    t.equal(rs.state, 'readable', 'stream becomes readable (even before promise fulfills)');
-    t.equal(timesCalled, 1, 'pull is not yet called a second time');
-    t.equal(rs.read(), 1, 'read() returns enqueued value');
+  rs.read().then(chunk1 => {
+    t.equal(timesCalled, 1, 'pull should not yet have been called a second time');
+    t.equal(chunk1, 1, 'read() should fulfill with the enqueued value');
 
     setTimeout(() => {
-      t.equal(timesCalled, 1, 'after 30 ms, pull has still only been called once');
+      t.equal(timesCalled, 1, 'after 30 ms, pull should still only have been called once');
 
       resolve();
 
       returnedPromise.then(() => {
-        t.equal(timesCalled, 2, 'after the promise is fulfilled, pull is called a second time');
-        t.equal(rs.read(), 2, 'read() returns the second enqueued value');
+        t.equal(timesCalled, 2, 'after the promise returned by pull is fulfilled, pull should be called a second time');
         t.end();
       });
     }, 30);
   });
 });
 
-test('ReadableStream does not call pull multiple times after previous pull finishes', t => {
+test('ReadableStream: should pull after start, and after every read', t => {
   let timesCalled = 0;
 
+  const startPromise = Promise.resolve();
   const rs = new ReadableStream({
     start(enqueue) {
       enqueue('a');
       enqueue('b');
       enqueue('c');
+      return startPromise;
     },
     pull() {
       ++timesCalled;
@@ -323,165 +543,97 @@ test('ReadableStream does not call pull multiple times after previous pull finis
     }
   });
 
-  t.equal(rs.state, 'readable', 'since start() synchronously enqueued chunks, the stream is readable');
-
   // Wait for start to finish
-  rs.ready.then(() => {
-    t.equal(rs.read(), 'a', 'first chunk should be as expected');
-    t.equal(rs.read(), 'b', 'second chunk should be as expected');
-    t.equal(rs.read(), 'c', 'third chunk should be as expected');
+  startPromise.then(() => {
+    return rs.read().then(chunk1 => {
+      t.equal(chunk1, 'a', 'first chunk should be as expected');
 
-    setTimeout(() => {
-      // Once for after start, and once for after rs.read() === 'a'.
-      t.equal(timesCalled, 2, 'pull() should only be called twice');
-      t.end();
-    }, 50);
-  });
-});
+      return rs.read().then(chunk2 => {
+        t.equal(chunk2, 'b', 'second chunk should be as expected');
 
-test('ReadableStream pull rejection makes stream errored', t => {
-  t.plan(2);
+        return rs.read().then(chunk3 => {
+          t.equal(chunk3, 'c', 'third chunk should be as expected');
 
-  const theError = new Error('pull failure');
-  const rs = new ReadableStream({
-    pull() {
-      return Promise.reject(theError);
-    }
-  });
-
-  t.equal(rs.state, 'waiting', 'stream starts out waiting');
-
-  rs.closed.then(
-    () => t.fail('.closed should not fulfill'),
-    e => t.equal(e, theError, '.closed should reject with the error')
-  );
-});
-
-test('ReadableStream ready does not error when no more data is available', t => {
-  // https://github.com/whatwg/streams/issues/80
-
-  t.plan(1);
-
-  const rs = sequentialReadableStream(5, { async: true });
-  const result = [];
-
-  pump();
-
-  function pump() {
-    while (rs.state === 'readable') {
-      result.push(rs.read());
-    }
-
-    if (rs.state === 'closed') {
-      t.deepEqual(result, [1, 2, 3, 4, 5], 'got the expected 5 chunks');
-    } else {
-      rs.ready.then(pump, r => t.ifError(r));
-    }
-  }
-});
-
-test('ReadableStream should be able to get data sequentially from an asynchronous stream', t => {
-  // https://github.com/whatwg/streams/issues/80
-
-  t.plan(4);
-
-  const rs = sequentialReadableStream(3, { async: true });
-
-  const result = [];
-  const EOF = Object.create(null);
-
-  getNext().then(v => {
-    t.equal(v, 1, 'first chunk should be 1');
-    return getNext().then(v => {
-      t.equal(v, 2, 'second chunk should be 2');
-      return getNext().then(v => {
-        t.equal(v, 3, 'third chunk should be 3');
-        return getNext().then(v => {
-          t.equal(v, EOF, 'fourth result should be EOF');
+          setTimeout(() => {
+            // Once for after start, and once for every read.
+            t.equal(timesCalled, 4, 'pull() should be called exactly four times');
+            t.end();
+          }, 50);
         });
       });
     });
   })
-  .catch(r => t.ifError(r));
-
-  function getNext() {
-    if (rs.state === 'closed') {
-      return Promise.resolve(EOF);
-    }
-
-    return rs.ready.then(() => {
-      if (rs.state === 'readable') {
-        return rs.read();
-      } else if (rs.state === 'closed') {
-        return EOF;
-      }
-    });
-  }
+  .catch(e => t.error(e));
 });
 
-test('Default ReadableStream returns `false` for all but the first `enqueue` call', t => {
+test('ReadableStream strategies: the default strategy should return false for all but the first enqueue call', t => {
   t.plan(5);
 
   new ReadableStream({
     start(enqueue) {
-      t.equal(enqueue('hi'), true);
-      t.equal(enqueue('hey'), false);
-      t.equal(enqueue('whee'), false);
-      t.equal(enqueue('yo'), false);
-      t.equal(enqueue('sup'), false);
+      t.equal(enqueue('a'), true, 'first enqueue should return true');
+      t.equal(enqueue('b'), false, 'second enqueue should return false');
+      t.equal(enqueue('c'), false, 'third enqueue should return false');
+      t.equal(enqueue('d'), false, 'fourth enqueue should return false');
+      t.equal(enqueue('e'), false, 'fifth enqueue should return false');
     }
   });
 });
 
-test('ReadableStream continues returning `true` from `enqueue` if the data is read out of it in time', t => {
-  t.plan(12);
-
+test('ReadableStream strategies: the default strategy should continue returning true from enqueue if the chunks are ' +
+     'read immediately', t => {
+  let doEnqueue;
   const rs = new ReadableStream({
     start(enqueue) {
-      // Delay a bit so that the stream is successfully constructed and thus the `rs` variable references something.
-      setTimeout(() => {
-        t.equal(enqueue('foo'), true);
-        t.equal(rs.state, 'readable');
-        t.equal(rs.read(), 'foo');
-        t.equal(rs.state, 'waiting');
-
-        t.equal(enqueue('bar'), true);
-        t.equal(rs.state, 'readable');
-        t.equal(rs.read(), 'bar');
-        t.equal(rs.state, 'waiting');
-
-        t.equal(enqueue('baz'), true);
-        t.equal(rs.state, 'readable');
-        t.equal(rs.read(), 'baz');
-        t.equal(rs.state, 'waiting');
-      }, 0);
-    },
-    strategy: new CountQueuingStrategy({ highWaterMark: 4 })
+      doEnqueue = enqueue;
+    }
   });
+
+  t.equal(doEnqueue('a'), true, 'first enqueue should return true');
+
+  rs.read().then(chunk1 => {
+    t.equal(chunk1, 'a', 'first chunk read should be correct');
+    t.equal(doEnqueue('b'), true, 'second enqueue should return true');
+
+    return rs.read().then(chunk2 => {
+      t.equal(chunk2, 'b', 'second chunk read should be correct');
+      t.equal(doEnqueue('c'), true, 'third enqueue should return true');
+
+      return rs.read().then(chunk3 => {
+        t.equal(chunk3, 'c', 'third chunk read should be correct');
+        t.equal(doEnqueue('d'), true, 'fourth enqueue should return true');
+
+        t.end();
+      });
+    });
+  })
+  .catch(e => t.error(e));
 });
 
-test('ReadableStream enqueue fails when the stream is draining', t => {
+test('ReadableStream: enqueue should throw when the stream is readable but draining', t => {
+  t.plan(4);
+
   const rs = new ReadableStream({
     start(enqueue, close) {
-      t.equal(enqueue('a'), true);
+      t.equal(enqueue('a'), true, 'the first enqueue should return true');
       close();
 
       t.throws(
         () => enqueue('b'),
         /TypeError/,
-        'enqueue after close must throw a TypeError'
+        'enqueue after close should throw a TypeError'
       );
-    },
-    strategy: new CountQueuingStrategy({ highWaterMark: 10 })
+    }
   });
 
-  t.equal(rs.state, 'readable');
-  t.equal(rs.read(), 'a');
-  t.equal(rs.state, 'closed');
-  t.end();
+  t.equal(rs.state, 'readable', 'state should start readable');
+  rs.read();
+  t.equal(rs.state, 'closed', 'state should become closed immediately after reading');
 });
 
-test('ReadableStream enqueue fails when the stream is closed', t => {
+test('ReadableStream: enqueue should throw when the stream is closed', t => {
+  t.plan(2);
+
   const rs = new ReadableStream({
     start(enqueue, close) {
       close();
@@ -489,16 +641,17 @@ test('ReadableStream enqueue fails when the stream is closed', t => {
       t.throws(
         () => enqueue('a'),
         /TypeError/,
-        'enqueue after close must throw a TypeError'
+        'enqueue after close should throw a TypeError'
       );
     }
   });
 
-  t.equal(rs.state, 'closed');
-  t.end();
+  t.equal(rs.state, 'closed', 'state should be closed immediately after creation');
 });
 
-test('ReadableStream enqueue fails with the correct error when the stream is errored', t => {
+test('ReadableStream: enqueue should throw the stored error when the stream is errored', t => {
+  t.plan(2);
+
   const expectedError = new Error('i am sad');
   const rs = new ReadableStream({
     start(enqueue, close, error) {
@@ -507,198 +660,29 @@ test('ReadableStream enqueue fails with the correct error when the stream is err
       t.throws(
         () => enqueue('a'),
         /i am sad/,
-        'enqueue after error must throw that error'
+        'enqueue after error should throw that error'
       );
     }
   });
 
-  t.equal(rs.state, 'errored');
-  t.end();
+  t.equal(rs.state, 'errored', 'state should be errored immediately after creation');
 });
 
-test('ReadableStream if shouldApplyBackpressure throws, the stream is errored', t => {
-  const error = new Error('aaaugh!!');
-
+test('ReadableStream: cancel() and closed on a closed stream should return the same promise', t => {
   const rs = new ReadableStream({
-    start(enqueue) {
-      try {
-        enqueue('hi');
-        t.fail('enqueue didn\'t throw');
-        t.end();
-      } catch (e) {
-        t.equal(e, error);
-      }
-    },
-    strategy: {
-      size() {
-        return 1;
-      },
-
-      shouldApplyBackpressure() {
-        throw error;
-      }
-    }
-  });
-
-  rs.closed.catch(r => {
-    t.equal(r, error);
-    t.end();
-  });
-});
-
-test('ReadableStream if size throws, the stream is errored', t => {
-  const error = new Error('aaaugh!!');
-
-  const rs = new ReadableStream({
-    start(enqueue) {
-      try {
-        enqueue('hi');
-        t.fail('enqueue didn\'t throw');
-        t.end();
-      } catch (e) {
-        t.equal(e, error);
-      }
-    },
-    strategy: {
-      size() {
-        throw error;
-      },
-
-      shouldApplyBackpressure() {
-        return true;
-      }
-    }
-  });
-
-  rs.closed.catch(r => {
-    t.equal(r, error);
-    t.end();
-  });
-});
-
-test('ReadableStream if size is NaN, the stream is errored', t => {
-  t.plan(2);
-
-  const rs = new ReadableStream({
-    start(enqueue) {
-      try {
-        enqueue('hi');
-        t.fail('enqueue didn\'t throw');
-      } catch (error) {
-        t.equal(error.constructor, RangeError);
-      }
-    },
-    strategy: {
-      size() {
-        return NaN;
-      },
-
-      shouldApplyBackpressure() {
-        return true;
-      }
-    }
-  });
-
-  t.equal(rs.state, 'errored', 'state should be errored');
-});
-
-test('ReadableStream if size is -Infinity, the stream is errored', t => {
-  t.plan(2);
-
-  const rs = new ReadableStream({
-    start(enqueue) {
-      try {
-        enqueue('hi');
-        t.fail('enqueue didn\'t throw');
-      } catch (error) {
-        t.equal(error.constructor, RangeError);
-      }
-    },
-    strategy: {
-      size() {
-        return -Infinity;
-      },
-
-      shouldApplyBackpressure() {
-        return true;
-      }
-    }
-  });
-
-  t.equal(rs.state, 'errored', 'state should be errored');
-});
-
-test('ReadableStream if size is +Infinity, the stream is errored', t => {
-  t.plan(2);
-
-  const rs = new ReadableStream({
-    start(enqueue) {
-      try {
-        enqueue('hi');
-        t.fail('enqueue didn\'t throw');
-      } catch (error) {
-        t.equal(error.constructor, RangeError);
-      }
-    },
-    strategy: {
-      size() {
-        return +Infinity;
-      },
-
-      shouldApplyBackpressure() {
-        return true;
-      }
-    }
-  });
-
-  t.equal(rs.state, 'errored', 'state should be errored');
-});
-
-test('ReadableStream errors in shouldApplyBackpressure cause ready to fulfill and closed to rejected', t => {
-  t.plan(3);
-
-  const thrownError = new Error('size failure');
-  let callsToShouldApplyBackpressure = 0;
-  const rs = new ReadableStream({
-    start(enqueue) {
-      setTimeout(() => {
-        try {
-          enqueue('hi');
-          t.fail('enqueue didn\'t throw');
-        } catch (error) {
-          t.equal(error, thrownError, 'error thrown by enqueue should be the thrown error');
-        }
-      }, 0);
-    },
-    strategy: {
-      size() {
-        return 1;
-      },
-      shouldApplyBackpressure() {
-        if (++callsToShouldApplyBackpressure === 2) {
-          throw thrownError;
-        }
-
-        return false;
-      }
+    start(enqueue, close) {
+      close();
     }
   });
 
-  rs.ready.then(
-    v => t.equal(v, undefined, 'ready should be fulfilled with undefined'),
-    e => t.fail('ready should not be rejected')
-  );
-
-  rs.closed.then(
-    v => t.fail('closed should not be fulfilled'),
-    e => t.equal(e, thrownError, 'closed should be rejected with the thrown error')
-  );
+  t.equal(rs.cancel(), rs.closed, 'the promises returned should be the same');
+  t.end();
 });
 
-test('ReadableStream cancel() and closed on a closed stream should return the same promise', t => {
+test('ReadableStream: cancel() and closed on an errored stream should return the same promise', t => {
   const rs = new ReadableStream({
-    start(enqueue, close) {
-      close();
+    start(enqueue, close, error) {
+      error(new Error('boo!'));
     }
   });
 
@@ -706,35 +690,24 @@ test('ReadableStream cancel() and closed on a closed stream should return the sa
   t.end();
 });
 
-test('ReadableStream ready returns the same value when called on a new, empty stream', t => {
+test('ReadableStream: read() returns fresh promises each call (empty stream)', t => {
   const rs = new ReadableStream();
-  t.equal(rs.ready, rs.ready, 'rs.ready should not change between gets');
+  t.notEqual(rs.read(), rs.read(), 'the promises returned should be different');
   t.end();
 });
 
-test('ReadableStream ready returns the same value when called on a readable stream', t => {
+test('ReadableStream: read() returns fresh promises each call (stream with a chunk)', t => {
   const rs = new ReadableStream({
     start(enqueue) {
       enqueue('a');
     }
   });
 
-  t.equal(rs.ready, rs.ready, 'rs.ready should not change between gets');
-  t.end();
-});
-
-test('ReadableStream cancel() and closed on an errored stream should return the same promise', t => {
-  const rs = new ReadableStream({
-    start(enqueue, close, error) {
-      error(new Error('boo!'));
-    }
-  });
-
-  t.equal(rs.cancel(), rs.closed, 'the promises returned should be the same');
+  t.notEqual(rs.read(), rs.read(), 'the promises returned should be different');
   t.end();
 });
 
-test('ReadableStream should call underlying source methods as methods', t => {
+test('ReadableStream: should call underlying source methods as methods', t => {
   t.plan(6);
 
   class Source {
@@ -759,8 +732,8 @@ test('ReadableStream should call underlying source methods as methods', t => {
   }
 
   const theSource = new Source();
-  theSource.debugName = "the source object passed to the constructor";
+  theSource.debugName = 'the source object passed to the constructor'; // makes test failures easier to diagnose
   const rs = new ReadableStream(theSource);
 
-  rs.ready.then(() => rs.cancel());
+  rs.read().then(() => rs.cancel());
 });
diff --git a/reference-implementation/test/transform-stream-errors.js b/reference-implementation/test/transform-stream-errors.js
index 5a83712ab..63e4cf5e5 100644
--- a/reference-implementation/test/transform-stream-errors.js
+++ b/reference-implementation/test/transform-stream-errors.js
@@ -1,7 +1,7 @@
 const test = require('tape-catch');
 
 test('TransformStream errors thrown in transform put the writable and readable in an errored state', t => {
-  t.plan(9);
+  t.plan(8);
 
   const thrownError = new Error('bad things are happening!');
   const ts = new TransformStream({
@@ -10,26 +10,23 @@ test('TransformStream errors thrown in transform put the writable and readable i
     }
   });
 
-  t.equal(ts.readable.state, 'waiting', 'readable starts in waiting');
+  t.equal(ts.readable.state, 'readable', 'readable starts in readable');
   t.equal(ts.writable.state, 'writable', 'writable starts in writable');
 
   ts.writable.write('a');
 
-  t.equal(ts.readable.state, 'waiting', 'readable stays in waiting immediately after throw');
-  t.equal(ts.writable.state, 'waiting', 'writable stays in waiting immediately after throw');
+  t.equal(ts.writable.state, 'waiting', 'writable becomes waiting immediately after throw');
 
   setTimeout(() => {
     t.equal(ts.readable.state, 'errored', 'readable becomes errored after writing to the throwing transform');
     t.equal(ts.writable.state, 'errored', 'writable becomes errored after writing to the throwing transform');
-
-    try {
-      ts.readable.read();
-      t.fail('read() didn\'nt throw');
-    } catch (error) {
-      t.equal(error, thrownError, 'readable\'s read should throw the thrown error');
-    }
   }, 0);
 
+  ts.readable.read().then(
+    () => t.fail('readable\'s read() should reject'),
+    r => t.equal(r, thrownError, 'readable\'s read should reject with the thrown error')
+  );
+
   ts.readable.closed.then(
     () => t.fail('readable\'s closed should not be fulfilled'),
     e => t.equal(e, thrownError, 'readable\'s closed should be rejected with the thrown error')
@@ -54,31 +51,29 @@ test('TransformStream errors thrown in flush put the writable and readable in an
     }
   });
 
-  t.equal(ts.readable.state, 'waiting', 'readable starts in waiting');
+  t.equal(ts.readable.state, 'readable', 'readable starts in readable');
   t.equal(ts.writable.state, 'writable', 'writable starts in writable');
 
   ts.writable.write('a');
 
-  t.equal(ts.readable.state, 'waiting', 'readable stays in waiting after a write');
-  t.equal(ts.writable.state, 'waiting', 'writable stays in waiting after a write');
+  t.equal(ts.readable.state, 'readable', 'readable stays in waiting after a write');
+  t.equal(ts.writable.state, 'waiting', 'writable becomes waiting after a write');
 
   ts.writable.close();
 
-  t.equal(ts.readable.state, 'waiting', 'readable stays in waiting immediately after a throw');
-  t.equal(ts.writable.state, 'closing', 'writable becomes closing immediately after a throw');
+  t.equal(ts.readable.state, 'readable', 'readable stays in readable after the close call');
+  t.equal(ts.writable.state, 'closing', 'writable becomes closing after the close call');
 
   setTimeout(() => {
     t.equal(ts.readable.state, 'errored', 'readable becomes errored after closing with the throwing flush');
     t.equal(ts.writable.state, 'errored', 'writable becomes errored after closing with the throwing flush');
-
-    try {
-      ts.readable.read();
-      t.fail('read() didn\'nt throw');
-    } catch (error) {
-      t.equal(error, thrownError, 'readable\'s read should throw the thrown error');
-    }
   }, 0);
 
+  ts.readable.read().then(
+    () => t.fail('readable\'s read() should reject'),
+    r => t.equal(r, thrownError, 'readable\'s read should reject with the thrown error')
+  );
+
   ts.readable.closed.then(
     () => t.fail('readable\'s closed should not be fulfilled'),
     e => t.equal(e, thrownError, 'readable\'s closed should be rejected with the thrown error')
diff --git a/reference-implementation/test/transform-stream.js b/reference-implementation/test/transform-stream.js
index 004dfdc94..4a75bce8a 100644
--- a/reference-implementation/test/transform-stream.js
+++ b/reference-implementation/test/transform-stream.js
@@ -1,5 +1,7 @@
 const test = require('tape-catch');
 
+import readableStreamToArray from './utils/readable-stream-to-array';
+
 test('TransformStream can be constructed with a transform function', t => {
   t.plan(1);
   t.doesNotThrow(() => new TransformStream({ transform() { } }), 'TransformStream constructed with no errors');
@@ -27,11 +29,11 @@ test('TransformStream writables and readables start in the expected states', t =
   const ts = new TransformStream({ transform() { } });
 
   t.equal(ts.writable.state, 'writable', 'writable starts writable');
-  t.equal(ts.readable.state, 'waiting', 'readable starts waiting');
+  t.equal(ts.readable.state, 'readable', 'readable starts readable');
 });
 
 test('Pass-through sync TransformStream: can read from readable what is put into writable', t => {
-  t.plan(5);
+  t.plan(3);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -40,22 +42,20 @@ test('Pass-through sync TransformStream: can read from readable what is put into
     }
   });
 
-  setTimeout(() => {
-    ts.writable.write('a');
+  ts.writable.write('a');
 
-    t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
-    t.equal(ts.readable.state, 'readable', 'readable is readable since transformation is sync');
-    t.equal(ts.readable.read(), 'a', 'result from reading the readable is the same as was written to writable');
-    t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read all that was written');
-    ts.writable.ready.then(() => {
+  t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
+  ts.readable.read().then(chunk => {
+    t.equal(chunk, 'a', 'result from reading the readable is the same as was written to writable');
+    return ts.writable.ready.then(() => {
       t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
-    })
-    .catch(t.error);
-  }, 0);
+    });
+  })
+  .catch(e => t.error(e));
 });
 
 test('Uppercaser sync TransformStream: can read from readable transformed version of what is put into writable', t => {
-  t.plan(5);
+  t.plan(3);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -64,22 +64,21 @@ test('Uppercaser sync TransformStream: can read from readable transformed versio
     }
   });
 
-  setTimeout(() => {
-    ts.writable.write('a');
+  ts.writable.write('a');
+
+  t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
 
-    t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
-    t.equal(ts.readable.state, 'readable', 'readable is readable since transformation is sync');
-    t.equal(ts.readable.read(), 'A', 'result from reading the readable is the same as was written to writable');
-    t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read all that was written');
-    ts.writable.ready.then(() => {
+  ts.readable.read().then(chunk => {
+    t.equal(chunk, 'A', 'result from reading the readable is the transformation of what was written to writable');
+    return ts.writable.ready.then(() => {
       t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
-    })
-    .catch(t.error);
-  }, 0);
+    });
+  })
+  .catch(e => t.error(e));
 });
 
 test('Uppercaser-doubler sync TransformStream: can read both chunks put into the readable', t => {
-  t.plan(7);
+  t.plan(4);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -89,24 +88,26 @@ test('Uppercaser-doubler sync TransformStream: can read both chunks put into the
     }
   });
 
-  setTimeout(() => {
-    ts.writable.write('a');
-
-    t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
-    t.equal(ts.readable.state, 'readable', 'readable is readable after writing to writable');
-    t.equal(ts.readable.read(), 'A', 'the first chunk read is the transformation of the single chunk written');
-    t.equal(ts.readable.state, 'readable', 'readable is readable still after reading the first chunk');
-    t.equal(ts.readable.read(), 'A', 'the second chunk read is also the transformation of the single chunk written');
-    t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read both enqueued chunks');
-    ts.writable.ready.then(() => {
-      t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
-    })
-    .catch(t.error);
-  }, 0);
+  ts.writable.write('a');
+
+  t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
+
+  ts.readable.read().then(chunk1 => {
+    t.equal(chunk1, 'A', 'the first chunk read is the transformation of the single chunk written');
+
+    return ts.readable.read().then(chunk2 => {
+      t.equal(chunk2, 'A', 'the second chunk read is also the transformation of the single chunk written');
+
+      return ts.writable.ready.then(() => {
+        t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
+      });
+    });
+  })
+  .catch(e => t.error(e));
 });
 
-test('Uppercaser async TransformStream: readable chunk becomes available asynchronously', t => {
-  t.plan(7);
+test('Uppercaser async TransformStream: can read from readable transformed version of what is put into writable', t => {
+  t.plan(3);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -115,29 +116,21 @@ test('Uppercaser async TransformStream: readable chunk becomes available asynchr
     }
   });
 
-  setTimeout(() => {
-    ts.writable.write('a');
-
-    t.equal(ts.writable.state, 'waiting', 'writable is now waiting since the transform has not signaled done');
-    t.equal(ts.readable.state, 'waiting', 'readable is still not readable');
-
-    ts.readable.ready.then(() => {
-      t.equal(ts.readable.state, 'readable', 'readable eventually becomes readable');
-      t.equal(ts.readable.read(), 'A', 'chunk read from readable is the transformation result');
-      t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read the chunk');
+  ts.writable.write('a');
 
-      t.equal(ts.writable.state, 'waiting', 'writable is still waiting since the transform still has not signaled done');
+  t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
 
-      return ts.writable.ready.then(() => {
-        t.equal(ts.writable.state, 'writable', 'writable eventually becomes writable (after the transform signals done)');
-      });
-    })
-    .catch(t.error);
-  }, 0);
+  ts.readable.read().then(chunk => {
+    t.equal(chunk, 'A', 'result from reading the readable is the transformation of what was written to writable');
+    return ts.writable.ready.then(() => {
+      t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
+    });
+  })
+  .catch(e => t.error(e));
 });
 
-test('Uppercaser-doubler async TransformStream: readable chunks becomes available asynchronously', t => {
-  t.plan(11);
+test('Uppercaser-doubler async TransformStream: can read both chunks put into the readable', t => {
+  t.plan(4);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -147,33 +140,21 @@ test('Uppercaser-doubler async TransformStream: readable chunks becomes availabl
     }
   });
 
-  setTimeout(() => {
-    ts.writable.write('a');
-
-    t.equal(ts.writable.state, 'waiting', 'writable is now waiting since the transform has not signaled done');
-    t.equal(ts.readable.state, 'waiting', 'readable is still not readable');
-
-    ts.readable.ready.then(() => {
-      t.equal(ts.readable.state, 'readable', 'readable eventually becomes readable');
-      t.equal(ts.readable.read(), 'A', 'chunk read from readable is the transformation result');
-      t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read the chunk');
-
-      t.equal(ts.writable.state, 'waiting', 'writable is still waiting since the transform still has not signaled done');
+  ts.writable.write('a');
 
-      return ts.readable.ready.then(() => {
-        t.equal(ts.readable.state, 'readable', 'readable becomes readable again');
-        t.equal(ts.readable.read(), 'A', 'chunk read from readable is the transformation result');
-        t.equal(ts.readable.state, 'waiting', 'readable is waiting again after having read the chunk');
+  t.equal(ts.writable.state, 'waiting', 'writable is waiting after one write');
+  ts.readable.read().then(chunk1 => {
+    t.equal(chunk1, 'A', 'the first chunk read is the transformation of the single chunk written');
 
-        t.equal(ts.writable.state, 'waiting', 'writable is still waiting since the transform still has not signaled done');
+    return ts.readable.read().then(chunk2 => {
+      t.equal(chunk2, 'A', 'the second chunk read is also the transformation of the single chunk written');
 
-        return ts.writable.ready.then(() => {
-          t.equal(ts.writable.state, 'writable', 'writable eventually becomes writable (after the transform signals done)');
-        });
+      return ts.writable.ready.then(() => {
+        t.equal(ts.writable.state, 'writable', 'writable becomes writable again');
       });
-    })
-    .catch(t.error);
-  }, 0);
+    });
+  })
+  .catch(e => t.error(e));
 });
 
 test('TransformStream: by default, closing the writable closes the readable (when there are no queued writes)', t => {
@@ -207,7 +188,7 @@ test('TransformStream: by default, closing the writable waits for transforms to
   ts.writable.close();
   t.equal(ts.writable.state, 'closing', 'writable is closing');
   setTimeout(() => {
-    t.equal(ts.readable.state, 'waiting', 'readable is still waiting after a tick');
+    t.equal(ts.readable.state, 'readable', 'readable is still readable after a tick');
 
     ts.writable.closed.then(() => {
       t.equal(ts.writable.state, 'closed', 'writable becomes closed eventually');
@@ -218,7 +199,7 @@ test('TransformStream: by default, closing the writable waits for transforms to
 });
 
 test('TransformStream: by default, closing the writable closes the readable after sync enqueues and async done', t => {
-  t.plan(7);
+  t.plan(6);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -231,24 +212,23 @@ test('TransformStream: by default, closing the writable closes the readable afte
   ts.writable.write('a');
   ts.writable.close();
   t.equal(ts.writable.state, 'closing', 'writable is closing');
-  setTimeout(() => {
-    t.equal(ts.readable.state, 'readable', 'readable is readable');
+  t.equal(ts.readable.state, 'readable', 'readable is readable');
 
-    ts.writable.closed.then(() => {
-      t.equal(ts.writable.state, 'closed', 'writable becomes closed eventually');
-      t.equal(ts.readable.state, 'readable', 'readable is still readable at that time');
+  ts.writable.closed.then(() => {
+    t.equal(ts.writable.state, 'closed', 'writable becomes closed eventually');
+    t.equal(ts.readable.state, 'readable', 'readable is still readable at that time');
 
-      t.equal(ts.readable.read(), 'x', 'can read the first enqueued chunk from the readable');
-      t.equal(ts.readable.read(), 'y', 'can read the second enqueued chunk from the readable');
+    return readableStreamToArray(ts.readable).then(chunks => {
+      t.deepEquals(chunks, ['x', 'y'], 'both enqueued chunks can be read from the readable');
 
       t.equal(ts.readable.state, 'closed', 'after reading, the readable is now closed');
-    })
-    .catch(t.error);
-  }, 0);
+    });
+  })
+  .catch(t.error);
 });
 
 test('TransformStream: by default, closing the writable closes the readable after async enqueues and async done', t => {
-  t.plan(8);
+  t.plan(6);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -261,19 +241,19 @@ test('TransformStream: by default, closing the writable closes the readable afte
   ts.writable.write('a');
   ts.writable.close();
   t.equal(ts.writable.state, 'closing', 'writable is closing');
-  setTimeout(() => {
-    t.equal(ts.readable.state, 'waiting', 'readable starts waiting');
+  t.equal(ts.readable.state, 'readable', 'readable is readable');
 
-    ts.writable.closed.then(() => {
-      t.equal(ts.writable.state, 'closed', 'writable becomes closed eventually');
-      t.equal(ts.readable.state, 'readable', 'readable is now readable since all chunks have been enqueued');
-      t.equal(ts.readable.read(), 'x', 'can read the first enqueued chunk from the readable');
-      t.equal(ts.readable.state, 'readable', 'after reading one chunk, the readable is still readable');
-      t.equal(ts.readable.read(), 'y', 'can read the second enqueued chunk from the readable');
-      t.equal(ts.readable.state, 'closed', 'after reading two chunks, the readable is now closed');
-    })
-    .catch(t.error);
-  }, 0);
+  ts.writable.closed.then(() => {
+    t.equal(ts.writable.state, 'closed', 'writable becomes closed eventually');
+    t.equal(ts.readable.state, 'readable', 'readable is still readable at that time');
+
+    return readableStreamToArray(ts.readable).then(chunks => {
+      t.deepEquals(chunks, ['x', 'y'], 'both enqueued chunks can be read from the readable');
+
+      t.equal(ts.readable.state, 'closed', 'after reading, the readable is now closed');
+    });
+  })
+  .catch(t.error);
 });
 
 test('TransformStream flush is called immediately when the writable is closed, if no writes are queued', t => {
@@ -287,10 +267,9 @@ test('TransformStream flush is called immediately when the writable is closed, i
     }
   });
 
-  setTimeout(() => {
-    ts.writable.close();
+  ts.writable.close().then(() => {
     t.ok(flushCalled, 'closing the writable triggers the transform flush immediately');
-  }, 0);
+  });
 });
 
 test('TransformStream flush is called after all queued writes finish, once the writable is closed', t => {
@@ -306,20 +285,18 @@ test('TransformStream flush is called after all queued writes finish, once the w
     }
   });
 
+  ts.writable.write('a');
+  ts.writable.close();
+  t.notOk(flushCalled, 'closing the writable does not immediately call flush if writes are not finished');
+
   setTimeout(() => {
-    ts.writable.write('a');
-    ts.writable.close();
-    t.notOk(flushCalled, 'closing the writable does not immediately call flush if writes are not finished');
-
-    setTimeout(() => {
-      t.ok(flushCalled, 'flush is eventually called');
-      t.equal(ts.readable.state, 'waiting', 'if flush does not call close, the readable stays open');
-    }, 50);
-  }, 0);
+    t.ok(flushCalled, 'flush is eventually called');
+    t.equal(ts.readable.state, 'readable', 'if flush does not call close, the readable stays readable');
+  }, 50);
 });
 
 test('TransformStream flush gets a chance to enqueue more into the readable', t => {
-  t.plan(6);
+  t.plan(2);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -331,23 +308,20 @@ test('TransformStream flush gets a chance to enqueue more into the readable', t
     }
   });
 
-  setTimeout(() => {
-    t.equal(ts.readable.state, 'waiting', 'before doing anything, the readable is waiting');
-    ts.writable.write('a');
-    t.equal(ts.readable.state, 'waiting', 'after a write to the writable, the readable is still waiting');
-    ts.writable.close();
-    ts.readable.ready.then(() => {
-      t.equal(ts.readable.state, 'readable', 'after closing the writable, the readable is now readable as a result of flush');
-      t.equal(ts.readable.read(), 'x', 'reading the first chunk gives back what was enqueued');
-      t.equal(ts.readable.read(), 'y', 'reading the second chunk gives back what was enqueued');
-      t.equal(ts.readable.state, 'waiting', 'after reading both chunks, the readable is waiting, since close was not called');
-    })
-    .catch(t.error);
-  }, 0);
+  ts.writable.write('a');
+  ts.writable.close();
+  ts.readable.read().then(chunk1 => {
+    t.equal(chunk1, 'x', 'the first chunk read is the transformation of the single chunk written');
+
+    return ts.readable.read().then(chunk2 => {
+      t.equal(chunk2, 'y', 'the second chunk read is also the transformation of the single chunk written');
+    });
+  })
+  .catch(t.error);
 });
 
 test('TransformStream flush gets a chance to enqueue more into the readable, and can then async close', t => {
-  t.plan(7);
+  t.plan(3);
 
   const ts = new TransformStream({
     transform(chunk, enqueue, done) {
@@ -360,22 +334,19 @@ test('TransformStream flush gets a chance to enqueue more into the readable, and
     }
   });
 
-  setTimeout(() => {
-    t.equal(ts.readable.state, 'waiting', 'before doing anything, the readable is waiting');
-    ts.writable.write('a');
-    t.equal(ts.readable.state, 'waiting', 'after a write to the writable, the readable is still waiting');
-    ts.writable.close();
-    ts.readable.ready.then(() => {
-      t.equal(ts.readable.state, 'readable', 'after closing the writable, the readable is now readable as a result of flush');
-      t.equal(ts.readable.read(), 'x', 'reading the first chunk gives back what was enqueued');
-      t.equal(ts.readable.read(), 'y', 'reading the second chunk gives back what was enqueued');
-      t.equal(ts.readable.state, 'waiting', 'after reading both chunks, the readable is waiting, since close was not called');
-    })
-    .catch(t.error);
-
-    ts.readable.closed.then(() => {
-      t.equal(ts.readable.state, 'closed', 'the readable eventually does close, after close is called from flush');
-    })
-    .catch(t.error);
-  }, 0);
+  ts.writable.write('a');
+  ts.writable.close();
+  ts.readable.read().then(chunk1 => {
+    t.equal(chunk1, 'x', 'the first chunk read is the transformation of the single chunk written');
+
+    return ts.readable.read().then(chunk2 => {
+      t.equal(chunk2, 'y', 'the second chunk read is also the transformation of the single chunk written');
+    });
+  })
+  .catch(t.error);
+
+  ts.readable.closed.then(() => {
+    t.equal(ts.readable.state, 'closed', 'the readable eventually does close, after close is called from flush');
+  })
+  .catch(t.error);
 });
diff --git a/reference-implementation/test/utils/random-push-source.js b/reference-implementation/test/utils/random-push-source.js
index 4ff21d437..43039a594 100644
--- a/reference-implementation/test/utils/random-push-source.js
+++ b/reference-implementation/test/utils/random-push-source.js
@@ -24,24 +24,23 @@ export default class RandomPushSource {
       this.paused = false;
     }
 
-    const stream = this;
+    const source = this;
     function writeChunk() {
-      if (stream.paused) {
+      if (source.paused) {
         return;
       }
 
-      stream.pushed++;
+      source.pushed++;
 
-      if (stream.toPush > 0 && stream.pushed > stream.toPush) {
-        if (stream._intervalHandle) {
-          clearInterval(stream._intervalHandle);
-          stream._intervalHandle = undefined;
+      if (source.toPush > 0 && source.pushed > source.toPush) {
+        if (source._intervalHandle) {
+          clearInterval(source._intervalHandle);
+          source._intervalHandle = undefined;
         }
-        stream.closed = true;
-        stream.onend();
-      }
-      else {
-        stream.ondata(randomChunk(128));
+        source.closed = true;
+        source.onend();
+      } else {
+        source.ondata(randomChunk(128));
       }
     }
   }
diff --git a/reference-implementation/test/utils/readable-stream-to-array.js b/reference-implementation/test/utils/readable-stream-to-array.js
index b77fb9397..d8eba913c 100644
--- a/reference-implementation/test/utils/readable-stream-to-array.js
+++ b/reference-implementation/test/utils/readable-stream-to-array.js
@@ -1,18 +1,16 @@
 export default function readableStreamToArray(readable) {
   const chunks = [];
 
-  pump();
-  return readable.closed.then(() => chunks);
+  return pump();
 
   function pump() {
-    while (readable.state === "readable") {
-      chunks.push(readable.read());
-    }
+    return readable.read().then(chunk => {
+      if (chunk === ReadableStream.EOS) {
+        return chunks;
+      }
 
-    if (readable.state === "waiting") {
-      readable.ready.then(pump);
-    }
-
-    // Otherwise the stream is "closed" or "errored", which will be handled above.
+      chunks.push(chunk);
+      return pump();
+    });
   }
 }