Make testharness.js tests fail on uncaught exceptions

third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/templated-expected.txt

Index: third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/templated-expected.txt
diff --git a/third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/templated-expected.txt b/third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/templated-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0955281a7c2ec5a907ffe07935f6c167331b3533
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/templated-expected.txt
@@ -0,0 +1,376 @@
+CONSOLE ERROR: line 300: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 59: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 62: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 59: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 62: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 300: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 59: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 62: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 59: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 62: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 271: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 121: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 356: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 356: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 571: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 586: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 609: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 271: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 121: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 356: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 228: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 356: Uncaught (in promise) #<Object>
+CONSOLE ERROR: line 571: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 586: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+CONSOLE ERROR: line 609: Uncaught (in promise) TypeError: This readable stream reader has been released and cannot be used to monitor the stream's state
+This is a testharness.js-based test.
+PASS Running templatedRSEmpty with ReadableStream (empty) 
+PASS instances have the correct methods and properties 
+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 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 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 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.
+