⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 194366 in webkit


Ignore:
Timestamp:
Dec 22, 2015, 10:20:49 AM (11 years ago)
Author:
calvaris@igalia.com
Message:

[Streams API] Fix cosmetic things after importing spec tests
​https://bugs.webkit.org/show_bug.cgi?id=152479

Reviewed by Youenn Fablet.

Spec version are mainly updated in this patch as it wasn't done when importing tests from the spec. Some other
minor changes were done, as renumbering some tests, removing some orphan expectations and other styling issues.

  • streams/brand-checks.html:
  • streams/pipe-to.html:
  • streams/readable-stream-controller-error.html:
  • streams/readable-stream-pipeThrough.html:
  • streams/readable-stream-reader-read.html:
  • streams/reference-implementation/abstract-ops.html:
  • streams/reference-implementation/bad-strategies.html:
  • streams/reference-implementation/bad-underlying-sinks.html:
  • streams/reference-implementation/bad-underlying-sources-expected.txt: Removed.
  • streams/reference-implementation/brand-checks.html:
  • streams/reference-implementation/byte-length-queuing-strategy.html:
  • streams/reference-implementation/count-queuing-strategy.html:
  • streams/reference-implementation/pipe-through.html:
  • streams/reference-implementation/pipe-to-options.html:
  • streams/reference-implementation/pipe-to.html:
  • streams/reference-implementation/readable-stream-templated.html:
  • streams/reference-implementation/transform-stream-errors.html:
  • streams/reference-implementation/transform-stream.html:
  • streams/reference-implementation/writable-stream-abort.html:
  • streams/reference-implementation/writable-stream-expected.txt:
  • streams/reference-implementation/writable-stream.html:
