Changeset 182783 in webkit


Ignore:
Timestamp:
Apr 14, 2015, 1:20:40 AM (10 years ago)
Author:
calvaris@igalia.com
Message:

Sync Streams API tests with spec
​https://bugs.webkit.org/show_bug.cgi?id=143669

Reviewed by Darin Adler.

Some tests were moved from the spec tests to our custom ones
because they were not approved (yet, or they won't be).

Some nuances from the spec tests were also fixed.

  • streams/readable-stream-expected.txt: Added.
  • streams/readable-stream-reader-expected.txt: Added.
  • streams/readable-stream-reader.html: Added.
  • streams/readable-stream.html: Added.
  • streams/reference-implementation/readable-stream-expected.txt:
  • streams/reference-implementation/readable-stream-reader-expected.txt:
  • streams/reference-implementation/readable-stream-reader.html:
  • streams/reference-implementation/readable-stream.html: Nuances

fixed and tests moved to custom.

Location:
trunk/LayoutTests
Files:
4 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r182780 r182783  
     12015-04-14  Youenn Fablet  <youenn.fablet@crf.canon.fr> and Xabier Rodriguez Calvar <calvaris@igalia.com>
     2
     3        Sync Streams API tests with spec
     4        https://bugs.webkit.org/show_bug.cgi?id=143669
     5
     6        Reviewed by Darin Adler.
     7
     8        Some tests were moved from the spec tests to our custom ones
     9        because they were not approved (yet, or they won't be).
     10
     11        Some nuances from the spec tests were also fixed.
     12
     13        * streams/readable-stream-expected.txt: Added.
     14        * streams/readable-stream-reader-expected.txt: Added.
     15        * streams/readable-stream-reader.html: Added.
     16        * streams/readable-stream.html: Added.
     17        * streams/reference-implementation/readable-stream-expected.txt:
     18        * streams/reference-implementation/readable-stream-reader-expected.txt:
     19        * streams/reference-implementation/readable-stream-reader.html:
     20        * streams/reference-implementation/readable-stream.html: Nuances
     21        fixed and tests moved to custom.
     22
    1232015-04-13  Manuel Rego Casasnovas  <rego@igalia.com>
    224

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

    r182625 r182783  
    11
    22FAIL ReadableStream can be constructed with no errors ReadableStream constructor should get an object as argument.
    3 PASS ReadableStream can't be constructed with garbage
    4 FAIL ReadableStream instances should have the correct list of properties assert_array_equals: lengths differ, expected 6 got 5
    5 PASS ReadableStream constructor should get a function as start argument
    6 FAIL ReadableStream start should be called with the proper parameters null is not an object (evaluating 'Object.getOwnPropertyNames(Object.getPrototypeOf(controller))')
    7 FAIL ReadableStream start controller parameter should be updatable null is not an object (evaluating 'Object.getOwnPropertyNames(Object.getPrototypeOf(controller))')
    8 PASS ReadableStream should be able to call start method within prototype chain of its source
     3FAIL ReadableStream instances should have the correct list of properties assert_array_equals: should have all the correct methods lengths differ, expected 6 got 5
     4PASS ReadableStream constructor should throw for non-function start arguments
    95PASS ReadableStream constructor can get initial garbage as cancel argument
    106PASS ReadableStream constructor can get initial garbage as pull argument
    … …  
    128FAIL ReadableStream start should be able to return a promise read is not implemented
    139TIMEOUT ReadableStream start should be able to return a promise and reject it Test timed out
    14 FAIL ReadableStream should be able to queue different objects. read is not implemented
     10FAIL ReadableStream should be able to enqueue different objects. read is not implemented
    1511PASS ReadableStream: if start throws an error, it should be re-thrown
    1612FAIL ReadableStream: if pull rejects, it should error the stream read is not implemented

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

    r182625 r182783  
    22PASS Can get the ReadableStreamReader constructor indirectly
    33PASS ReadableStreamReader constructor should get a ReadableStream object as argument
    4 FAIL ReadableStream instances should have the correct list of properties assert_array_equals: lengths differ, expected 5 got 4
     4FAIL ReadableStreamReader instances should have the correct list of properties assert_array_equals: lengths differ, expected 5 got 4
    55PASS ReadableStreamReader closed should always return the same promise object
    66PASS Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)
    … …  
    1818FAIL cancel() on a released reader is a no-op and does not pass through releaseLock is not implemented
    1919FAIL Getting a second reader after erroring the stream should succeed read is not implemented
    20 PASS Collecting a ReadableStreamReader should not unlock its stream
    2120

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

    r182629 r182783  
    22<script src='../../resources/testharness.js'></script>
    33<script src='../../resources/testharnessreport.js'></script>
    4 <script src='../../resources/gc.js'></script>
    54<script src='resources/streams-utils.js'></script>
    65<script>
    … …  
    2524
    2625test(function() {
     26    var methods = ['cancel', 'constructor', 'read', 'releaseLock'];
     27    var properties = methods.concat(['closed']).sort();
     28
    2729    var rsReader = new ReadableStreamReader(new ReadableStream());
    28 
    29     // assert_array_equals(Object.getOwnPropertyNames(rsReader), []);
    30     assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(rsReader)).sort(), [ 'cancel', 'closed', 'constructor', 'read', 'releaseLock' ]);
    31 
    32     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').enumerable);
    33     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').configurable);
    34     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').writable);
    35 
    36     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'closed').enumerable);
    37     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'closed').configurable);
    38 
    39     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'constructor').configurable);
    40     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'constructor').writable);
    41 
    42     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').enumerable);
    43     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').configurable);
    44     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').writable);
    45 
    46     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').enumerable);
    47     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').configurable);
    48     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').writable);
    49 
    50     assert_equals(typeof rsReader.cancel, 'function', 'has a cancel method');
    51     assert_equals(rsReader.cancel.length, 1);
    52     assert_exists(Object.getPrototypeOf(rsReader), 'closed', 'has a closed property');
     30    var proto = Object.getPrototypeOf(rsReader);
     31
     32    assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties);
     33
     34    for (var m of methods) {
     35        var propDesc = Object.getOwnPropertyDescriptor(proto, m);
     36        assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
     37        assert_equals(propDesc.configurable, true, 'method should be configurable');
     38        assert_equals(propDesc.writable, true, 'method should be writable');
     39        assert_equals(typeof rsReader[m], 'function', 'should have be a method');
     40    }
     41
     42    var closedPropDesc = Object.getOwnPropertyDescriptor(proto, 'closed');
     43    assert_equals(closedPropDesc.enumerable, false, 'closed should be non-enumerable');
     44    assert_equals(closedPropDesc.configurable, true, 'closed should be configurable');
     45    assert_not_equals(closedPropDesc.get, undefined, 'closed should have a getter');
     46    assert_equals(closedPropDesc.set, undefined, 'closed should not have a setter');
     47
     48    assert_equals(rsReader.cancel.length, 1, 'cancel has 1 parameter');
     49    assert_not_equals(rsReader.closed, undefined, 'has a non-undefined closed property');
    5350    assert_equals(typeof rsReader.closed.then, 'function', 'closed property is thenable');
    5451    assert_equals(typeof rsReader.constructor, 'function', 'has a constructor method');
    5552    assert_equals(rsReader.constructor.length, 1, 'constructor has 1 parameter');
    5653    assert_equals(typeof rsReader.read, 'function', 'has a getReader method');
    57     assert_equals(rsReader.read.length, 0);
     54    assert_equals(rsReader.read.length, 0, 'read has no parameters');
    5855    assert_equals(typeof rsReader.releaseLock, 'function', 'has a releaseLock method');
    59     assert_equals(rsReader.releaseLock.length, 0);
    60 
    61 }, 'ReadableStream instances should have the correct list of properties');
     56    assert_equals(rsReader.releaseLock.length, 0, 'releaseLock has no parameters');
     57}, 'ReadableStreamReader instances should have the correct list of properties');
    6258
    6359test(function() {
    6460    var rsReader = new ReadableStreamReader(new ReadableStream());
    6561
    66     assert_equals(rsReader.closed, rsReader.closed);
     62    assert_equals(rsReader.closed, rsReader.closed, 'closed should return the same promise');
    6763}, 'ReadableStreamReader closed should always return the same promise object');
    6864
    … …  
    317313    }));
    318314});
    319 
    320 test(function() {
    321     var rs = new ReadableStream({});
    322     rs.getReader();
    323     window.gc();
    324     assert_throws(new TypeError(), function() { rs.getReader(); });
    325 }, 'Collecting a ReadableStreamReader should not unlock its stream');
    326315</script>

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

    r182629 r182783  
    1313
    1414test(function() {
    15     assert_throws(new TypeError(), function() {
    16         new ReadableStream(null);
    17     }, 'constructor can\'t receive null');
    18 }, 'ReadableStream can\'t be constructed with garbage');
    19 
    20 test(function() {
     15    var methods = ['cancel', 'constructor', 'getReader', 'pipeThrough', 'pipeTo', 'tee'];
     16
    2117    var rs = new ReadableStream();
    22 
    23     assert_array_equals(Object.getOwnPropertyNames(rs), []);
    24     assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(rs)).sort(), ['cancel', 'constructor', 'getReader', 'pipeThrough', 'pipeTo', 'tee']);
    25 
    26     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').enumerable, 'cancel method is enumerable');
    27     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').configurable, 'cancel method is configurable');
    28     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').writable, 'cancel method is writable');
    29 
    30     assert_false(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').enumerable, 'constructor method is not enumerable');
    31     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').configurable, 'constructor method is configurable');
    32     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').writable, 'constructor method is writable');
    33 
    34     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').enumerable, 'getReader method is enumerable');
    35     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').configurable, 'getReader method is configurable');
    36     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').writable, 'getReader method is writable');
    37 
    38     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').enumerable, 'pipeThrough method is enumerable');
    39     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').configurable, 'pipeThrough method is configurable');
    40     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').writable, 'pipeThrough method is writable');
    41 
    42     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').enumerable, 'pipeTo method is enumerable');
    43     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').configurable, 'pipeTo method is configurable');
    44     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').writable, 'pipeTo method is writable');
    45 
    46     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').enumerable, 'tee method is enumerable');
    47     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').configurable, 'tee method is configurable');
    48     assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').writable, 'tee method is writable');
    49 
    50     assert_equals(typeof rs.cancel, 'function', 'has a cancel method');
    51     assert_equals(rs.cancel.length, 1, 'cancel has 1 parameter');
    52     assert_equals(typeof rs.constructor, 'function', 'has a constructor method');
    53     assert_equals(rs.constructor.length, 0), 'constructor has no parameters';
    54     assert_equals(typeof rs.getReader, 'function', 'has a getReader method');
    55     assert_equals(rs.getReader.length, 0, 'getReader has no parameters');
    56     assert_equals(typeof rs.pipeThrough, 'function', 'has a pipeThrough method');
    57     assert_equals(rs.pipeThrough.length, 2, 'pipeThrough has 2 parameters');
    58     assert_equals(typeof rs.pipeTo, 'function', 'has a pipeTo method');
    59     assert_equals(rs.pipeTo.length, 1, 'pipeTo has 1 parameter');
    60     assert_equals(typeof rs.tee, 'function', 'has a tee method');
    61     assert_equals(rs.tee.length, 0, 'tee has no parameters');
    62 
     18    var proto = Object.getPrototypeOf(rs);
     19
     20    assert_array_equals(Object.getOwnPropertyNames(proto).sort(), methods, 'should have all the correct methods');
     21
     22    for (var m of methods) {
     23        var propDesc = Object.getOwnPropertyDescriptor(proto, m);
     24        assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
     25        assert_equals(propDesc.configurable, true, 'method should be configurable');
     26        assert_equals(propDesc.writable, true, 'method should be writable');
     27        assert_equals(typeof rs[m], 'function', 'should have be a method');
     28    }
     29
     30    assert_equals(rs.cancel.length, 1, 'cancel should have 1 parameter');
     31    assert_equals(rs.constructor.length, 0, 'constructor should have no parameters');
     32    assert_equals(rs.getReader.length, 0, 'getReader should have no parameters');
     33    assert_equals(rs.pipeThrough.length, 2, 'pipeThrough should have 2 parameters');
     34    assert_equals(rs.pipeTo.length, 1, 'pipeTo should have 1 parameter');
     35    assert_equals(rs.tee.length, 0, 'tee should have no parameters');
    6336}, 'ReadableStream instances should have the correct list of properties');
    6437
    … …  
    6639    assert_throws(new TypeError(), function() {
    6740        new ReadableStream({ start: 'potato'});
    68     }, 'constructor should throw when start is a string');
    69 }, 'ReadableStream constructor should get a function as start argument');
    70 
    71 test(function()
    72 {
    73     var isStartCalled = false;
    74     var source = {
    75         start: function(controller) {
    76             assert_equals(this, source);
    77 
    78             assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
    79 
    80             var enqueue = controller.enqueue;
    81             var close = controller.close;
    82             var error = controller.error;
    83 
    84             assert_equals(typeof enqueue, 'function');
    85             assert_equals(typeof close, 'function');
    86             assert_equals(typeof error, 'function');
    87 
    88             assert_array_equals(Object.getOwnPropertyNames(enqueue).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
    89             assert_array_equals(Object.getOwnPropertyNames(close).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
    90             assert_array_equals(Object.getOwnPropertyNames(error).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
    91 
    92             assert_equals(enqueue.name, '');
    93             assert_equals(close.name, '');
    94             assert_equals(error.name, '');
    95 
    96             assert_equals(enqueue.length, 1);
    97             assert_equals(close.length, 0);
    98             assert_equals(error.length, 1);
    99 
    100             isStartCalled = true;
    101         }
    102     };
    103 
    104     var rs = new ReadableStream(source);
    105     assert_true(isStartCalled);
    106 }, 'ReadableStream start should be called with the proper parameters');
    107 
    108 test(function()
    109 {
    110     var isStartCalled = false;
    111     var source = {
    112         start: function(controller) {
    113             assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
    114             controller.test = "";
    115             assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
    116             assert_not_equals(Object.getOwnPropertyNames(controller).indexOf('test'));
    117 
    118             isStartCalled = true;
    119         }
    120     };
    121 
    122     var rs = new ReadableStream(source);
    123     assert_true(isStartCalled);
    124 }, 'ReadableStream start controller parameter should be updatable');
    125 
    126 test(function()
    127 {
    128     var isStartCalled = false;
    129 
    130     var SimpleStreamSource = function() { };
    131     SimpleStreamSource.prototype.start = function() { isStartCalled = true; };
    132     SimpleStreamSource.prototype.constructor = SimpleStreamSource;
    133 
    134     var rs = new ReadableStream(new SimpleStreamSource());
    135     assert_true(isStartCalled);
    136 }, 'ReadableStream should be able to call start method within prototype chain of its source');
     41    }, 'constructor should throw when start is not a function');
     42}, 'ReadableStream constructor should throw for non-function start arguments');
    13743
    13844test(function() {
    … …  
    16874    reader.read().then(test1.step_func(function(r) {
    16975        readCalled = true;
    170         assert_object_equals(r, { value: 'a', done: false }, 'read value correctly');
     76        assert_object_equals(r, { value: 'a', done: false }, 'value read should be the one enqueued');
    17177    }));
    17278
    17379    reader.closed.then(test1.step_func(function() {
    17480        assert_true(readCalled);
    175         test1.done('stream successfully closed');
     81        test1.done('stream should close successfully');
    17682    }));
    17783});
    … …  
    18086test2.step(function()
    18187{
    182     var theError = new Error("rejected!");
     88    var theError = new Error('rejected!');
    18389    var rs = new ReadableStream({
    18490        start: function() {
    … …  
    19298
    19399    rs.getReader().closed.catch(test2.step_func(function(e) {
    194         assert_equals(e, theError, 'promise is rejected with the same error');
     100        assert_equals(e, theError, 'promise should be rejected with the same error');
    195101        test2.done();
    196102    }));
    197103});
    198104
    199 var test3 = async_test('ReadableStream should be able to queue different objects.');
     105var test3 = async_test('ReadableStream should be able to enqueue different objects.');
    200106test3.step(function() {
    201107    var readCalls = 0;
    … …  
    208114    var rs = new ReadableStream({
    209115        start: function(c) {
    210             for (var i = 0; i < objects.length; i++) {
    211                 c.enqueue(objects[i]);
     116            for (var o of objects) {
     117                c.enqueue(o);
    212118            }
    213119            c.close();
    … …  
    218124
    219125    reader.read().then(test3.step_func(function(r) {
    220         assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
     126        assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
    221127    }));
    222128
    223129    reader.read().then(test3.step_func(function(r) {
    224         assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
     130        assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
    225131    }));
    226132
    227133    reader.read().then(test3.step_func(function(r) {
    228         assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
     134        assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
    229135    }));
    230136
    231137    reader.closed.then(test3.step_func(function() {
    232138        assert_equals(readCalls, 3);
    233         test3.done('stream was closed correctly');
     139        test3.done('stream should close correctly correctly');
    234140    }));
    235141});
Note: See TracChangeset for help on using the changeset viewer.