Added: trunk/LayoutTests/streams/readable-stream.html (0 => 182783)
--- trunk/LayoutTests/streams/readable-stream.html (rev 0)
+++ trunk/LayoutTests/streams/readable-stream.html 2015-04-14 08:20:40 UTC (rev 182783)
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<script src=''></script>
+<script src=''></script>
+<script>
+test(function() {
+ assert_throws(new TypeError(), function() {
+ new ReadableStream(null);
+ }, 'constructor should throw when the source is null');
+}, 'ReadableStream can\'t be constructed with garbage');
+
+test(function()
+{
+ var isStartCalled = false;
+ var source = {
+ start: function(controller) {
+ assert_equals(this, source, 'source is this during start');
+
+ var unnamedMethods = [ 'close', 'enqueue', 'error' ];
+ var methods = unnamedMethods.concat(['constructor']).sort();
+ var proto = Object.getPrototypeOf(controller);
+
+ assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), methods,
+ 'the controller should have the right methods');
+
+ for (var m of unnamedMethods) {
+ assert_equals(controller[m].name, '', 'method should have no name');
+ }
+
+ for (var m of methods) {
+ var methodProperties = [ 'arguments', 'caller', 'length', 'name', 'prototype' ];
+ var propDesc = Object.getOwnPropertyDescriptor(proto, m);
+ assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
+ assert_equals(propDesc.configurable, true, 'method should be configurable');
+ assert_equals(propDesc.writable, true, 'method should be writable');
+ assert_equals(typeof controller[m], 'function', 'should have be a method');
+ assert_array_equals(Object.getOwnPropertyNames(controller[m]).sort(), methodProperties, 'method should have the right properties');
+ }
+
+ assert_equals(controller.close.length, 0, 'close should have no parameters');
+ assert_equals(controller.constructor.length, 1, 'constructor should have 1 parameters');
+ assert_equals(controller.enqueue.length, 1, 'enqueue should have 1 parameter');
+ assert_equals(controller.error.length, 1, 'error should have 1 parameter');
+
+ isStartCalled = true;
+ }
+ };
+
+ var rs = new ReadableStream(source);
+ assert_true(isStartCalled);
+}, 'ReadableStream start should be called with the proper parameters');
+
+test(function()
+{
+ var isStartCalled = false;
+ var source = {
+ start: function(controller) {
+ const methods = [ 'close', 'constructor', 'enqueue', 'error' ];
+ assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), methods, 'prototype should have the right methods');
+ controller.test = "";
+ assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), methods, 'prototype should still have the right methods');
+ assert_not_equals(Object.getOwnPropertyNames(controller).indexOf('test'), '\'test\' is a property of the controller');
+
+ isStartCalled = true;
+ }
+ };
+
+ var rs = new ReadableStream(source);
+ assert_true(isStartCalled);
+}, 'ReadableStream start controller parameter should be updatable');
+
+test(function()
+{
+ var isStartCalled = false;
+
+ var SimpleStreamSource = function() { };
+ SimpleStreamSource.prototype.start = function() { isStartCalled = true; };
+ SimpleStreamSource.prototype.constructor = SimpleStreamSource;
+
+ var rs = new ReadableStream(new SimpleStreamSource());
+ assert_true(isStartCalled);
+}, 'ReadableStream should be able to call start method within prototype chain of its source');
+</script>
Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html (182782 => 182783)
--- trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html 2015-04-14 05:48:23 UTC (rev 182782)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream-reader.html 2015-04-14 08:20:40 UTC (rev 182783)
@@ -1,7 +1,6 @@
<!DOCTYPE html>
<script src=''></script>
<script src=''></script>
-<script src=''></script>
<script src=''></script>
<script>
var ReadableStreamReader;
@@ -24,46 +23,43 @@
}, 'ReadableStreamReader constructor should get a ReadableStream object as argument');
test(function() {
+ var methods = ['cancel', 'constructor', 'read', 'releaseLock'];
+ var properties = methods.concat(['closed']).sort();
+
var rsReader = new ReadableStreamReader(new ReadableStream());
+ var proto = Object.getPrototypeOf(rsReader);
- // assert_array_equals(Object.getOwnPropertyNames(rsReader), []);
- assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(rsReader)).sort(), [ 'cancel', 'closed', 'constructor', 'read', 'releaseLock' ]);
+ assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').enumerable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').configurable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'cancel').writable);
+ for (var m of methods) {
+ var propDesc = Object.getOwnPropertyDescriptor(proto, m);
+ assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
+ assert_equals(propDesc.configurable, true, 'method should be configurable');
+ assert_equals(propDesc.writable, true, 'method should be writable');
+ assert_equals(typeof rsReader[m], 'function', 'should have be a method');
+ }
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'closed').enumerable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'closed').configurable);
+ var closedPropDesc = Object.getOwnPropertyDescriptor(proto, 'closed');
+ assert_equals(closedPropDesc.enumerable, false, 'closed should be non-enumerable');
+ assert_equals(closedPropDesc.configurable, true, 'closed should be configurable');
+ assert_not_equals(closedPropDesc.get, undefined, 'closed should have a getter');
+ assert_equals(closedPropDesc.set, undefined, 'closed should not have a setter');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'constructor').configurable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'constructor').writable);
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').enumerable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').configurable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'read').writable);
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').enumerable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').configurable);
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rsReader), 'releaseLock').writable);
-
- assert_equals(typeof rsReader.cancel, 'function', 'has a cancel method');
- assert_equals(rsReader.cancel.length, 1);
- assert_exists(Object.getPrototypeOf(rsReader), 'closed', 'has a closed property');
+ assert_equals(rsReader.cancel.length, 1, 'cancel has 1 parameter');
+ assert_not_equals(rsReader.closed, undefined, 'has a non-undefined closed property');
assert_equals(typeof rsReader.closed.then, 'function', 'closed property is thenable');
assert_equals(typeof rsReader.constructor, 'function', 'has a constructor method');
assert_equals(rsReader.constructor.length, 1, 'constructor has 1 parameter');
assert_equals(typeof rsReader.read, 'function', 'has a getReader method');
- assert_equals(rsReader.read.length, 0);
+ assert_equals(rsReader.read.length, 0, 'read has no parameters');
assert_equals(typeof rsReader.releaseLock, 'function', 'has a releaseLock method');
- assert_equals(rsReader.releaseLock.length, 0);
+ assert_equals(rsReader.releaseLock.length, 0, 'releaseLock has no parameters');
+}, 'ReadableStreamReader instances should have the correct list of properties');
-}, 'ReadableStream instances should have the correct list of properties');
-
test(function() {
var rsReader = new ReadableStreamReader(new ReadableStream());
- assert_equals(rsReader.closed, rsReader.closed);
+ assert_equals(rsReader.closed, rsReader.closed, 'closed should return the same promise');
}, 'ReadableStreamReader closed should always return the same promise object');
test(function() {
@@ -316,11 +312,4 @@
test8.done();
}));
});
-
-test(function() {
- var rs = new ReadableStream({});
- rs.getReader();
- window.gc();
- assert_throws(new TypeError(), function() { rs.getReader(); });
-}, 'Collecting a ReadableStreamReader should not unlock its stream');
</script>
Modified: trunk/LayoutTests/streams/reference-implementation/readable-stream.html (182782 => 182783)
--- trunk/LayoutTests/streams/reference-implementation/readable-stream.html 2015-04-14 05:48:23 UTC (rev 182782)
+++ trunk/LayoutTests/streams/reference-implementation/readable-stream.html 2015-04-14 08:20:40 UTC (rev 182783)
@@ -12,129 +12,35 @@
}, 'ReadableStream can be constructed with no errors');
test(function() {
- assert_throws(new TypeError(), function() {
- new ReadableStream(null);
- }, 'constructor can\'t receive null');
-}, 'ReadableStream can\'t be constructed with garbage');
+ var methods = ['cancel', 'constructor', 'getReader', 'pipeThrough', 'pipeTo', 'tee'];
-test(function() {
var rs = new ReadableStream();
+ var proto = Object.getPrototypeOf(rs);
- assert_array_equals(Object.getOwnPropertyNames(rs), []);
- assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(rs)).sort(), ['cancel', 'constructor', 'getReader', 'pipeThrough', 'pipeTo', 'tee']);
+ assert_array_equals(Object.getOwnPropertyNames(proto).sort(), methods, 'should have all the correct methods');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').enumerable, 'cancel method is enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').configurable, 'cancel method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'cancel').writable, 'cancel method is writable');
+ for (var m of methods) {
+ var propDesc = Object.getOwnPropertyDescriptor(proto, m);
+ assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
+ assert_equals(propDesc.configurable, true, 'method should be configurable');
+ assert_equals(propDesc.writable, true, 'method should be writable');
+ assert_equals(typeof rs[m], 'function', 'should have be a method');
+ }
- assert_false(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').enumerable, 'constructor method is not enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').configurable, 'constructor method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'constructor').writable, 'constructor method is writable');
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').enumerable, 'getReader method is enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').configurable, 'getReader method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'getReader').writable, 'getReader method is writable');
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').enumerable, 'pipeThrough method is enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').configurable, 'pipeThrough method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeThrough').writable, 'pipeThrough method is writable');
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').enumerable, 'pipeTo method is enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').configurable, 'pipeTo method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'pipeTo').writable, 'pipeTo method is writable');
-
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').enumerable, 'tee method is enumerable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').configurable, 'tee method is configurable');
- assert_true(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rs), 'tee').writable, 'tee method is writable');
-
- assert_equals(typeof rs.cancel, 'function', 'has a cancel method');
- assert_equals(rs.cancel.length, 1, 'cancel has 1 parameter');
- assert_equals(typeof rs.constructor, 'function', 'has a constructor method');
- assert_equals(rs.constructor.length, 0), 'constructor has no parameters';
- assert_equals(typeof rs.getReader, 'function', 'has a getReader method');
- assert_equals(rs.getReader.length, 0, 'getReader has no parameters');
- assert_equals(typeof rs.pipeThrough, 'function', 'has a pipeThrough method');
- assert_equals(rs.pipeThrough.length, 2, 'pipeThrough has 2 parameters');
- assert_equals(typeof rs.pipeTo, 'function', 'has a pipeTo method');
- assert_equals(rs.pipeTo.length, 1, 'pipeTo has 1 parameter');
- assert_equals(typeof rs.tee, 'function', 'has a tee method');
- assert_equals(rs.tee.length, 0, 'tee has no parameters');
-
+ assert_equals(rs.cancel.length, 1, 'cancel should have 1 parameter');
+ assert_equals(rs.constructor.length, 0, 'constructor should have no parameters');
+ assert_equals(rs.getReader.length, 0, 'getReader should have no parameters');
+ assert_equals(rs.pipeThrough.length, 2, 'pipeThrough should have 2 parameters');
+ assert_equals(rs.pipeTo.length, 1, 'pipeTo should have 1 parameter');
+ assert_equals(rs.tee.length, 0, 'tee should have no parameters');
}, 'ReadableStream instances should have the correct list of properties');
test(function() {
assert_throws(new TypeError(), function() {
new ReadableStream({ start: 'potato'});
- }, 'constructor should throw when start is a string');
-}, 'ReadableStream constructor should get a function as start argument');
+ }, 'constructor should throw when start is not a function');
+}, 'ReadableStream constructor should throw for non-function start arguments');
-test(function()
-{
- var isStartCalled = false;
- var source = {
- start: function(controller) {
- assert_equals(this, source);
-
- assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
-
- var enqueue = controller.enqueue;
- var close = controller.close;
- var error = controller.error;
-
- assert_equals(typeof enqueue, 'function');
- assert_equals(typeof close, 'function');
- assert_equals(typeof error, 'function');
-
- assert_array_equals(Object.getOwnPropertyNames(enqueue).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
- assert_array_equals(Object.getOwnPropertyNames(close).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
- assert_array_equals(Object.getOwnPropertyNames(error).sort(), [ 'arguments', 'caller', 'length', 'name', 'prototype' ]);
-
- assert_equals(enqueue.name, '');
- assert_equals(close.name, '');
- assert_equals(error.name, '');
-
- assert_equals(enqueue.length, 1);
- assert_equals(close.length, 0);
- assert_equals(error.length, 1);
-
- isStartCalled = true;
- }
- };
-
- var rs = new ReadableStream(source);
- assert_true(isStartCalled);
-}, 'ReadableStream start should be called with the proper parameters');
-
-test(function()
-{
- var isStartCalled = false;
- var source = {
- start: function(controller) {
- assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
- controller.test = "";
- assert_array_equals(Object.getOwnPropertyNames(Object.getPrototypeOf(controller)).sort(), [ 'close', 'constructor', 'enqueue', 'error' ]);
- assert_not_equals(Object.getOwnPropertyNames(controller).indexOf('test'));
-
- isStartCalled = true;
- }
- };
-
- var rs = new ReadableStream(source);
- assert_true(isStartCalled);
-}, 'ReadableStream start controller parameter should be updatable');
-
-test(function()
-{
- var isStartCalled = false;
-
- var SimpleStreamSource = function() { };
- SimpleStreamSource.prototype.start = function() { isStartCalled = true; };
- SimpleStreamSource.prototype.constructor = SimpleStreamSource;
-
- var rs = new ReadableStream(new SimpleStreamSource());
- assert_true(isStartCalled);
-}, 'ReadableStream should be able to call start method within prototype chain of its source');
-
test(function() {
new ReadableStream({ cancel: '2'}); // Constructor should not throw when cancel is not a function.
}, 'ReadableStream constructor can get initial garbage as cancel argument');
@@ -167,19 +73,19 @@
reader.read().then(test1.step_func(function(r) {
readCalled = true;
- assert_object_equals(r, { value: 'a', done: false }, 'read value correctly');
+ assert_object_equals(r, { value: 'a', done: false }, 'value read should be the one enqueued');
}));
reader.closed.then(test1.step_func(function() {
assert_true(readCalled);
- test1.done('stream successfully closed');
+ test1.done('stream should close successfully');
}));
});
var test2 = async_test('ReadableStream start should be able to return a promise and reject it', { timeout: 100 });
test2.step(function()
{
- var theError = new Error("rejected!");
+ var theError = new Error('rejected!');
var rs = new ReadableStream({
start: function() {
return new Promise(test2.step_func(function(resolve, reject) {
@@ -191,12 +97,12 @@
});
rs.getReader().closed.catch(test2.step_func(function(e) {
- assert_equals(e, theError, 'promise is rejected with the same error');
+ assert_equals(e, theError, 'promise should be rejected with the same error');
test2.done();
}));
});
-var test3 = async_test('ReadableStream should be able to queue different objects.');
+var test3 = async_test('ReadableStream should be able to enqueue different objects.');
test3.step(function() {
var readCalls = 0;
var objects = [
@@ -207,8 +113,8 @@
var rs = new ReadableStream({
start: function(c) {
- for (var i = 0; i < objects.length; i++) {
- c.enqueue(objects[i]);
+ for (var o of objects) {
+ c.enqueue(o);
}
c.close();
}
@@ -217,20 +123,20 @@
var reader = rs.getReader();
reader.read().then(test3.step_func(function(r) {
- assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
+ assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
}));
reader.read().then(test3.step_func(function(r) {
- assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
+ assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
}));
reader.read().then(test3.step_func(function(r) {
- assert_object_equals(r, { value: objects[readCalls++], done: false }, 'read value correctly');
+ assert_object_equals(r, { value: objects[readCalls++], done: false }, 'value read should be the one enqueued');
}));
reader.closed.then(test3.step_func(function() {
assert_equals(readCalls, 3);
- test3.done('stream was closed correctly');
+ test3.done('stream should close correctly correctly');
}));
});
