Add m-esr52 at 52.6.0

1 files changed, 633 insertions, 0 deletions

diff --git a/testing/web-platform/meta/streams/readable-streams/templated.https.html.ini b/testing/web-platform/meta/streams/readable-streams/templated.https.html.ini
new file mode 100644
index 000000000..7b885ca93
--- /dev/null
+++ b/testing/web-platform/meta/streams/readable-streams/templated.https.html.ini
@@ -0,0 +1,633 @@
+[templated.https.html]
+  type: testharness
+  disabled: @True
+  [instances have the correct methods and properties]
+    expected: FAIL
+
+  [instances have the correct methods and properties]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    expected: FAIL
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    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
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    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
+
+  [read() should return distinct promises each time]
+    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
+
+  [releasing the lock should cause further read() calls to reject with a TypeError]
+    expected: FAIL
+
+  [reader's closed property always returns the same promise]
+    expected: FAIL
+
+  [instances have the correct methods and properties]
+    expected: FAIL
+
+  [instances have the correct methods and properties]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    expected: FAIL
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    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
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    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
+
+  [read() should return distinct promises each time]
+    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
+
+  [releasing the lock should cause further read() calls to reject with a TypeError]
+    expected: FAIL
+
+  [reader's closed property always returns the same promise]
+    expected: FAIL
+
+  [instances have the correct methods and properties]
+    expected: FAIL
+
+  [instances have the correct methods and properties]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    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
+
+  [cancel() should return a distinct fulfilled promise each time]
+    expected: FAIL
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    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
+
+  [getReader() should return a reader that acts errored]
+    expected: FAIL
+
+  [read() twice should give the error each time]
+    expected: FAIL
+
+  [locked should be false]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    expected: FAIL
+
+  [read() should reject with the error]
+    expected: FAIL
+
+  [closed should reject with the error]
+    expected: FAIL
+
+  [releasing the lock should cause closed to reject and change identity]
+    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
+
+  [read() should return distinct promises each time]
+    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
+
+  [releasing the lock should cause further read() calls to reject with a TypeError]
+    expected: FAIL
+
+  [reader's closed property always returns the same promise]
+    expected: FAIL
+