<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[188684] trunk/LayoutTests</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/188684">188684</a></dd>
<dt>Author</dt> <dd>calvaris@igalia.com</dd>
<dt>Date</dt> <dd>2015-08-20 01:00:43 -0700 (Thu, 20 Aug 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>[Streams API] Sync tests with upstream reference
https://bugs.webkit.org/show_bug.cgi?id=148078
Synced with the upstream reference tests. This means that we moved
some of ours to the reference and brought some new ones. Of course
expectations were updated accordingly.
Reviewed by Darin Adler.
* streams/readable-stream-controller-error-expected.txt: Expectations.
* streams/readable-stream-controller-error.html: Changed test descriptions and moved one test to the reference.
* streams/readable-stream-gc-expected.txt: Removed.
* streams/readable-stream-gc.html: Moved to the reference.
* streams/readable-stream-reader-read-expected.txt: Expectations.
* streams/readable-stream-reader-read.html: Moved a test to the reference.
* streams/reference-implementation/readable-stream-expected.txt:
* streams/reference-implementation/readable-stream-reader-expected.txt: Expectations.
* streams/reference-implementation/readable-stream-reader.html: Brought changes from upstream reference and
uncomented async pull source test (which had been commented since a long time ago and is working now).
* streams/reference-implementation/readable-stream-tee.html: Brought changes from upstream reference.
* streams/reference-implementation/readable-stream-templated-expected.txt: Expectations.
* streams/reference-implementation/readable-stream-templated.html:
* streams/reference-implementation/readable-stream.html: Brought changes from upstream reference.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkLayoutTestsstreamsreadablestreamcontrollererrorexpectedtxt">trunk/LayoutTests/streams/readable-stream-controller-error-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreadablestreamcontrollererrorhtml">trunk/LayoutTests/streams/readable-stream-controller-error.html</a></li>
<li><a href="#trunkLayoutTestsstreamsreadablestreamreaderreadexpectedtxt">trunk/LayoutTests/streams/readable-stream-reader-read-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreadablestreamreaderreadhtml">trunk/LayoutTests/streams/readable-stream-reader-read.html</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamexpectedtxt">trunk/LayoutTests/streams/reference-implementation/readable-stream-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamreaderexpectedtxt">trunk/LayoutTests/streams/reference-implementation/readable-stream-reader-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamreaderhtml">trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamteehtml">trunk/LayoutTests/streams/reference-implementation/readable-stream-tee.html</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamtemplatedexpectedtxt">trunk/LayoutTests/streams/reference-implementation/readable-stream-templated-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamtemplatedhtml">trunk/LayoutTests/streams/reference-implementation/readable-stream-templated.html</a></li>
<li><a href="#trunkLayoutTestsstreamsreferenceimplementationreadablestreamhtml">trunk/LayoutTests/streams/reference-implementation/readable-stream.html</a></li>
</ul>
<h3>Removed Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsstreamsreadablestreamgcexpectedtxt">trunk/LayoutTests/streams/readable-stream-gc-expected.txt</a></li>
<li><a href="#trunkLayoutTestsstreamsreadablestreamgchtml">trunk/LayoutTests/streams/readable-stream-gc.html</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/ChangeLog 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -1,3 +1,29 @@
</span><ins>+2015-08-20 Xabier Rodriguez Calvar <calvaris@igalia.com>
+
+ [Streams API] Sync tests with upstream reference
+ https://bugs.webkit.org/show_bug.cgi?id=148078
+
+ Synced with the upstream reference tests. This means that we moved
+ some of ours to the reference and brought some new ones. Of course
+ expectations were updated accordingly.
+
+ Reviewed by Darin Adler.
+
+ * streams/readable-stream-controller-error-expected.txt: Expectations.
+ * streams/readable-stream-controller-error.html: Changed test descriptions and moved one test to the reference.
+ * streams/readable-stream-gc-expected.txt: Removed.
+ * streams/readable-stream-gc.html: Moved to the reference.
+ * streams/readable-stream-reader-read-expected.txt: Expectations.
+ * streams/readable-stream-reader-read.html: Moved a test to the reference.
+ * streams/reference-implementation/readable-stream-expected.txt:
+ * streams/reference-implementation/readable-stream-reader-expected.txt: Expectations.
+ * streams/reference-implementation/readable-stream-reader.html: Brought changes from upstream reference and
+ uncomented async pull source test (which had been commented since a long time ago and is working now).
+ * streams/reference-implementation/readable-stream-tee.html: Brought changes from upstream reference.
+ * streams/reference-implementation/readable-stream-templated-expected.txt: Expectations.
+ * streams/reference-implementation/readable-stream-templated.html:
+ * streams/reference-implementation/readable-stream.html: Brought changes from upstream reference.
+
</ins><span class="cx"> 2015-08-19 Wenson Hsieh <wenson_hsieh@apple.com>
</span><span class="cx">
</span><span class="cx"> Select validation does not correctly work when handling change event
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamcontrollererrorexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/readable-stream-controller-error-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-controller-error-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-controller-error-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -1,5 +1,4 @@
</span><span class="cx">
</span><del>-PASS Erroring a ReadableStream should reject ReadableStreamReader close promise
-PASS Erroring a ReadableStream should reject ReadableStreamReader close promise
-PASS Erroring a ReadableStream without any value
</del><ins>+PASS Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise
+PASS Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise
</ins><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamcontrollererrorhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/readable-stream-controller-error.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-controller-error.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-controller-error.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -2,7 +2,7 @@
</span><span class="cx"> <script src='../resources/testharness.js'></script>
</span><span class="cx"> <script src='../resources/testharnessreport.js'></script>
</span><span class="cx"> <script>
</span><del>-var test1 = async_test('Erroring a ReadableStream should reject ReadableStreamReader close promise');
</del><ins>+var test1 = async_test('Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise');
</ins><span class="cx"> test1.step(function() {
</span><span class="cx"> var controller;
</span><span class="cx"> var rs = new ReadableStream({
</span><span class="lines">@@ -22,7 +22,7 @@
</span><span class="cx"> controller.error(rsError);
</span><span class="cx"> });
</span><span class="cx">
</span><del>-var test2 = async_test('Erroring a ReadableStream should reject ReadableStreamReader close promise');
</del><ins>+var test2 = async_test('Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise');
</ins><span class="cx"> test2.step(function() {
</span><span class="cx"> var controller;
</span><span class="cx"> var rs = new ReadableStream({
</span><span class="lines">@@ -43,23 +43,4 @@
</span><span class="cx"> test2.done();
</span><span class="cx"> }));
</span><span class="cx"> });
</span><del>-
-var test3 = async_test('Erroring a ReadableStream without any value');
-test3.step(function() {
- var controller;
- var rs = new ReadableStream({
- start: function(c) {
- controller = c;
- }
- });
-
- rs.getReader().closed.then(test3.step_func(function() {
- assert_unreached("closed promise should not be resolved when stream is errored");
- }), test3.step_func(function(err) {
- assert_equals(err, undefined);
- test3.done();
- }));
-
- controller.error();
-});
</del><span class="cx"> </script>
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamgcexpectedtxt"></a>
<div class="delfile"><h4>Deleted: trunk/LayoutTests/streams/readable-stream-gc-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-gc-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-gc-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -1,5 +0,0 @@
</span><del>-
-PASS Readable stream controller methods should continue working properly when scripts are loosing reference to the readable stream
-PASS Readable stream closed promise should resolve even if stream and reader JS references are lost
-PASS Readable stream closed promise should reject even if stream and reader JS references are lost
-
</del></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamgchtml"></a>
<div class="delfile"><h4>Deleted: trunk/LayoutTests/streams/readable-stream-gc.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-gc.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-gc.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -1,66 +0,0 @@
</span><del>-<!DOCTYPE html>
-<script src='../resources/testharness.js'></script>
-<script src='../resources/testharnessreport.js'></script>
-<script src='../resources/gc.js'></script>
-<script>
-function garbageCollectAndDo(task)
-{
- var timeout = 50;
- if (window.GCController)
- window.GCController.collect();
- else if (window.gc)
- window.gc();
- else
- timeout = 400;
- setTimeout(task, timeout);
-}
-
-var test1 = async_test('Readable stream controller methods should continue working properly when scripts are loosing reference to the readable stream');
-test1.step(function() {
- var controller;
- new ReadableStream({
- start: function(c) {
- controller = c;
- }
- });
-
- garbageCollectAndDo(test1.step_func(function() {
- controller.close();
- assert_throws(new TypeError(), function() { controller.close(); });
- assert_throws(new TypeError(), function() { controller.error(); });
- test1.done();
- }));
-});
-
-var test2 = async_test('Readable stream closed promise should resolve even if stream and reader JS references are lost');
-test2.step(function() {
- var controller;
- new ReadableStream({
- start: function(c) {
- controller = c;
- }
- }).getReader().closed.then(test2.step_func(function() {
- test2.done();
- }));
-
- garbageCollectAndDo(test2.step_func(function() {
- controller.close();
- }));
-});
-
-var test3 = async_test('Readable stream closed promise should reject even if stream and reader JS references are lost');
-test3.step(function() {
- var controller;
- new ReadableStream({
- start: function(c) {
- controller = c;
- }
- }).getReader().closed.catch(test3.step_func(function() {
- test3.done();
- }));
-
- garbageCollectAndDo(test3.step_func(function() {
- controller.error();
- }));
-});
-</script>
</del></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamreaderreadexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/readable-stream-reader-read-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-reader-read-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-reader-read-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -3,6 +3,5 @@
</span><span class="cx"> PASS Reading twice on a closed stream
</span><span class="cx"> PASS Reading twice on an errored stream
</span><span class="cx"> PASS Reading twice on a stream that gets errored
</span><del>-PASS Reading within a read promise resolve callback on a stream that gets closed
</del><span class="cx"> PASS ReadableStream: if start rejects with no parameter, it should error the stream with an undefined error
</span><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreadablestreamreaderreadhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/readable-stream-reader-read.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/readable-stream-reader-read.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/readable-stream-reader-read.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -135,36 +135,17 @@
</span><span class="cx"> controller.error(myError);
</span><span class="cx"> });
</span><span class="cx">
</span><del>-var test5 = async_test('Reading within a read promise resolve callback on a stream that gets closed');
</del><ins>+var test5 = async_test('ReadableStream: if start rejects with no parameter, it should error the stream with an undefined error');
</ins><span class="cx"> test5.step(function() {
</span><del>- var controller;
</del><span class="cx"> var rs = new ReadableStream({
</span><span class="cx"> start: function(c) {
</span><del>- controller = c;
- }
- });
-
- var reader = rs.getReader();
-
- reader.read().then(test5.step_func(function() {
- reader.read().then(test5.step_func(function() {
- test5.done();
- }));
- }));
- controller.close();
-});
-
-var test6 = async_test('ReadableStream: if start rejects with no parameter, it should error the stream with an undefined error');
-test6.step(function() {
- var rs = new ReadableStream({
- start: function(c) {
</del><span class="cx"> return Promise.reject();
</span><span class="cx"> }
</span><span class="cx"> });
</span><span class="cx">
</span><del>- rs.getReader().read().catch(test6.step_func(function(e) {
</del><ins>+ rs.getReader().read().catch(test5.step_func(function(e) {
</ins><span class="cx"> assert_equals(typeof e, "undefined");
</span><del>- test6.done();
</del><ins>+ test5.done();
</ins><span class="cx"> }));
</span><span class="cx"> });
</span><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -30,4 +30,8 @@
</span><span class="cx"> PASS ReadableStream strategies: the default strategy should continue giving desiredSize of 1 if the chunks are read immediately
</span><span class="cx"> PASS ReadableStream integration test: adapting a random push source
</span><span class="cx"> PASS ReadableStream integration test: adapting a sync pull source
</span><ins>+PASS ReadableStream integration test: adapting an async pull source
+PASS ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream
+PASS ReadableStream closed promise should fulfill even if the stream and reader JS references are lost
+PASS ReadableStream closed promise should reject even if stream and reader JS references are lost
</ins><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamreaderexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-reader-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-reader-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-reader-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -18,4 +18,5 @@
</span><span class="cx"> PASS cancel() on a released reader is a no-op and does not pass through
</span><span class="cx"> PASS Getting a second reader after erroring the stream should succeed
</span><span class="cx"> PASS Garbage-collecting a ReadableStreamReader should not unlock its stream
</span><ins>+PASS ReadableStreamReader closed promise should be rejected with undefined if that is the error
</ins><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamreaderhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -312,4 +312,23 @@
</span><span class="cx">
</span><span class="cx"> assert_throws(new TypeError(), function() { rs.getReader(); }, 'old reader should still be locking the stream even after garbage collection');
</span><span class="cx"> }, 'Garbage-collecting a ReadableStreamReader should not unlock its stream');
</span><ins>+
+var test9 = async_test('ReadableStreamReader closed promise should be rejected with undefined if that is the error');
+test9.step(function() {
+ var controller;
+ var rs = new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ });
+
+ rs.getReader().closed.then(test9.step_func(function() {
+ assert_unreached("closed promise should not be resolved when stream is errored");
+ }), test9.step_func(function(err) {
+ assert_equals(err, undefined, 'passed error should be undefined as it was');
+ test9.done();
+ }));
+
+ controller.error();
+});
</ins><span class="cx"> </script>
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamteehtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-tee.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-tee.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-tee.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -201,10 +201,10 @@
</span><span class="cx"> var reason2 = new Error('I have the death sentence on twelve systems.');
</span><span class="cx">
</span><span class="cx"> var rs = new ReadableStream({
</span><del>- cancel: test6.step_func(function(reason) {
</del><ins>+ cancel: function(reason) {
</ins><span class="cx"> assert_array_equals(reason, [reason1, reason2], 'the cancel reason should be an array containing those from the branches');
</span><span class="cx"> test6.done();
</span><del>- })
</del><ins>+ }
</ins><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> var branch = rs.tee();
</span><span class="lines">@@ -230,7 +230,6 @@
</span><span class="cx"> branch1.cancel().catch(test7.step_func(function(e) {
</span><span class="cx"> assert_equals(e, theError, 'branch1.cancel() should reject with the error');
</span><span class="cx"> cancelRejected = true;
</span><del>- test7.done();
</del><span class="cx"> }));
</span><span class="cx"> branch2.cancel().catch(test7.step_func(function(e) {
</span><span class="cx"> assert_equals(e, theError, 'branch2.cancel() should reject with the error');
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamtemplatedexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-templated-expected.txt (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-templated-expected.txt 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-templated-expected.txt 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -19,32 +19,51 @@
</span><span class="cx"> PASS locked should be false
</span><span class="cx"> PASS getReader() should be OK
</span><span class="cx"> PASS should be able to acquire multiple readers, since they are all auto-released
</span><del>-PASS Running templatedRSClosedReader with ReadableStream (closed via call in start) reader
</del><ins>+PASS Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)
</ins><span class="cx"> PASS read() should fulfill with { value: undefined, done: true }
</span><ins>+PASS read() multiple times should fulfill with { value: undefined, done: true }
+PASS read() should work when used within another read() fulfill callback
</ins><span class="cx"> PASS closed should fulfill with undefined
</span><span class="cx"> PASS cancel() should return a distinct fulfilled promise each time
</span><ins>+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 cancel() should return a distinct fulfilled promise each time
</ins><span class="cx"> PASS Running templatedRSClosed with ReadableStream (closed via cancel)
</span><span class="cx"> PASS cancel() should return a distinct fulfilled promise each time
</span><span class="cx"> PASS locked should be false
</span><span class="cx"> PASS getReader() should be OK
</span><span class="cx"> PASS should be able to acquire multiple readers, since they are all auto-released
</span><del>-PASS Running templatedRSClosedReader with ReadableStream (closed via cancel) reader
</del><ins>+PASS Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)
</ins><span class="cx"> PASS read() should fulfill with { value: undefined, done: true }
</span><ins>+PASS read() multiple times should fulfill with { value: undefined, done: true }
+PASS read() should work when used within another read() fulfill callback
</ins><span class="cx"> PASS closed should fulfill with undefined
</span><span class="cx"> PASS cancel() should return a distinct fulfilled promise each time
</span><span class="cx"> PASS Running templatedRSErrored with ReadableStream (errored via call in start)
</span><span class="cx"> PASS getReader() should return a reader that acts errored
</span><ins>+PASS read() twice should give the error each time
</ins><span class="cx"> PASS locked should be false
</span><span class="cx"> PASS Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)
</span><ins>+PASS should be able to obtain a second reader, with the correct closed promise
</ins><span class="cx"> PASS cancel() should return a distinct rejected promise each time
</span><span class="cx"> PASS reader cancel() should return a distinct rejected promise each time
</span><span class="cx"> PASS should be able to acquire multiple readers, since they are all auto-released
</span><span class="cx"> PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start)
</span><span class="cx"> PASS getReader() should return a reader that acts errored
</span><ins>+PASS read() twice should give the error each time
</ins><span class="cx"> PASS locked should be false
</span><span class="cx"> PASS Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader
</span><span class="cx"> PASS closed should reject with the error
</span><span class="cx"> PASS read() should reject with the error
</span><ins>+PASS Running templatedRSErroredReader with ReadableStream reader (errored before getting reader)
+PASS closed should reject with the error
+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 read() should reject with the error
</ins><span class="cx"> PASS Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader
</span><span class="cx"> PASS calling read() twice without waiting will eventually give both chunks
</span><span class="cx"> PASS calling read() twice with waiting will eventually give both chunks
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamtemplatedhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-templated.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream-templated.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-templated.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -91,6 +91,28 @@
</span><span class="cx"> }));
</span><span class="cx"> });
</span><span class="cx">
</span><ins>+ var test2 = async_test('read() twice should give the error each time');
+ test2.step(function() {
+ var rs = factory();
+ var promiseCount = 0;
+
+ var reader = rs.getReader();
+
+ reader.read().catch(test2.step_func(function(e) {
+ assert_equals(e, error, 'reader.read() should reject with the error');
+ assert_equals(++promiseCount, 1);
+ }));
+ reader.read().catch(test2.step_func(function(e) {
+ assert_equals(e, error, 'reader.read() should reject with the error');
+ assert_equals(++promiseCount, 2);
+ }));
+ reader.closed.catch(test2.step_func(function(e) {
+ assert_equals(e, error, 'reader.closed should reject with the error');
+ assert_equals(++promiseCount, 3);
+ test2.done();
+ }));
+ });
+
</ins><span class="cx"> test(function() {
</span><span class="cx"> var rs = factory();
</span><span class="cx">
</span><span class="lines">@@ -102,31 +124,48 @@
</span><span class="cx"> test(function() {
</span><span class="cx"> }, 'Running templatedRSErroredSyncOnly with ' + label);
</span><span class="cx">
</span><del>- var test1 = async_test('cancel() should return a distinct rejected promise each time');
</del><ins>+ var test1 = async_test('should be able to obtain a second reader, with the correct closed promise');
</ins><span class="cx"> test1.step(function() {
</span><span class="cx"> var rs = factory();
</span><ins>+
+ rs.getReader();
+
+ var reader = rs.getReader(); // Calling getReader() twice does not throw (the stream is not locked).
+
+ reader.closed.then(
+ test1.step_func(function() { assert_unreached('closed promise should not be fulfilled when stream is errored'); }),
+ test1.step_func(function(err) {
+ assert_equals(err, error);
+ test1.done();
+ })
+ );
+ });
+
+ var test2 = async_test('cancel() should return a distinct rejected promise each time');
+ test2.step(function() {
+ var rs = factory();
</ins><span class="cx"> var promisesCount = 0;
</span><span class="cx"> var allChecked = false;
</span><span class="cx">
</span><span class="cx"> var cancelPromise1 = rs.cancel();
</span><span class="cx"> var cancelPromise2 = rs.cancel();
</span><span class="cx">
</span><del>- cancelPromise1.catch(test1.step_func(function(e) {
</del><ins>+ cancelPromise1.catch(test2.step_func(function(e) {
</ins><span class="cx"> assert_equals(e, error, 'first cancel() call should reject with the error');
</span><span class="cx"> ++promisesCount;
</span><span class="cx"> }));
</span><del>- cancelPromise2.catch(test1.step_func(function(e) {
</del><ins>+ cancelPromise2.catch(test2.step_func(function(e) {
</ins><span class="cx"> assert_equals(e, error, 'second cancel() call should reject with the error');
</span><span class="cx"> assert_equals(++promisesCount, 2);
</span><span class="cx"> assert_true(allChecked);
</span><del>- test1.done();
</del><ins>+ test2.done();
</ins><span class="cx"> }));
</span><span class="cx"> assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
</span><span class="cx"> allChecked = true;
</span><span class="cx"> });
</span><span class="cx">
</span><del>- var test2 = async_test('reader cancel() should return a distinct rejected promise each time');
- test2.step(function() {
</del><ins>+ var test3 = async_test('reader cancel() should return a distinct rejected promise each time');
+ test3.step(function() {
</ins><span class="cx"> var rs = factory();
</span><span class="cx"> var reader = rs.getReader();
</span><span class="cx"> var promisesCount = 0;
</span><span class="lines">@@ -135,15 +174,15 @@
</span><span class="cx"> var cancelPromise1 = reader.cancel();
</span><span class="cx"> var cancelPromise2 = reader.cancel();
</span><span class="cx">
</span><del>- cancelPromise1.catch(test2.step_func(function(e) {
</del><ins>+ cancelPromise1.catch(test3.step_func(function(e) {
</ins><span class="cx"> assert_equals(e, error, 'first cancel() call should reject with the error');
</span><span class="cx"> ++promisesCount;
</span><span class="cx"> }));
</span><del>- cancelPromise2.catch(test2.step_func(function(e) {
</del><ins>+ cancelPromise2.catch(test3.step_func(function(e) {
</ins><span class="cx"> assert_equals(e, error, 'second cancel() call should reject with the error');
</span><span class="cx"> assert_equals(++promisesCount, 2);
</span><span class="cx"> assert_true(allChecked);
</span><del>- test2.done();
</del><ins>+ test3.done();
</ins><span class="cx"> }));
</span><span class="cx"> assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
</span><span class="cx"> allChecked = true;
</span><span class="lines">@@ -328,22 +367,51 @@
</span><span class="cx"> );
</span><span class="cx"> });
</span><span class="cx">
</span><del>- var test2 = async_test('closed should fulfill with undefined');
</del><ins>+ var test2 = async_test('read() multiple times should fulfill with { value: undefined, done: true }');
</ins><span class="cx"> test2.step(function() {
</span><span class="cx"> var { reader } = factory();
</span><ins>+ var readCount = 0;
</ins><span class="cx">
</span><del>- reader.closed.then(
</del><ins>+ reader.read().then(
</ins><span class="cx"> test2.step_func(function(v) {
</span><del>- assert_equals(v, undefined, 'reader closed should fulfill with undefined');
</del><ins>+ assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+ ++readCount;
+ }),
+ test2.step_func(function() { assert_unreached('read() should not return a rejected promise'); })
+ );
+ reader.read().then(
+ test2.step_func(function(v) {
+ assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
+ assert_equals(++readCount, 2);
</ins><span class="cx"> test2.done();
</span><span class="cx"> }),
</span><del>- test2.step_func(function() { assert_unreached('reader closed should not reject'); })
</del><ins>+ test2.step_func(function() { assert_unreached('read() should not return a rejected promise'); })
</ins><span class="cx"> );
</span><span class="cx"> });
</span><span class="cx">
</span><del>- var test3 = async_test('cancel() should return a distinct fulfilled promise each time');
</del><ins>+ var test3 = async_test('read() should work when used within another read() fulfill callback');
</ins><span class="cx"> test3.step(function() {
</span><span class="cx"> var { reader } = factory();
</span><ins>+
+ reader.read().then(test3.step_func(function() { reader.read().then(test3.step_func(function() { test3.done('read() should fulfill'); })); }));
+ });
+
+ var test4 = async_test('closed should fulfill with undefined');
+ test4.step(function() {
+ var { reader } = factory();
+
+ reader.closed.then(
+ test4.step_func(function(v) {
+ assert_equals(v, undefined, 'reader closed should fulfill with undefined');
+ test4.done();
+ }),
+ test4.step_func(function() { assert_unreached('reader closed should not reject'); })
+ );
+ });
+
+ var test5 = async_test('cancel() should return a distinct fulfilled promise each time');
+ test5.step(function() {
+ var { reader } = factory();
</ins><span class="cx"> var promiseCount = 0;
</span><span class="cx"> var allChecked = false;
</span><span class="cx">
</span><span class="lines">@@ -351,15 +419,15 @@
</span><span class="cx"> var cancelPromise2 = reader.cancel();
</span><span class="cx"> var closedReaderPromise = reader.closed;
</span><span class="cx">
</span><del>- cancelPromise1.then(test3.step_func(function(v) {
</del><ins>+ cancelPromise1.then(test5.step_func(function(v) {
</ins><span class="cx"> assert_equals(v, undefined, 'first cancel() call should fulfill with undefined');
</span><span class="cx"> ++promiseCount;
</span><span class="cx"> }));
</span><del>- cancelPromise2.then(test3.step_func(function(v) {
</del><ins>+ cancelPromise2.then(test5.step_func(function(v) {
</ins><span class="cx"> assert_equals(v, undefined, 'second cancel() call should fulfill with undefined');
</span><span class="cx"> assert_equals(++promiseCount, 2);
</span><span class="cx"> assert_true(allChecked);
</span><del>- test3.done();
</del><ins>+ test5.done();
</ins><span class="cx"> }));
</span><span class="cx"> assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should return distinct promises');
</span><span class="cx"> assert_not_equals(cancelPromise1, closedReaderPromise, 'cancel() promise 1 should be distinct from reader.closed');
</span><span class="lines">@@ -607,14 +675,26 @@
</span><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>-templatedRSClosedReader('ReadableStream (closed via call in start) reader', function() {
</del><ins>+templatedRSClosedReader('ReadableStream reader (closed before getting reader)', function() {
</ins><span class="cx"> var controller;
</span><span class="cx"> var stream = new ReadableStream({
</span><span class="cx"> start: function(c) {
</span><span class="cx"> controller = c;
</span><span class="cx"> }
</span><span class="cx"> });
</span><ins>+ controller.close();
</ins><span class="cx"> var result = streamAndDefaultReader(stream);
</span><ins>+ return result;
+});
+
+templatedRSClosedReader('ReadableStream reader (closed after getting reader)', function() {
+ var controller;
+ var stream = new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ });
+ var result = streamAndDefaultReader(stream);
</ins><span class="cx"> controller.close();
</span><span class="cx"> return result;
</span><span class="cx"> });
</span><span class="lines">@@ -625,7 +705,7 @@
</span><span class="cx"> return stream;
</span><span class="cx"> });
</span><span class="cx">
</span><del>-templatedRSClosedReader('ReadableStream (closed via cancel) reader', function() {
</del><ins>+templatedRSClosedReader('ReadableStream reader (closed via cancel after getting reader)', function() {
</ins><span class="cx"> var stream = new ReadableStream();
</span><span class="cx"> var result = streamAndDefaultReader(stream);
</span><span class="cx"> result.reader.cancel();
</span><span class="lines">@@ -670,6 +750,28 @@
</span><span class="cx"> theError
</span><span class="cx"> );
</span><span class="cx">
</span><ins>+templatedRSErroredReader('ReadableStream reader (errored before getting reader)', function() {
+ var controller;
+ var stream = new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ });
+ controller.error(theError);
+ return streamAndDefaultReader(stream);
+}, theError);
+
+templatedRSErroredReader('ReadableStream reader (errored after getting reader)', function() {
+ var controller;
+ var result = streamAndDefaultReader(new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ }));
+ controller.error(theError);
+ return result;
+}, theError);
+
</ins><span class="cx"> var chunks = ['a', 'b'];
</span><span class="cx">
</span><span class="cx"> templatedRSTwoChunksOpenReader('ReadableStream (two chunks enqueued, still open) reader', function() {
</span></span></pre></div>
<a id="trunkLayoutTestsstreamsreferenceimplementationreadablestreamhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream.html (188683 => 188684)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/streams/reference-implementation/readable-stream.html 2015-08-20 07:41:11 UTC (rev 188683)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream.html 2015-08-20 08:00:43 UTC (rev 188684)
</span><span class="lines">@@ -2,6 +2,7 @@
</span><span class="cx"> <script src='../../resources/testharness.js'></script>
</span><span class="cx"> <script src='../../resources/testharnessreport.js'></script>
</span><span class="cx"> <script src='resources/streams-utils.js'></script>
</span><ins>+<script src='../../resources/gc.js'></script>
</ins><span class="cx"> <script>
</span><span class="cx"> test(function() {
</span><span class="cx"> new ReadableStream(); // ReadableStream constructed with no parameters.
</span><span class="lines">@@ -765,15 +766,76 @@
</span><span class="cx"> }));
</span><span class="cx"> });
</span><span class="cx">
</span><del>-// var test20 = async_test('ReadableStream integration test: adapting an async pull source');
-// test20.step(function() {
-// var rs = sequentialReadableStream(10, { async: true });
</del><ins>+var test20 = async_test('ReadableStream integration test: adapting an async pull source');
+test20.step(function() {
+ var rs = sequentialReadableStream(10, { async: true });
</ins><span class="cx">
</span><del>-// readableStreamToArray(rs).then(test20.step_func(function(chunks) {
-// assert_true(rs.source.closed, 'source should be closed after all chunks are read');
-// assert_array_equals(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'the expected 10 chunks should be read');
</del><ins>+ readableStreamToArray(rs).then(test20.step_func(function(chunks) {
+ assert_true(rs.source.closed, 'source should be closed after all chunks are read');
+ assert_array_equals(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'the expected 10 chunks should be read');
</ins><span class="cx">
</span><del>-// test20.done();
-// }));
-// });
</del><ins>+ test20.done();
+ }));
+});
+
+function garbageCollectAndDo(task)
+{
+ var timeout = 50;
+ if (window.GCController)
+ window.GCController.collect();
+ else if (window.gc)
+ window.gc();
+ else
+ timeout = 400;
+ setTimeout(task, timeout);
+}
+
+var test21 = async_test('ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream');
+test21.step(function() {
+ var controller;
+ new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ });
+
+ garbageCollectAndDo(test21.step_func(function() {
+ controller.close();
+ assert_throws(new TypeError(), function() { controller.close(); }, 'close should throw a TypeError the second time');
+ assert_throws(new TypeError(), function() { controller.error(); }), 'error should throw a TypeError on a closed stream';
+ test21.done();
+ }));
+});
+
+var test22 = async_test('ReadableStream closed promise should fulfill even if the stream and reader JS references are lost');
+test22.step(function() {
+ var controller;
+ new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ }).getReader().closed.then(test22.step_func(function() {
+ test22.done('closed promise should be fulfilled');
+ }));
+
+ garbageCollectAndDo(test22.step_func(function() {
+ controller.close();
+ }));
+});
+
+var test23 = async_test('ReadableStream closed promise should reject even if stream and reader JS references are lost');
+test23.step(function() {
+ var controller;
+ new ReadableStream({
+ start: function(c) {
+ controller = c;
+ }
+ }).getReader().closed.catch(test23.step_func(function() {
+ test23.done('closed promise should be rejected');
+ }));
+
+ garbageCollectAndDo(test23.step_func(function() {
+ controller.error();
+ }));
+});
</ins><span class="cx"> </script>
</span></span></pre>
</div>
</div>
</body>
</html>