Location:
trunk/LayoutTests
Files:
1 deleted
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r194365 r194366  
     12015-12-22  Xabier Rodriguez Calvar  <calvaris@igalia.com>
     2
     3        [Streams API] Fix cosmetic things after importing spec tests
     4        https://bugs.webkit.org/show_bug.cgi?id=152479
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Spec version are mainly updated in this patch as it wasn't done when importing tests from the spec. Some other
     9        minor changes were done, as renumbering some tests, removing some orphan expectations and other styling issues.
     10
     11        * streams/brand-checks.html:
     12        * streams/pipe-to.html:
     13        * streams/readable-stream-controller-error.html:
     14        * streams/readable-stream-pipeThrough.html:
     15        * streams/readable-stream-reader-read.html:
     16        * streams/reference-implementation/abstract-ops.html:
     17        * streams/reference-implementation/bad-strategies.html:
     18        * streams/reference-implementation/bad-underlying-sinks.html:
     19        * streams/reference-implementation/bad-underlying-sources-expected.txt: Removed.
     20        * streams/reference-implementation/brand-checks.html:
     21        * streams/reference-implementation/byte-length-queuing-strategy.html:
     22        * streams/reference-implementation/count-queuing-strategy.html:
     23        * streams/reference-implementation/pipe-through.html:
     24        * streams/reference-implementation/pipe-to-options.html:
     25        * streams/reference-implementation/pipe-to.html:
     26        * streams/reference-implementation/readable-stream-templated.html:
     27        * streams/reference-implementation/transform-stream-errors.html:
     28        * streams/reference-implementation/transform-stream.html:
     29        * streams/reference-implementation/writable-stream-abort.html:
     30        * streams/reference-implementation/writable-stream-expected.txt:
     31        * streams/reference-implementation/writable-stream.html:
     32
    1332015-12-22  Ryan Haddad  <ryanhaddad@apple.com>
    234

  • trunk/LayoutTests/streams/brand-checks.html

    r193824 r194366  
    44<script src='reference-implementation/resources/streams-utils.js'></script>
    55<script>
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
     7
    68let ReadableStreamReader = (new ReadableStream()).getReader().constructor;
    79

  • trunk/LayoutTests/streams/pipe-to.html

    r192765 r194366  
    44<script src='reference-implementation/resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88// This test is alone here for timing reasons though it should be at streams/reference-implementation/pipe-to.html.

  • trunk/LayoutTests/streams/readable-stream-controller-error.html

    r191292 r194366  
    33<script src='../resources/testharnessreport.js'></script>
    44<script>
    5 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     5// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    66
    77var test1 = async_test('Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise');

  • trunk/LayoutTests/streams/readable-stream-pipeThrough.html

    r190155 r194366  
    44<script src='../resources/gc.js'></script>
    55<script>
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    67
    78test(function() {
    … …  
    7980    assert_equals(count, 3);
    8081}, 'ReadableStream.prototype.pipeThrough should work with missing parameters');
    81 
    8282</script>

  • trunk/LayoutTests/streams/readable-stream-reader-read.html

    r190395 r194366  
    33<script src='../resources/testharnessreport.js'></script>
    44<script>
    5 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     5// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    66
    77var test1 = async_test('Reading twice on a stream that gets closed');
    … …  
    151151    }));
    152152});
    153 
    154153</script>

  • trunk/LayoutTests/streams/reference-implementation/abstract-ops.html

    r192621 r194366  
    33<script src='../../resources/testharnessreport.js'></script>
    44<script src='resources/streams-utils.js'></script>
    5 <!-- FIXME: enable IsReadableStreamDisturbed -->
    65<script>
    76const IsReadableStreamDisturbed = internals.isReadableStreamDisturbed.bind(internals);
    87
    9 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     8// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    109
    1110test(function() {

  • trunk/LayoutTests/streams/reference-implementation/bad-strategies.html

    r193824 r194366  
    33<script src='../../resources/testharnessreport.js'></script>
    44<script>
    5 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     5// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    66
    77test(function() {
    … …  
    1818}, 'Writable stream: throwing strategy.size getter');
    1919
    20 var test3 = async_test('Writable stream: throwing strategy.size method');
    21 test3.step(function() {
     20var test1 = async_test('Writable stream: throwing strategy.size method');
     21test1.step(function() {
    2222    var theError = new Error('a unique string');
    2323    var writeCalled = false;
    … …  
    3232
    3333    ws.write('a').then(
    34         test3.step_func(function() { assert_unreached('write should not fulfill'); }),
    35         test3.step_func(function(r) {
     34        test1.step_func(function() { assert_unreached('write should not fulfill'); }),
     35        test1.step_func(function(r) {
    3636            assert_equals(r, theError, 'write should reject with the thrown error');
    3737            writeCalled = true;
    … …  
    4040
    4141    ws.closed.then(
    42         test3.step_func(function() { assert_unreached('closed should not fulfill'); }),
    43         test3.step_func(function(r) {
     42        test1.step_func(function() { assert_unreached('closed should not fulfill'); }),
     43        test1.step_func(function(r) {
    4444            assert_equals(r, theError, 'closed should reject with the thrown error');
    4545            assert_true(writeCalled);
    46             test3.done();
     46            test1.done();
    4747        })
    4848    );
    4949});
    5050
    51 var test4 = async_test('Writable stream: invalid strategy.size return value');
    52 test4.step(function() {
     51var test2 = async_test('Writable stream: invalid strategy.size return value');
     52test2.step(function() {
    5353    var numberOfCalls = 0;
    5454    var elements = [NaN, -Infinity, +Infinity, -1];
    … …  
    6969        };
    7070        ws.write('a').then(
    71             test4.step_func(function() { assert_unreached('write should not fulfill'); }),
    72             test4.step_func(writeFunction.bind(this, i))
     71            test2.step_func(function() { assert_unreached('write should not fulfill'); }),
     72            test2.step_func(writeFunction.bind(this, i))
    7373        );
    7474
    … …  
    7676            assert_equals(e, theError[i], 'closed should reject with the error for ' + elements[i]);
    7777            if (++numberOfCalls, elements.length) {
    78                 test4.done();
     78                test2.done();
    7979            }
    8080        };
    8181
    82         ws.closed.catch(test4.step_func(catchFunction.bind(this, i)));
     82        ws.closed.catch(test2.step_func(catchFunction.bind(this, i)));
    8383    }
    8484});

  • trunk/LayoutTests/streams/reference-implementation/bad-underlying-sinks.html

    r190161 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88test(function() {

  • trunk/LayoutTests/streams/reference-implementation/brand-checks.html

    r193824 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88function fakeWritableStream() {
    … …  
    5353}
    5454
    55 var test6 = async_test('WritableStream.prototype.closed enforces a brand check');
    56 test6.step(function() {
    57     getterRejects(test6, WritableStream.prototype, 'closed', fakeWritableStream());
    58     getterRejects(test6, WritableStream.prototype, 'closed', realReadableStream(), true);
     55var test1 = async_test('WritableStream.prototype.closed enforces a brand check');
     56test1.step(function() {
     57    getterRejects(test1, WritableStream.prototype, 'closed', fakeWritableStream());
     58    getterRejects(test1, WritableStream.prototype, 'closed', realReadableStream(), true);
    5959});
    6060
    61 var test7 = async_test('WritableStream.prototype.ready enforces a brand check');
    62 test7.step(function() {
    63     getterRejects(test7, WritableStream.prototype, 'ready', fakeWritableStream());
    64     getterRejects(test7, WritableStream.prototype, 'ready', realReadableStream(), true);
     61var test2 = async_test('WritableStream.prototype.ready enforces a brand check');
     62test2.step(function() {
     63    getterRejects(test2, WritableStream.prototype, 'ready', fakeWritableStream());
     64    getterRejects(test2, WritableStream.prototype, 'ready', realReadableStream(), true);
    6565});
    6666
    … …  
    7070}, 'WritableStream.prototype.state enforces a brand check');
    7171
    72 var test8 = async_test('WritableStream.prototype.abort enforces a brand check');
    73 test8.step(function() {
    74     methodRejects(test8, WritableStream.prototype, 'abort', fakeWritableStream());
    75     methodRejects(test8, WritableStream.prototype, 'abort', realReadableStream(), true);
     72var test3 = async_test('WritableStream.prototype.abort enforces a brand check');
     73test3.step(function() {
     74    methodRejects(test3, WritableStream.prototype, 'abort', fakeWritableStream());
     75    methodRejects(test3, WritableStream.prototype, 'abort', realReadableStream(), true);
    7676});
    7777
    78 var test9 = async_test('WritableStream.prototype.write enforces a brand check');
    79 test9.step(function() {
    80     methodRejects(test9, WritableStream.prototype, 'write', fakeWritableStream());
    81     methodRejects(test9, WritableStream.prototype, 'write', realReadableStream(), true);
     78var test4 = async_test('WritableStream.prototype.write enforces a brand check');
     79test4.step(function() {
     80    methodRejects(test4, WritableStream.prototype, 'write', fakeWritableStream());
     81    methodRejects(test4, WritableStream.prototype, 'write', realReadableStream(), true);
    8282});
    8383
    84 var test10 = async_test('WritableStream.prototype.close enforces a brand check');
    85 test10.step(function() {
    86     methodRejects(test10, WritableStream.prototype, 'close', fakeWritableStream());
    87     methodRejects(test10, WritableStream.prototype, 'close', realReadableStream(), true);
     84var test5 = async_test('WritableStream.prototype.close enforces a brand check');
     85test5.step(function() {
     86    methodRejects(test5, WritableStream.prototype, 'close', fakeWritableStream());
     87    methodRejects(test5, WritableStream.prototype, 'close', realReadableStream(), true);
    8888});
    8989</script>

  • trunk/LayoutTests/streams/reference-implementation/byte-length-queuing-strategy.html

    r193824 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('Closing a writable stream with in-flight writes below the high water mark delays the close call properly');

  • trunk/LayoutTests/streams/reference-implementation/count-queuing-strategy.html

    r193824 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88test(function() {
    … …  
    1010}, 'Can construct a writable stream with a valid CountQueuingStrategy');
    1111
    12 var test4 = async_test('Correctly governs the value of a WritableStream\'s state property (HWM = 0)');
    13 test4.step(function() {
     12var test1 = async_test('Correctly governs the value of a WritableStream\'s state property (HWM = 0)');
     13test1.step(function() {
    1414    var dones = Object.create(null);
    1515
    … …  
    1717        {
    1818            write: function(chunk) {
    19                 return new Promise(test4.step_func(function(resolve) { dones[chunk] = resolve; }));
     19                return new Promise(test1.step_func(function(resolve) { dones[chunk] = resolve; }));
    2020            }
    2121        },
    … …  
    2323    );
    2424
    25     setTimeout(test4.step_func(function() {
     25    setTimeout(test1.step_func(function() {
    2626        assert_equals(ws.state, 'writable', 'After 0 writes, 0 of which finished, state should be \'writable\'');
    2727
    … …  
    3333
    3434        dones.a();
    35         writePromiseA.then(test4.step_func(function() {
     35        writePromiseA.then(test1.step_func(function() {
    3636            assert_equals(ws.state, 'waiting', 'After 2 writes, 1 of which finished, state should be \'waiting\'');
    3737
    3838            dones.b();
    39             return writePromiseB.then(test4.step_func(function() {
     39            return writePromiseB.then(test1.step_func(function() {
    4040                assert_equals(ws.state, 'writable', 'After 2 writes, 2 of which finished, state should be \'writable\'');
    4141
    … …  
    4444
    4545                dones.c();
    46                 return writePromiseC.then(test4.step_func(function() {
     46                return writePromiseC.then(test1.step_func(function() {
    4747                    assert_equals(ws.state, 'writable', 'After 3 writes, 3 of which finished, state should be \'writable\'');
    4848
    49                     test4.done();
     49                    test1.done();
    5050                }));
    5151            }));
    52         })).catch(test4.step_func(function(e) { assert_unreached("uncaught error " + e); }));
     52        })).catch(test1.step_func(function(e) { assert_unreached("uncaught error " + e); }));
    5353    }), 0);
    5454});
    5555
    56 var test5 = async_test('Correctly governs the value of a WritableStream\'s state property (HWM = 4)');
    57 test5.step(function() {
     56var test2 = async_test('Correctly governs the value of a WritableStream\'s state property (HWM = 4)');
     57test2.step(function() {
    5858    var dones = Object.create(null);
    5959
    … …  
    6161        {
    6262            write: function(chunk) {
    63                 return new Promise(test5.step_func(function(resolve) { dones[chunk] = resolve; }));
     63                return new Promise(test2.step_func(function(resolve) { dones[chunk] = resolve; }));
    6464            }
    6565        },
    … …  
    6767    );
    6868
    69     setTimeout(test5.step_func(function() {
     69    setTimeout(test2.step_func(function() {
    7070        assert_equals(ws.state, 'writable', 'After 0 writes, 0 of which finished, state should be \'writable\'');
    7171
    … …  
    9292
    9393        dones.a();
    94         writePromiseA.then(test5.step_func(function() {
     94        writePromiseA.then(test2.step_func(function() {
    9595            assert_equals(ws.state, 'waiting', 'After 7 writes, 1 of which finished, state should be \'waiting\'');
    9696
    9797            dones.b();
    98             return writePromiseB.then(test5.step_func(function() {
     98            return writePromiseB.then(test2.step_func(function() {
    9999                assert_equals(ws.state, 'waiting', 'After 7 writes, 2 of which finished, state should be \'waiting\'');
    100100
    101101                dones.c();
    102                 return writePromiseC.then(test5.step_func(function() {
     102                return writePromiseC.then(test2.step_func(function() {
    103103                    assert_equals(ws.state, 'writable', 'After 7 writes, 3 of which finished, state should be \'writable\'');
    104104
    … …  
    107107
    108108                    dones.d();
    109                     return writePromiseD.then(test5.step_func(function() {
     109                    return writePromiseD.then(test2.step_func(function() {
    110110                        assert_equals(ws.state, 'writable', 'After 8 writes, 4 of which finished, state should be \'writable\'');
    111111
    … …  
    113113                        assert_equals(ws.state, 'waiting', 'After 9 writes, 4 of which finished, state should be \'waiting\'');
    114114
    115                         test5.done();
     115                        test2.done();
    116116                    }));
    117117                }));
    118118            }));
    119         })).catch(test5.step_func(function(e) { assert_unreached("uncaught error " + e); }));
     119        })).catch(test2.step_func(function(e) { assert_unreached("uncaught error " + e); }));
    120120    }), 0);
    121121});

  • trunk/LayoutTests/streams/reference-implementation/pipe-through.html

    r190165 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('Piping through a duck-typed pass-through transform stream works');

  • trunk/LayoutTests/streams/reference-implementation/pipe-to-options.html

    r190395 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('Piping with no options and a destination error');

  • trunk/LayoutTests/streams/reference-implementation/pipe-to.html

    r192765 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('Piping from a ReadableStream from which lots of data are readable synchronously');

  • trunk/LayoutTests/streams/reference-implementation/readable-stream-templated.html

    r193824 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88function templatedRSClosed(label, factory) {
    … …  
    1010    }, 'Running templatedRSClosed with ' + label);
    1111
    12     var test2 = async_test('piping to a WritableStream in the writable state should close the writable stream');
    13     test2.step(function() {
     12    var test1 = async_test('piping to a WritableStream in the writable state should close the writable stream');
     13    test1.step(function() {
    1414        var closeCalled = false;
    1515
    … …  
    3232        });
    3333
     34        startPromise.then(test1.step_func(function() {
     35            assert_equals(ws.state, 'writable', 'writable stream should start in writable state');
     36
     37            return rs.pipeTo(ws).then(test1.step_func(function() {
     38                assert_true(closeCalled);
     39                assert_equals(ws.state, 'closed', 'writable stream should become closed');
     40                test1.done('underlying source close should be called');
     41            }));
     42        })).catch(test1.step_func(function(e) { assert_unreached(e); }));
     43    });
     44
     45    var test2 = async_test('piping to a WritableStream in the writable state with { preventClose: true } should do nothing');
     46    test2.step(function() {
     47        var rs = factory();
     48
     49        var startPromise = Promise.resolve();
     50        var ws = new WritableStream({
     51            start: function() {
     52                return startPromise;
     53            },
     54            write: function() {
     55                assert_unreached('Unexpected write call');
     56            },
     57            close: function() {
     58                assert_unreached('Unexpected close call');
     59            },
     60            abort: function() {
     61                assert_unreached('Unexpected abort call');
     62            }
     63        });
     64
    3465        startPromise.then(test2.step_func(function() {
    3566            assert_equals(ws.state, 'writable', 'writable stream should start in writable state');
    3667
    37             return rs.pipeTo(ws).then(test2.step_func(function() {
    38                 assert_true(closeCalled);
    39                 assert_equals(ws.state, 'closed', 'writable stream should become closed');
    40                 test2.done('underlying source close should be called');
     68            return rs.pipeTo(ws, { preventClose: true }).then(test2.step_func(function() {
     69                assert_equals(ws.state, 'writable', 'writable stream should still be writable');
     70                test2.done('pipeTo promise should be fulfilled');
    4171            }));
    4272        })).catch(test2.step_func(function(e) { assert_unreached(e); }));
    43     });
    44 
    45     var test3 = async_test('piping to a WritableStream in the writable state with { preventClose: true } should do nothing');
    46     test3.step(function() {
    47         var rs = factory();
    48 
    49         var startPromise = Promise.resolve();
    50         var ws = new WritableStream({
    51             start: function() {
    52                 return startPromise;
    53             },
    54             write: function() {
    55                 assert_unreached('Unexpected write call');
    56             },
    57             close: function() {
    58                 assert_unreached('Unexpected close call');
    59             },
    60             abort: function() {
    61                 assert_unreached('Unexpected abort call');
    62             }
    63         });
    64 
    65         startPromise.then(test3.step_func(function() {
    66             assert_equals(ws.state, 'writable', 'writable stream should start in writable state');
    67 
    68             return rs.pipeTo(ws, { preventClose: true }).then(test3.step_func(function() {
    69                 assert_equals(ws.state, 'writable', 'writable stream should still be writable');
    70                 test3.done('pipeTo promise should be fulfilled');
    71             }));
    72         })).catch(test3.step_func(function(e) { assert_unreached(e); }));
    7373    });
    7474};

  • trunk/LayoutTests/streams/reference-implementation/transform-stream-errors.html

    r190166 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('TransformStream errors thrown in transform put the writable and readable in an errored state');

  • trunk/LayoutTests/streams/reference-implementation/transform-stream.html

    r190167 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88test(function() {

  • trunk/LayoutTests/streams/reference-implementation/writable-stream-abort.html

    r190395 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88var test1 = async_test('Aborting a WritableStream immediately prevents future writes');

  • trunk/LayoutTests/streams/reference-implementation/writable-stream-expected.txt

    r191669 r194366  
    1111PASS WritableStream with simple input, processed synchronously
    1212PASS WritableStream is writable and ready fulfills immediately if the strategy does not apply backpressure
    13 PASS Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined ovalue
     13PASS Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined value
    1414

  • trunk/LayoutTests/streams/reference-implementation/writable-stream.html

    r190395 r194366  
    44<script src='resources/streams-utils.js'></script>
    55<script>
    6 // This is updated till https://github.com/whatwg/streams/commit/ec5ffa036308d9f6350d2946560d48cdbf090939
     6// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3
    77
    88function writeArrayToStream(array, writableStream) {
    … …  
    240240});
    241241
    242 var test10 = async_test('Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined ovalue');
     242var test10 = async_test('Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined value');
    243243test10.step(function() {
    244244    var ws = new WritableStream({
Note: See TracChangeset for help on using the changeset viewer.