Re: [streams-tests] Rename ReadableStreamReader to ReadableStreamDefaultReader (#5019)

 [View the complete job log.](https://travis-ci.org/w3c/web-platform-tests/jobs/205717088)

# Chrome (unstable channel) #
Testing web-platform-tests at revision dcc8fc38397339ea2ec65b870cae4240ac494a31
Using browser at version 58.0.3018.3 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>12 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/garbage-collection.sharedworker.html">/streams/readable-streams/garbage-collection.sharedworker.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | PASS    |
| `Garbage-collecting a ReadableStreamDefaultReader should not unlock its stream`                                              | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/brand-checks.sharedworker.html">/streams/readable-streams/brand-checks.sharedworker.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `ReadableStreamDefaultReader enforces a brand check on its argument`         | PASS    |
| `ReadableStreamDefaultReader.prototype.cancel enforces a brand check`        | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamDefaultReader.prototype.closed enforces a brand check`        | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamDefaultReader.prototype.read enforces a brand check`          | PASS    |
| `ReadableStreamDefaultReader.prototype.releaseLock enforces a brand check`   | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`             | PASS    |
| `ReadableStreamController.prototype.close enforces a brand check`            | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/5019/streams/readable-streams/brand-checks.serviceworker.https.html">/streams/readable-streams/brand-checks.serviceworker.https.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `ReadableStreamDefaultReader enforces a brand check on its argument`         | PASS    |
| `ReadableStreamDefaultReader.prototype.cancel enforces a brand check`        | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamDefaultReader.prototype.closed enforces a brand check`        | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamDefaultReader.prototype.read enforces a brand check`          | PASS    |
| `ReadableStreamDefaultReader.prototype.releaseLock enforces a brand check`   | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `Service worker test setup`                                                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`             | PASS    |
| `ReadableStreamController.prototype.close enforces a brand check`            | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/default-reader.html">/streams/readable-streams/default-reader.html</a></summary>


|                                                           Subtest                                                           | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | OK      |
| `ReadableStreamDefaultReader instances should have the correct list of properties`                                          | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Reading twice on a stream that gets errored`                                                                               | PASS    |
| `Reading twice on a closed stream`                                                                                          | PASS    |
| `Multiple readers can access the stream in sequence`                                                                        | PASS    |
| `cancel() on a reader does not release the reader`                                                                          | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is errored`                                 | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                                 | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamDefaultReader closed promise`                  | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamDefaultReader closed promise`                 | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `ReadableStreamDefaultReader closed should always return the same promise object`                                           | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                          | PASS    |
| `Cannot use an already-released reader to unlock a stream again`                                                            | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                       | PASS    |
| `ReadableStreamDefaultReader constructor should get a ReadableStream object as argument`                                    | PASS    |
| `ReadableStreamDefaultReader: if start rejects with no parameter, it should error the stream with an undefined error`       | PASS    |
| `Reading twice on a stream that gets closed`                                                                                | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamDefaultReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                            | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is closed`                                  | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                        | PASS    |
| `Reading twice on an errored stream`                                                                                        | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/default-reader.sharedworker.html">/streams/readable-streams/default-reader.sharedworker.html</a></summary>


|                                                           Subtest                                                           | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | OK      |
| `ReadableStreamDefaultReader instances should have the correct list of properties`                                          | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Reading twice on a stream that gets errored`                                                                               | PASS    |
| `Reading twice on a closed stream`                                                                                          | PASS    |
| `Multiple readers can access the stream in sequence`                                                                        | PASS    |
| `cancel() on a reader does not release the reader`                                                                          | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is errored`                                 | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                                 | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamDefaultReader closed promise`                  | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamDefaultReader closed promise`                 | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `ReadableStreamDefaultReader closed should always return the same promise object`                                           | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                          | PASS    |
| `Cannot use an already-released reader to unlock a stream again`                                                            | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                       | PASS    |
| `ReadableStreamDefaultReader constructor should get a ReadableStream object as argument`                                    | PASS    |
| `ReadableStreamDefaultReader: if start rejects with no parameter, it should error the stream with an undefined error`       | PASS    |
| `Reading twice on a stream that gets closed`                                                                                | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamDefaultReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                            | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is closed`                                  | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                        | PASS    |
| `Reading twice on an errored stream`                                                                                        | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/brand-checks.dedicatedworker.html">/streams/readable-streams/brand-checks.dedicatedworker.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `ReadableStreamDefaultReader enforces a brand check on its argument`         | PASS    |
| `ReadableStreamDefaultReader.prototype.cancel enforces a brand check`        | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamDefaultReader.prototype.closed enforces a brand check`        | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamDefaultReader.prototype.read enforces a brand check`          | PASS    |
| `ReadableStreamDefaultReader.prototype.releaseLock enforces a brand check`   | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`             | PASS    |
| `ReadableStreamController.prototype.close enforces a brand check`            | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/5019/streams/readable-streams/default-reader.serviceworker.https.html">/streams/readable-streams/default-reader.serviceworker.https.html</a></summary>


|                                                           Subtest                                                           | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | OK      |
| `ReadableStreamDefaultReader instances should have the correct list of properties`                                          | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Service worker test setup`                                                                                                 | PASS    |
| `Reading twice on a closed stream`                                                                                          | PASS    |
| `Multiple readers can access the stream in sequence`                                                                        | PASS    |
| `cancel() on a reader does not release the reader`                                                                          | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is errored`                                 | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                                 | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamDefaultReader closed promise`                  | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamDefaultReader closed promise`                 | PASS    |
| `Reading twice on a stream that gets errored`                                                                               | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `ReadableStreamDefaultReader closed should always return the same promise object`                                           | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                          | PASS    |
| `Cannot use an already-released reader to unlock a stream again`                                                            | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                       | PASS    |
| `ReadableStreamDefaultReader constructor should get a ReadableStream object as argument`                                    | PASS    |
| `ReadableStreamDefaultReader: if start rejects with no parameter, it should error the stream with an undefined error`       | PASS    |
| `Reading twice on a stream that gets closed`                                                                                | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamDefaultReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                            | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is closed`                                  | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                        | PASS    |
| `Reading twice on an errored stream`                                                                                        | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/garbage-collection.dedicatedworker.html">/streams/readable-streams/garbage-collection.dedicatedworker.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | PASS    |
| `Garbage-collecting a ReadableStreamDefaultReader should not unlock its stream`                                              | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/garbage-collection.html">/streams/readable-streams/garbage-collection.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | PASS    |
| `Garbage-collecting a ReadableStreamDefaultReader should not unlock its stream`                                              | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/brand-checks.html">/streams/readable-streams/brand-checks.html</a></summary>


|                                   Subtest                                    | Results |
|------------------------------------------------------------------------------|---------|
|                                                                              | OK      |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `ReadableStreamDefaultReader enforces a brand check on its argument`         | PASS    |
| `ReadableStreamDefaultReader.prototype.cancel enforces a brand check`        | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamDefaultReader.prototype.closed enforces a brand check`        | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamDefaultReader.prototype.read enforces a brand check`          | PASS    |
| `ReadableStreamDefaultReader.prototype.releaseLock enforces a brand check`   | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`             | PASS    |
| `ReadableStreamController.prototype.close enforces a brand check`            | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5019/streams/readable-streams/default-reader.dedicatedworker.html">/streams/readable-streams/default-reader.dedicatedworker.html</a></summary>


|                                                           Subtest                                                           | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | OK      |
| `ReadableStreamDefaultReader instances should have the correct list of properties`                                          | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Reading twice on a stream that gets errored`                                                                               | PASS    |
| `Reading twice on a closed stream`                                                                                          | PASS    |
| `Multiple readers can access the stream in sequence`                                                                        | PASS    |
| `cancel() on a reader does not release the reader`                                                                          | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is errored`                                 | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                                 | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamDefaultReader closed promise`                  | PASS    |
| `Getting a ReadableStreamDefaultReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamDefaultReader closed promise`                 | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `ReadableStreamDefaultReader closed should always return the same promise object`                                           | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                          | PASS    |
| `Cannot use an already-released reader to unlock a stream again`                                                            | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                       | PASS    |
| `ReadableStreamDefaultReader constructor should get a ReadableStream object as argument`                                    | PASS    |
| `ReadableStreamDefaultReader: if start rejects with no parameter, it should error the stream with an undefined error`       | PASS    |
| `Reading twice on a stream that gets closed`                                                                                | PASS    |
| `Can get the ReadableStreamDefaultReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamDefaultReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                            | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should be OK if the stream is closed`                                  | PASS    |
| `Constructing a ReadableStreamDefaultReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                        | PASS    |
| `Reading twice on an errored stream`                                                                                        | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/5019/streams/readable-streams/garbage-collection.serviceworker.https.html">/streams/readable-streams/garbage-collection.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `Garbage-collecting a ReadableStreamDefaultReader should not unlock its stream`                                              | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</details>
</details>

View on GitHub: https://github.com/w3c/web-platform-tests/pull/5019#issuecomment-282656158

Received on Monday, 27 February 2017 08:24:47 UTC