This is a testharness.js-based test.
Harness Error. harness_status.status = 1 , harness_status.message = 17 duplicate test names: "instances have the correct methods and properties", "cancel() should return a distinct fulfilled promise each time", "read() should fulfill with { value: undefined, done: true }", "read() multiple times should fulfill with { value: undefined, done: true }", "read() should work when used within another read() fulfill callback", "closed should fulfill with undefined", "releasing the lock should cause closed to reject and change identity", "locked should be false", "getReader() should be OK", "should be able to acquire multiple readers if they are released in succession", "should not be able to acquire a second reader if we don't release the first one", "getReader() should return a reader that acts errored", "read() twice should give the error each time", "closed should reject with the error", "read() should reject with the error", "read() should return distinct promises each time", "releasing the lock should cause further read() calls to reject with a TypeError"
PASS Running templatedRSEmpty with ReadableStream (empty) 
PASS instances have the correct methods and properties 
PASS calling getReader with invalid arguments should throw appropriate errors 
PASS Running templatedRSEmptyReader with ReadableStream (empty) reader 
PASS instances have the correct methods and properties 
PASS locked should be true 
PASS read() should never settle 
PASS two read()s should both never settle 
PASS read() should return distinct promises each time 
PASS getReader() again on the stream should fail 
PASS releasing the lock with pending read requests should throw but the read requests should stay pending 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS releasing the lock should cause closed calls to reject with a TypeError 
PASS releasing the lock should cause locked to become false 
PASS canceling via the reader should cause the reader to act closed 
PASS canceling via the stream should fail 
PASS Running templatedRSClosed with ReadableStream (closed via call in start) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed before getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosedReader with ReadableStream reader (closed after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosed with ReadableStream (closed via cancel) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via call in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start) 
PASS should be able to obtain a second reader, with the correct closed promise 
PASS should not be able to obtain additional readers if we don't release the first lock 
PASS cancel() should return a distinct rejected promise each time 
PASS reader cancel() should return a distinct rejected promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored before getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored after getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader 
PASS calling read() twice without waiting will eventually give both chunks (sequential) 
PASS calling read() twice without waiting will eventually give both chunks (nested) 
PASS read() should return distinct promises each time 
PASS cancel() after a read() should still give that single read result 
PASS Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader 
PASS third read(), without waiting, should give { value: undefined, done: true } (sequential) 
PASS third read(), without waiting, should give { value: undefined, done: true } (nested) 
PASS draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true 
PASS releasing the lock after the stream is closed should cause locked to become false 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS reader's closed property always returns the same promise 
PASS Untitled 
PASS Running templatedRSEmpty with ReadableStream (empty) 
PASS instances have the correct methods and properties 
PASS calling getReader with invalid arguments should throw appropriate errors 
PASS Running templatedRSEmptyReader with ReadableStream (empty) reader 
PASS instances have the correct methods and properties 
PASS locked should be true 
PASS read() should never settle 
PASS two read()s should both never settle 
PASS read() should return distinct promises each time 
PASS getReader() again on the stream should fail 
PASS releasing the lock with pending read requests should throw but the read requests should stay pending 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS releasing the lock should cause closed calls to reject with a TypeError 
PASS releasing the lock should cause locked to become false 
PASS canceling via the reader should cause the reader to act closed 
PASS canceling via the stream should fail 
PASS Running templatedRSClosed with ReadableStream (closed via call in start) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed before getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosedReader with ReadableStream reader (closed after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosed with ReadableStream (closed via cancel) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via call in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start) 
PASS should be able to obtain a second reader, with the correct closed promise 
PASS should not be able to obtain additional readers if we don't release the first lock 
PASS cancel() should return a distinct rejected promise each time 
PASS reader cancel() should return a distinct rejected promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored before getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored after getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader 
PASS calling read() twice without waiting will eventually give both chunks (sequential) 
PASS calling read() twice without waiting will eventually give both chunks (nested) 
PASS read() should return distinct promises each time 
PASS cancel() after a read() should still give that single read result 
PASS Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader 
PASS third read(), without waiting, should give { value: undefined, done: true } (sequential) 
PASS third read(), without waiting, should give { value: undefined, done: true } (nested) 
PASS draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true 
PASS releasing the lock after the stream is closed should cause locked to become false 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS reader's closed property always returns the same promise 
PASS Running templatedRSEmpty with ReadableStream (empty) 
PASS instances have the correct methods and properties 
PASS calling getReader with invalid arguments should throw appropriate errors 
PASS Running templatedRSEmptyReader with ReadableStream (empty) reader 
PASS instances have the correct methods and properties 
PASS locked should be true 
PASS read() should never settle 
PASS two read()s should both never settle 
PASS read() should return distinct promises each time 
PASS getReader() again on the stream should fail 
PASS releasing the lock with pending read requests should throw but the read requests should stay pending 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS releasing the lock should cause closed calls to reject with a TypeError 
PASS releasing the lock should cause locked to become false 
PASS canceling via the reader should cause the reader to act closed 
PASS canceling via the stream should fail 
PASS Running templatedRSClosed with ReadableStream (closed via call in start) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed before getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosedReader with ReadableStream reader (closed after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosed with ReadableStream (closed via cancel) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via call in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start) 
PASS should be able to obtain a second reader, with the correct closed promise 
PASS should not be able to obtain additional readers if we don't release the first lock 
PASS cancel() should return a distinct rejected promise each time 
PASS reader cancel() should return a distinct rejected promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored before getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored after getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader 
PASS calling read() twice without waiting will eventually give both chunks (sequential) 
PASS calling read() twice without waiting will eventually give both chunks (nested) 
PASS read() should return distinct promises each time 
PASS cancel() after a read() should still give that single read result 
PASS Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader 
PASS third read(), without waiting, should give { value: undefined, done: true } (sequential) 
PASS third read(), without waiting, should give { value: undefined, done: true } (nested) 
PASS draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true 
PASS releasing the lock after the stream is closed should cause locked to become false 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS reader's closed property always returns the same promise 
PASS Running templatedRSEmpty with ReadableStream (empty) 
PASS instances have the correct methods and properties 
PASS calling getReader with invalid arguments should throw appropriate errors 
PASS Running templatedRSEmptyReader with ReadableStream (empty) reader 
PASS instances have the correct methods and properties 
PASS locked should be true 
PASS read() should never settle 
PASS two read()s should both never settle 
PASS read() should return distinct promises each time 
PASS getReader() again on the stream should fail 
PASS releasing the lock with pending read requests should throw but the read requests should stay pending 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS releasing the lock should cause closed calls to reject with a TypeError 
PASS releasing the lock should cause locked to become false 
PASS canceling via the reader should cause the reader to act closed 
PASS canceling via the stream should fail 
PASS Running templatedRSClosed with ReadableStream (closed via call in start) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed before getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosedReader with ReadableStream reader (closed after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSClosed with ReadableStream (closed via cancel) 
PASS cancel() should return a distinct fulfilled promise each time 
PASS locked should be false 
PASS getReader() should be OK 
PASS should be able to acquire multiple readers if they are released in succession 
PASS should not be able to acquire a second reader if we don't release the first one 
PASS Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader) 
PASS read() should fulfill with { value: undefined, done: true } 
PASS read() multiple times should fulfill with { value: undefined, done: true } 
PASS read() should work when used within another read() fulfill callback 
PASS closed should fulfill with undefined 
PASS releasing the lock should cause closed to reject and change identity 
PASS cancel() should return a distinct fulfilled promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via call in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start) 
PASS should be able to obtain a second reader, with the correct closed promise 
PASS should not be able to obtain additional readers if we don't release the first lock 
PASS cancel() should return a distinct rejected promise each time 
PASS reader cancel() should return a distinct rejected promise each time 
PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start) 
PASS getReader() should return a reader that acts errored 
PASS read() twice should give the error each time 
PASS locked should be false 
PASS Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored before getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSErroredReader with ReadableStream reader (errored after getting reader) 
PASS closed should reject with the error 
PASS releasing the lock should cause closed to reject and change identity 
PASS read() should reject with the error 
PASS Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader 
PASS calling read() twice without waiting will eventually give both chunks (sequential) 
PASS calling read() twice without waiting will eventually give both chunks (nested) 
PASS read() should return distinct promises each time 
PASS cancel() after a read() should still give that single read result 
PASS Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader 
PASS third read(), without waiting, should give { value: undefined, done: true } (sequential) 
PASS third read(), without waiting, should give { value: undefined, done: true } (nested) 
PASS draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true 
PASS releasing the lock after the stream is closed should cause locked to become false 
PASS releasing the lock should cause further read() calls to reject with a TypeError 
PASS reader's closed property always returns the same promise 
Harness: the test ran to completion.

