[templated.serviceworker.https.html]
  type: testharness
  [instances have the correct methods and properties]
    expected: FAIL

  [calling getReader with invalid arguments should throw appropriate errors]
    expected: FAIL

  [locked should be true]
    expected: FAIL

  [read() should never settle]
    expected: FAIL

  [two read()s should both never settle]
    expected: FAIL

  [read() should return distinct promises each time]
    expected: FAIL

  [getReader() again on the stream should fail]
    expected: FAIL

  [releasing the lock with pending read requests should throw but the read requests should stay pending]
    expected: FAIL

  [releasing the lock should cause further read() calls to reject with a TypeError]
    expected: FAIL

  [releasing the lock should cause closed calls to reject with a TypeError]
    expected: FAIL

  [releasing the lock should cause locked to become false]
    expected: FAIL

  [canceling via the reader should cause the reader to act closed]
    expected: FAIL

  [canceling via the stream should fail]
    expected: FAIL

  [cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [locked should be false]
    expected: FAIL

  [getReader() should be OK]
    expected: FAIL

  [should be able to acquire multiple readers if they are released in succession]
    expected: FAIL

  [should not be able to acquire a second reader if we don't release the first one]
    expected: FAIL

  [read() should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [read() multiple times should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [read() should work when used within another read() fulfill callback]
    expected: FAIL

  [closed should fulfill with undefined]
    expected: FAIL

  [releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [getReader() should return a reader that acts errored]
    expected: FAIL

  [read() twice should give the error each time]
    expected: FAIL

  [should be able to obtain a second reader, with the correct closed promise]
    expected: FAIL

  [should not be able to obtain additional readers if we don't release the first lock]
    expected: FAIL

  [cancel() should return a distinct rejected promise each time]
    expected: FAIL

  [reader cancel() should return a distinct rejected promise each time]
    expected: FAIL

  [closed should reject with the error]
    expected: FAIL

  [read() should reject with the error]
    expected: FAIL

  [calling read() twice without waiting will eventually give both chunks (sequential)]
    expected: FAIL

  [calling read() twice without waiting will eventually give both chunks (nested)]
    expected: FAIL

  [cancel() after a read() should still give that single read result]
    expected: FAIL

  [third read(), without waiting, should give { value: undefined, done: true } (sequential)]
    expected: FAIL

  [third read(), without waiting, should give { value: undefined, done: true } (nested)]
    expected: FAIL

  [draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true]
    expected: FAIL

  [releasing the lock after the stream is closed should cause locked to become false]
    expected: FAIL

  [reader's closed property always returns the same promise]
    expected: FAIL

  [ReadableStream (empty): instances have the correct methods and properties]
    expected: FAIL

  [ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors]
    expected: FAIL

  [ReadableStream (empty) reader: instances have the correct methods and properties]
    expected: FAIL

  [ReadableStream (empty) reader: locked should be true]
    expected: FAIL

  [ReadableStream (empty) reader: read() should never settle]
    expected: FAIL

  [ReadableStream (empty) reader: two read()s should both never settle]
    expected: FAIL

  [ReadableStream (empty) reader: read() should return distinct promises each time]
    expected: FAIL

  [ReadableStream (empty) reader: getReader() again on the stream should fail]
    expected: FAIL

  [ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending]
    expected: FAIL

  [ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError]
    expected: FAIL

  [ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError]
    expected: FAIL

  [ReadableStream (empty) reader: releasing the lock should cause locked to become false]
    expected: FAIL

  [ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed]
    expected: FAIL

  [ReadableStream (empty) reader: canceling via the stream should fail]
    expected: FAIL

  [ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [ReadableStream (closed via call in start): locked should be false]
    expected: FAIL

  [ReadableStream (closed via call in start): getReader() should be OK]
    expected: FAIL

  [ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession]
    expected: FAIL

  [ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): read() should work when used within another read() fulfill callback]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): closed should fulfill with undefined]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): read() multiple times should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): closed should fulfill with undefined]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [ReadableStream (closed via cancel): locked should be false]
    expected: FAIL

  [ReadableStream (closed via cancel): getReader() should be OK]
    expected: FAIL

  [ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession]
    expected: FAIL

  [ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time]
    expected: FAIL

  [ReadableStream (errored via call in start): getReader() should return a reader that acts errored]
    expected: FAIL

  [ReadableStream (errored via call in start): read() twice should give the error each time]
    expected: FAIL

  [ReadableStream (errored via call in start): locked should be false]
    expected: FAIL

  [ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise]
    expected: FAIL

  [ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock]
    expected: FAIL

  [ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time]
    expected: FAIL

  [ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start): locked should be false]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error]
    expected: FAIL

  [ReadableStream reader (errored before getting reader): closed should reject with the error]
    expected: FAIL

  [ReadableStream reader (errored before getting reader): releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream reader (errored before getting reader): read() should reject with the error]
    expected: FAIL

  [ReadableStream reader (errored after getting reader): closed should reject with the error]
    expected: FAIL

  [ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity]
    expected: FAIL

  [ReadableStream reader (errored after getting reader): read() should reject with the error]
    expected: FAIL

  [ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)]
    expected: FAIL

  [ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)]
    expected: FAIL

  [ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time]
    expected: FAIL

  [ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError]
    expected: FAIL

  [ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise]
    expected: FAIL

