diff --git a/reference-implementation/package.json b/reference-implementation/package.json
index d5c3016cd..414b35d3e 100644
--- a/reference-implementation/package.json
+++ b/reference-implementation/package.json
@@ -6,7 +6,8 @@
"test": "node --expose_gc node_modules/traceur-runner/bin/traceur-runner.js run-tests.js | tap-spec && npm run wpt",
"wpt": "node --expose_gc node_modules/traceur-runner/bin/traceur-runner.js run-web-platform-tests.js",
"bench": "traceur-runner bench/recording-runner.js && traceur-runner bench/recording-differ.js",
- "build-browser-tests": "traceur-runner browser-tests/build.js"
+ "build-browser-tests": "traceur-runner browser-tests/build.js",
+ "lint": "eslint web-platform-tests"
},
"repository": "whatwg/streams",
"keywords": [
@@ -26,6 +27,7 @@
"browserify": "^9.0.7",
"browserify-tape-spec": "^1.1.2",
"es6ify": "^1.6.0",
+ "eslint": "^1.10.1",
"glob": "^5.0.3",
"mkdirp": "^0.5.0",
"ms": "^0.7.0",
diff --git a/reference-implementation/web-platform-tests/.eslintrc b/reference-implementation/web-platform-tests/.eslintrc
new file mode 100644
index 000000000..d50db997f
--- /dev/null
+++ b/reference-implementation/web-platform-tests/.eslintrc
@@ -0,0 +1,292 @@
+{
+ "root": true,
+ "env": {
+ "browser": true
+ },
+ "globals": {
+ "ByteLengthQueuingStrategy": false,
+ "CountQueuingStrategy": false,
+ "ReadableStream": false,
+
+ "GCController": false,
+
+ "EventWatcher": false,
+ "test": false,
+ "async_test": false,
+ "promise_test": false,
+ "promise_rejects": false,
+ "generate_tests": false,
+ "setup": false,
+ "done": false,
+ "on_event": false,
+ "step_timeout": false,
+ "format_value": false,
+ "assert_true": false,
+ "assert_false": false,
+ "assert_equals": false,
+ "assert_not_equals": false,
+ "assert_in_array": false,
+ "assert_object_equals": false,
+ "assert_array_equals": false,
+ "assert_approx_equals": false,
+ "assert_less_than": false,
+ "assert_greater_than": false,
+ "assert_between_exclusive": false,
+ "assert_less_than_equal": false,
+ "assert_greater_than_equal": false,
+ "assert_between_inclusive": false,
+ "assert_regexp_match": false,
+ "assert_class_string": false,
+ "assert_exists": false,
+ "assert_own_property": false,
+ "assert_not_exists": false,
+ "assert_inherits": false,
+ "assert_idl_attribute": false,
+ "assert_readonly": false,
+ "assert_throws": false,
+ "assert_unreached": false,
+ "assert_any": false,
+ "fetch_tests_from_worker": false,
+ "timeout": false,
+ "add_start_callback": false,
+ "add_test_state_callback": false,
+ "add_result_callback": false,
+ "add_completion_callback": false,
+
+ "getterRejects": true,
+ "methodRejects": true,
+ "getterThrows": true,
+ "methodThrows": true,
+ "garbageCollect": true,
+ "delay": true,
+
+ "RandomPushSource": true,
+ "readableStreamToArray": true,
+ "sequentialReadableStream": true,
+
+ "templatedRSEmpty": true,
+ "templatedRSEmptyReader": true,
+ "templatedRSClosed": true,
+ "templatedRSClosedReader": true,
+ "templatedRSErrored": true,
+ "templatedRSErroredSyncOnly": true,
+ "templatedRSErroredReader": true,
+ "templatedRSTwoChunksOpenReader": true,
+ "templatedRSTwoChunksClosedReader": true
+ },
+ "ecmaFeatures": {
+ "arrowFunctions": true,
+ "binaryLiterals": true,
+ "blockBindings": true,
+ "classes": true,
+ "defaultParams": false,
+ "destructuring": false,
+ "forOf": true,
+ "generators": true,
+ "modules": false,
+ "objectLiteralComputedProperties": true,
+ "objectLiteralDuplicateProperties": true,
+ "objectLiteralShorthandMethods": true,
+ "objectLiteralShorthandProperties": true,
+ "octalLiterals": true,
+ "regexUFlag": false,
+ "regexYFlag": false,
+ "restParams": false,
+ "spread": false,
+ "superInFunctions": false,
+ "templateStrings": true,
+ "unicodeCodePointEscapes": true
+ },
+ "rules": {
+ // Possible errors
+ "comma-dangle": [2, "never"],
+ "no-cond-assign": [2, "except-parens"],
+ "no-console": 2,
+ "no-constant-condition": 2,
+ "no-control-regex": 2,
+ "no-debugger": 2,
+ "no-dupe-args": 2,
+ "no-dupe-keys": 2,
+ "no-duplicate-case": 2,
+ "no-empty-character-class": 2,
+ "no-empty": 2,
+ "no-ex-assign": 2,
+ "no-extra-boolean-cast": 2,
+ "no-extra-parens": 0, // https://github.com/eslint/eslint/issues/3065
+ "no-extra-semi": 2,
+ "no-func-assign": 2,
+ "no-inner-declarations": 0,
+ "no-invalid-regexp": 2,
+ "no-irregular-whitespace": 2,
+ "no-negated-in-lhs": 2,
+ "no-obj-calls": 2,
+ "no-regex-spaces": 2,
+ "no-sparse-arrays": 2,
+ "no-unreachable": 2,
+ "use-isnan": 2,
+ "valid-jsdoc": 0,
+ "valid-typeof": 2,
+ "no-unexpected-multiline": 2,
+
+ // Best practices
+ "accessor-pairs": 2,
+ "block-scoped-var": 0,
+ "complexity": 0,
+ "consistent-return": 2,
+ "curly": [2, "all"],
+ "default-case": 0,
+ "dot-notation": 2,
+ "dot-location": [2, "property"],
+ "eqeqeq": 2,
+ "guard-for-in": 0,
+ "no-alert": 0,
+ "no-caller": 2,
+ "no-div-regex": 0,
+ "no-else-return": 2,
+ "no-empty-label": 2,
+ "no-eq-null": 2,
+ "no-eval": 2,
+ "no-extend-native": 2,
+ "no-extra-bind": 2,
+ "no-fallthrough": 2,
+ "no-floating-decimal": 2,
+ "no-implicit-coercion": 2,
+ "no-implied-eval": 0,
+ "no-invalid-this": 0, // meh
+ "no-iterator": 2,
+ "no-labels": 0,
+ "no-lone-blocks": 0,
+ "no-loop-func": 0,
+ "no-multi-spaces": 2,
+ "no-multi-str": 2,
+ "no-native-reassign": 2,
+ "no-new-func": 0,
+ "no-new-wrappers": 2,
+ "no-new": 0,
+ "no-octal-escape": 2,
+ "no-octal": 2,
+ "no-param-reassign": 0,
+ "no-process-env": 2,
+ "no-proto": 2,
+ "no-redeclare": 2,
+ "no-return-assign": [2, "always"],
+ "no-script-url": 0,
+ "no-self-compare": 2,
+ "no-sequences": 2,
+ "no-throw-literal": 2,
+ "no-unused-expressions": 2,
+ "no-useless-call": 2,
+ "no-useless-concat": 2,
+ "no-void": 2,
+ "no-warning-comments": 0,
+ "no-with": 2,
+ "radix": 0,
+ "vars-on-top": 0,
+ "wrap-iife": [2, "outside"],
+ "yoda": [2, "never"],
+
+ // Strict Mode
+ "strict": [2, "global"],
+
+ // Variables
+ "init-declarations": 0,
+ "no-catch-shadow": 2,
+ "no-delete-var": 2,
+ "no-label-var": 2,
+ "no-shadow-restricted-names": 2,
+ "no-shadow": 2,
+ "no-undef-init": 2,
+ "no-undef": 2,
+ "no-undefined": 0,
+ "no-unused-vars": 2,
+ "no-use-before-define": [2, "nofunc"],
+
+ // Node.js and CommonJS
+ "callback-return": 0,
+ "global-require": 2,
+ "handle-callback-err": 2,
+ "no-mixed-requires": [2, true],
+ "no-new-require": 2,
+ "no-path-concat": 2,
+ "no-process-exit": 0,
+ "no-restricted-modules": [2, "url"],
+ "no-sync": 0,
+
+ // Stylistic Issues
+ "array-bracket-spacing": [2, "never"],
+ "block-spacing": [2, "always"],
+ "brace-style": [2, "1tbs", { "allowSingleLine": true }],
+ "camelcase": [2, { "properties": "always" }],
+ "comma-spacing": [2, { "before": false, "after": true }],
+ "comma-style": [2, "last"],
+ "computed-property-spacing": [2, "never"],
+ "consistent-this": 0,
+ "eol-last": 2,
+ "func-names": 0,
+ "func-style": [2, "declaration"],
+ "id-length": 0,
+ "id-match": 0,
+ "indent": [2, 2, { "SwitchCase": 1 }],
+ "jsx-quotes": 0,
+ "key-spacing": [2, { "beforeColon": false, "afterColon": true, "mode": "strict" }],
+ "lines-around-comment": 0,
+ "linebreak-style": [2, "unix"],
+ "max-nested-callbacks": 0,
+ "new-cap": 2,
+ "new-parens": 2,
+ "newline-after-var": 0,
+ "no-array-constructor": 2,
+ "no-continue": 0,
+ "no-inline-comments": 0,
+ "no-lonely-if": 2,
+ "no-mixed-spaces-and-tabs": 2,
+ "no-multiple-empty-lines": 2,
+ "no-nested-ternary": 2,
+ "no-new-object": 2,
+ "no-restricted-syntax": 0,
+ "no-spaced-func": 2,
+ "no-ternary": 0,
+ "no-trailing-spaces": 2,
+ "no-underscore-dangle": 0,
+ "no-unneeded-ternary": 2,
+ "object-curly-spacing": [2, "always"],
+ "one-var": [2, "never"],
+ "operator-assignment": [2, "always"],
+ "operator-linebreak": [2, "after"],
+ "padded-blocks": 0,
+ "quote-props": [2, "as-needed"],
+ "quotes": [2, "single"],
+ "require-jsdoc": 0,
+ "semi-spacing": 2,
+ "semi": [2, "always"],
+ "sort-vars": 0,
+ "space-after-keywords": [2, "always"],
+ "space-before-keywords": [2, "always"],
+ "space-before-blocks": [2, "always"],
+ "space-before-function-paren": [2, { "anonymous": "always", "named": "never" }],
+ "space-in-parens": [2, "never"],
+ "space-infix-ops": 2,
+ "space-return-throw-case": 2,
+ "space-unary-ops": [2, { "words": true, "nonwords": false }],
+ "spaced-comment": [2, "always", { "markers": ["///"] }],
+ "wrap-regex": 0,
+
+ // ECMAScript 6
+ "arrow-parens": [2, "as-needed"],
+ "arrow-spacing": 2,
+ "constructor-super": 2,
+ "generator-star-spacing": [2, "after"],
+ "no-class-assign": 2,
+ "no-const-assign": 2,
+ "no-dupe-class-members": 2,
+ "no-this-before-super": 2,
+ "no-var": 2,
+ "object-shorthand": 2,
+ "prefer-arrow-callback": 2,
+ "prefer-const": 2,
+ "prefer-spread": 0,
+ "prefer-reflect": 0,
+ "prefer-template": 0,
+ "require-yield": 2
+ }
+}
diff --git a/reference-implementation/web-platform-tests/byte-length-queuing-strategy.js b/reference-implementation/web-platform-tests/byte-length-queuing-strategy.js
index c133f9fb1..54407af99 100644
--- a/reference-implementation/web-platform-tests/byte-length-queuing-strategy.js
+++ b/reference-implementation/web-platform-tests/byte-length-queuing-strategy.js
@@ -6,7 +6,7 @@ if (self.importScripts) {
test(() => {
- const strategy = new ByteLengthQueuingStrategy({ highWaterMark: 4 });
+ new ByteLengthQueuingStrategy({ highWaterMark: 4 });
}, 'Can construct a ByteLengthQueuingStrategy with a valid high water mark');
@@ -23,11 +23,11 @@ test(() => {
const highWaterMark = 1;
const highWaterMarkObjectGetter = {
- get highWaterMark() { return highWaterMark; },
+ get highWaterMark() { return highWaterMark; }
};
const error = new Error('wow!');
const highWaterMarkObjectGetterThrowing = {
- get highWaterMark() { throw error; },
+ get highWaterMark() { throw error; }
};
assert_throws({ name: 'TypeError' }, () => new ByteLengthQueuingStrategy(), 'construction fails with undefined');
@@ -47,12 +47,12 @@ test(() => {
const size = 1024;
const chunk = { byteLength: size };
const chunkGetter = {
- get byteLength() { return size; },
- }
+ get byteLength() { return size; }
+ };
const error = new Error('wow!');
const chunkGetterThrowing = {
- get byteLength() { throw error; },
- }
+ get byteLength() { throw error; }
+ };
assert_throws({ name: 'TypeError' }, () => ByteLengthQueuingStrategy.prototype.size(), 'size fails with undefined');
assert_throws({ name: 'TypeError' }, () => ByteLengthQueuingStrategy.prototype.size(null), 'size fails with null');
assert_equals(ByteLengthQueuingStrategy.prototype.size('potato'), undefined,
@@ -73,9 +73,7 @@ test(() => {
const thisValue = null;
const returnValue = { 'returned from': 'byteLength getter' };
const chunk = {
- get byteLength() {
- return returnValue;
- }
+ get byteLength() { return returnValue; }
};
assert_equals(ByteLengthQueuingStrategy.prototype.size.call(thisValue, chunk), returnValue);
@@ -101,8 +99,8 @@ test(() => {
strategy.highWaterMark = 10;
assert_equals(strategy.highWaterMark, 10);
- strategy.highWaterMark = "banana";
- assert_equals(strategy.highWaterMark, "banana");
+ strategy.highWaterMark = 'banana';
+ assert_equals(strategy.highWaterMark, 'banana');
}, 'ByteLengthQueuingStrategy\'s highWaterMark property can be set to anything');
diff --git a/reference-implementation/web-platform-tests/count-queuing-strategy.js b/reference-implementation/web-platform-tests/count-queuing-strategy.js
index c98fdf5a7..5ae0063f5 100644
--- a/reference-implementation/web-platform-tests/count-queuing-strategy.js
+++ b/reference-implementation/web-platform-tests/count-queuing-strategy.js
@@ -6,7 +6,7 @@ if (self.importScripts) {
test(() => {
- const strategy = new CountQueuingStrategy({ highWaterMark: 4 });
+ new CountQueuingStrategy({ highWaterMark: 4 });
}, 'Can construct a CountQueuingStrategy with a valid high water mark');
@@ -23,11 +23,11 @@ test(() => {
const highWaterMark = 1;
const highWaterMarkObjectGetter = {
- get highWaterMark() { return highWaterMark; },
+ get highWaterMark() { return highWaterMark; }
};
const error = new Error('wow!');
const highWaterMarkObjectGetterThrowing = {
- get highWaterMark() { throw error; },
+ get highWaterMark() { throw error; }
};
assert_throws({ name: 'TypeError' }, () => new CountQueuingStrategy(), 'construction fails with undefined');
@@ -61,12 +61,12 @@ test(() => {
const size = 1024;
const chunk = { byteLength: size };
const chunkGetter = {
- get byteLength() { return size; },
- }
+ get byteLength() { return size; }
+ };
const error = new Error('wow!');
const chunkGetterThrowing = {
- get byteLength() { throw error; },
- }
+ get byteLength() { throw error; }
+ };
assert_equals(CountQueuingStrategy.prototype.size(), 1, 'size returns 1 with undefined');
assert_equals(CountQueuingStrategy.prototype.size(null), 1, 'size returns 1 with null');
@@ -98,8 +98,8 @@ test(() => {
strategy.highWaterMark = 10;
assert_equals(strategy.highWaterMark, 10);
- strategy.highWaterMark = "banana";
- assert_equals(strategy.highWaterMark, "banana");
+ strategy.highWaterMark = 'banana';
+ assert_equals(strategy.highWaterMark, 'banana');
}, 'CountQueuingStrategy\'s highWaterMark property can be set to anything');
diff --git a/reference-implementation/web-platform-tests/readable-streams/bad-strategies.js b/reference-implementation/web-platform-tests/readable-streams/bad-strategies.js
index 0fa63d68e..7d085c76a 100644
--- a/reference-implementation/web-platform-tests/readable-streams/bad-strategies.js
+++ b/reference-implementation/web-platform-tests/readable-streams/bad-strategies.js
@@ -4,114 +4,119 @@ if (self.importScripts) {
self.importScripts('/resources/testharness.js');
}
-test(function() {
- var theError = new Error('a unique string');
-
- assert_throws(theError, function() {
- new ReadableStream({}, {
- get size() {
- throw theError;
- },
- highWaterMark: 5
- });
- }, 'construction should re-throw the error');
+test(() => {
+
+ const theError = new Error('a unique string');
+
+ assert_throws(theError, () => {
+ new ReadableStream({}, {
+ get size() {
+ throw theError;
+ },
+ highWaterMark: 5
+ });
+ }, 'construction should re-throw the error');
+
}, 'Readable stream: throwing strategy.size getter');
-var test1 = async_test('Readable stream: throwing strategy.size method');
-test1.step(function() {
- var theError = new Error('a unique string');
- var rs = new ReadableStream(
- {
- start: function(c) {
- assert_throws(theError, function() { c.enqueue('a'); }, 'enqueue should throw the error');
- }
- },
- {
- size: function() {
- throw theError;
- },
- highWaterMark: 5
- }
- );
+promise_test(() => {
+
+ const theError = new Error('a unique string');
+ const rs = new ReadableStream(
+ {
+ start(c) {
+ assert_throws(theError, () => c.enqueue('a'), 'enqueue should throw the error');
+ }
+ },
+ {
+ size() {
+ throw theError;
+ },
+ highWaterMark: 5
+ }
+ );
+
+ return rs.getReader().closed.catch(e => {
+ assert_equals(e, theError, 'closed should reject with the error');
+ });
+
+}, 'Readable stream: throwing strategy.size method');
+
+test(() => {
+
+ const theError = new Error('a unique string');
+
+ assert_throws(theError, () => {
+ new ReadableStream({}, {
+ size() {
+ return 1;
+ },
+ get highWaterMark() {
+ throw theError;
+ }
+ });
+ }, 'construction should re-throw the error');
- rs.getReader().closed.catch(test1.step_func(function(e) {
- assert_equals(e, theError, 'closed should reject with the error');
- test1.done();
- }))
-});
-
-test(function() {
- var theError = new Error('a unique string');
-
- assert_throws(theError, function() {
- new ReadableStream({}, {
- size: function() {
- return 1;
- },
- get highWaterMark() {
- throw theError;
- }
- });
- }, 'construction should re-throw the error');
}, 'Readable stream: throwing strategy.highWaterMark getter');
-test(function() {
- for (var highWaterMark of [-1, -Infinity]) {
- assert_throws(new RangeError(), function() {
- new ReadableStream({}, {
- size: function() {
- return 1;
- },
- highWaterMark
- });
- }, 'construction should throw a RangeError for ' + highWaterMark);
- }
+test(() => {
+
+ for (const highWaterMark of [-1, -Infinity]) {
+ assert_throws(new RangeError(), () => {
+ new ReadableStream({}, {
+ size() {
+ return 1;
+ },
+ highWaterMark
+ });
+ }, 'construction should throw a RangeError for ' + highWaterMark);
+ }
+
+ for (const highWaterMark of [NaN, 'foo', {}]) {
+ assert_throws(new TypeError(), () => {
+ new ReadableStream({}, {
+ size() {
+ return 1;
+ },
+ highWaterMark
+ });
+ }, 'construction should throw a TypeError for ' + highWaterMark);
+ }
- for (var highWaterMark of [NaN, 'foo', {}]) {
- assert_throws(new TypeError(), function() {
- new ReadableStream({}, {
- size: function() {
- return 1;
- },
- highWaterMark
- });
- }, 'construction should throw a TypeError for ' + highWaterMark);
- }
}, 'Readable stream: invalid strategy.highWaterMark');
-var test2 = async_test('Readable stream: invalid strategy.size return value');
-test2.step(function() {
- var numberOfCalls = 0;
- var elements = [NaN, -Infinity, +Infinity, -1];
- var theErrors = [];
- for (var i = 0; i < elements.length; i++) {
- var rs = new ReadableStream({
- start: function(c) {
- try {
- c.enqueue('hi');
- assert_unreached('enqueue didn\'t throw');
- } catch (error) {
- assert_equals(error.name, 'RangeError', 'enqueue should throw a RangeError for ' + elements[i]);
- theErrors[i] = error;
- }
- }
+promise_test(() => {
+
+ const promises = [];
+ for (const size of [NaN, -Infinity, Infinity, -1]) {
+ let theError;
+ const rs = new ReadableStream(
+ {
+ start(c) {
+ try {
+ c.enqueue('hi');
+ assert_unreached('enqueue didn\'t throw');
+ } catch (error) {
+ assert_equals(error.name, 'RangeError', 'enqueue should throw a RangeError for ' + size);
+ theError = error;
+ }
+ }
+ },
+ {
+ size() {
+ return size;
},
- {
- size: function() {
- return elements[i];
- },
- highWaterMark: 5
- });
-
- var catchFunction = function(i, e) {
- assert_equals(e, theErrors[i], 'closed should reject with the error for ' + elements[i]);
- if (++numberOfCalls === elements.length) {
- test2.done();
- }
- };
-
- rs.getReader().closed.catch(test2.step_func(catchFunction.bind(this, i)));
- }
-});
+ highWaterMark: 5
+ }
+ );
+
+ promises.push(rs.getReader().closed.catch(e => {
+ assert_equals(e, theError, 'closed should reject with the error for ' + size);
+ }));
+ }
+
+ return Promise.all(promises);
+
+}, 'Readable stream: invalid strategy.size return value');
done();
diff --git a/reference-implementation/web-platform-tests/readable-streams/bad-underlying-sources.js b/reference-implementation/web-platform-tests/readable-streams/bad-underlying-sources.js
index 6bf585116..f2fd0fdc9 100644
--- a/reference-implementation/web-platform-tests/readable-streams/bad-underlying-sources.js
+++ b/reference-implementation/web-platform-tests/readable-streams/bad-underlying-sources.js
@@ -6,6 +6,7 @@ if (self.importScripts) {
test(() => {
+
const theError = new Error('a unique string');
assert_throws(theError, () => {
@@ -20,6 +21,7 @@ test(() => {
test(() => {
+
const theError = new Error('a unique string');
assert_throws(theError, () => {
@@ -141,7 +143,7 @@ promise_test(t => {
}, 'Underlying source cancel: throwing method');
-promise_test(t => {
+promise_test(() => {
let controller;
const rs = new ReadableStream({
@@ -157,7 +159,7 @@ promise_test(t => {
}, 'Underlying source: calling enqueue on an empty canceled stream should not throw');
-promise_test(t => {
+promise_test(() => {
let controller;
const rs = new ReadableStream({
@@ -175,7 +177,7 @@ promise_test(t => {
}, 'Underlying source: calling enqueue on a non-empty canceled stream should not throw');
-promise_test(t => {
+promise_test(() => {
return new ReadableStream({
start(c) {
@@ -200,7 +202,7 @@ promise_test(t => {
}, 'Underlying source: calling enqueue on an errored stream should throw');
-promise_test(t => {
+promise_test(() => {
return new ReadableStream({
start(c) {
@@ -211,7 +213,7 @@ promise_test(t => {
}, 'Underlying source: calling close twice on an empty stream should throw the second time');
-promise_test(t => {
+promise_test(() => {
let startCalled = false;
let readCalled = false;
@@ -237,7 +239,8 @@ promise_test(t => {
}, 'Underlying source: calling close twice on a non-empty stream should throw the second time');
-promise_test(t => {
+promise_test(() => {
+
let controller;
let startCalled = false;
const rs = new ReadableStream({
@@ -254,9 +257,9 @@ promise_test(t => {
assert_true(startCalled);
});
- }, 'Underlying source: calling close on an empty canceled stream should not throw');
+}, 'Underlying source: calling close on an empty canceled stream should not throw');
-promise_test(t => {
+promise_test(() => {
let controller;
let startCalled = false;
@@ -277,7 +280,7 @@ promise_test(t => {
}, 'Underlying source: calling close on a non-empty canceled stream should not throw');
-promise_test(t => {
+promise_test(() => {
const theError = new Error('boo');
let startCalled = false;
@@ -297,7 +300,7 @@ promise_test(t => {
}, 'Underlying source: calling close after error should throw');
-promise_test(t => {
+promise_test(() => {
const theError = new Error('boo');
let startCalled = false;
@@ -317,7 +320,7 @@ promise_test(t => {
}, 'Underlying source: calling error twice should throw the second time');
-promise_test(t => {
+promise_test(() => {
let startCalled = false;
@@ -333,7 +336,7 @@ promise_test(t => {
}, 'Underlying source: calling error after close should throw');
-promise_test(t => {
+promise_test(() => {
let startCalled = false;
const firstError = new Error('1');
@@ -355,7 +358,7 @@ promise_test(t => {
}, 'Underlying source: calling error and returning a rejected promise from start should cause the stream to error ' +
'with the first error');
-promise_test(t => {
+promise_test(() => {
let startCalled = false;
const firstError = new Error('1');
diff --git a/reference-implementation/web-platform-tests/readable-streams/brand-checks.js b/reference-implementation/web-platform-tests/readable-streams/brand-checks.js
index 422704910..ae8e7a8dc 100644
--- a/reference-implementation/web-platform-tests/readable-streams/brand-checks.js
+++ b/reference-implementation/web-platform-tests/readable-streams/brand-checks.js
@@ -5,118 +5,147 @@ if (self.importScripts) {
self.importScripts('/resources/testharness.js');
}
-var ReadableStreamReader;
-var ReadableStreamController;
+let ReadableStreamReader;
+let ReadableStreamController;
+
+test(() => {
+
+ // It's not exposed globally, but we test a few of its properties here.
+ ReadableStreamReader = (new ReadableStream()).getReader().constructor;
-test(function() {
- // It's not exposed globally, but we test a few of its properties here.
- ReadableStreamReader = (new ReadableStream()).getReader().constructor;
}, 'Can get the ReadableStreamReader constructor indirectly');
-test(function() {
- // It's not exposed globally, but we test a few of its properties here.
- new ReadableStream({
- start: function(c) {
- ReadableStreamController = c.constructor;
- }
- });
+test(() => {
+
+ // It's not exposed globally, but we test a few of its properties here.
+ new ReadableStream({
+ start(c) {
+ ReadableStreamController = c.constructor;
+ }
+ });
+
}, 'Can get the ReadableStreamController constructor indirectly');
function fakeReadableStream() {
- return {
- cancel: function(reason) { return Promise.resolve(); },
- getReader: function() { return new ReadableStreamReader(new ReadableStream()); },
- pipeThrough: function(obj, options) { return obj.readable; },
- pipeTo: function() { return Promise.resolve(); },
- tee: function() { return [realReadableStream(), realReadableStream()]; }
- };
+ return {
+ cancel() { return Promise.resolve(); },
+ getReader() { return new ReadableStreamReader(new ReadableStream()); },
+ pipeThrough(obj) { return obj.readable; },
+ pipeTo() { return Promise.resolve(); },
+ tee() { return [realReadableStream(), realReadableStream()]; }
+ };
}
function realReadableStream() {
- return new ReadableStream();
+ return new ReadableStream();
}
function fakeReadableStreamReader() {
- return {
- get closed() { return Promise.resolve(); },
- cancel: function(reason) { return Promise.resolve(); },
- read: function() { return Promise.resolve({ value: undefined, done: true }); },
- releaseLock: function() { return; }
- };
+ return {
+ get closed() { return Promise.resolve(); },
+ cancel() { return Promise.resolve(); },
+ read() { return Promise.resolve({ value: undefined, done: true }); },
+ releaseLock() { return; }
+ };
}
function fakeReadableStreamController() {
- return {
- close: function() { },
- enqueue: function(chunk) { },
- error: function(e) { }
- };
+ return {
+ close() { },
+ enqueue() { },
+ error() { }
+ };
}
-var test1 = async_test('ReadableStream.prototype.cancel enforces a brand check');
-test1.step(function() {
- methodRejects(test1, ReadableStream.prototype, 'cancel', fakeReadableStream(), true);
-});
+promise_test(t => {
+
+ return methodRejects(t, ReadableStream.prototype, 'cancel', fakeReadableStream(), true);
+
+}, 'ReadableStream.prototype.cancel enforces a brand check');
+
+test(() => {
+
+ methodThrows(ReadableStream.prototype, 'getReader', fakeReadableStream());
-test(function() {
- methodThrows(ReadableStream.prototype, 'getReader', fakeReadableStream());
}, 'ReadableStream.prototype.getReader enforces a brand check');
-test(function() {
- methodThrows(ReadableStream.prototype, 'tee', fakeReadableStream());
+test(() => {
+
+ methodThrows(ReadableStream.prototype, 'tee', fakeReadableStream());
+
}, 'ReadableStream.prototype.tee enforces a brand check');
-test(function() {
- assert_throws(new TypeError(), function() { new ReadableStreamReader(fakeReadableStream()); }, 'Constructing a ReadableStreamReader should throw');
+test(() => {
+
+ assert_throws(new TypeError(), () => new ReadableStreamReader(fakeReadableStream()),
+ 'Constructing a ReadableStreamReader should throw');
+
}, 'ReadableStreamReader enforces a brand check on its argument');
-var test2 = async_test('ReadableStreamReader.prototype.closed enforces a brand check');
-test2.step(function() {
- getterRejects(test2, ReadableStreamReader.prototype, 'closed', fakeReadableStreamReader());
- getterRejects(test2, ReadableStreamReader.prototype, 'closed', realReadableStream(), true);
-});
-
-var test3 = async_test('ReadableStreamReader.prototype.cancel enforces a brand check');
-test3.step(function() {
- methodRejects(test3, ReadableStreamReader.prototype, 'cancel', fakeReadableStreamReader());
- methodRejects(test3, ReadableStreamReader.prototype, 'cancel', realReadableStream(), true);
-});
-
-var test4 = async_test('ReadableStreamReader.prototype.read enforces a brand check');
-test4.step(function() {
- methodRejects(test4, ReadableStreamReader.prototype, 'read', fakeReadableStreamReader());
- methodRejects(test4, ReadableStreamReader.prototype, 'read', realReadableStream(), true);
-});
-
-var test5 = async_test('ReadableStreamReader.prototype.read enforces a brand check');
-test5.step(function() {
- methodRejects(test5, ReadableStreamReader.prototype, 'read', fakeReadableStreamReader());
- methodRejects(test5, ReadableStreamReader.prototype, 'read', realReadableStream(), true);
-});
-
-test(function() {
- methodThrows(ReadableStreamReader.prototype, 'releaseLock', fakeReadableStreamReader());
- methodThrows(ReadableStreamReader.prototype, 'releaseLock', realReadableStream());
+promise_test(t => {
+
+ return Promise.all([
+ getterRejects(t, ReadableStreamReader.prototype, 'closed', fakeReadableStreamReader()),
+ getterRejects(t, ReadableStreamReader.prototype, 'closed', realReadableStream(), true)
+ ]);
+
+}, 'ReadableStreamReader.prototype.closed enforces a brand check');
+
+promise_test(t => {
+
+ return Promise.all([
+ methodRejects(t, ReadableStreamReader.prototype, 'cancel', fakeReadableStreamReader()),
+ methodRejects(t, ReadableStreamReader.prototype, 'cancel', realReadableStream(), true)
+ ]);
+
+}, 'ReadableStreamReader.prototype.cancel enforces a brand check');
+
+promise_test(t => {
+
+ return Promise.all([
+ methodRejects(t, ReadableStreamReader.prototype, 'read', fakeReadableStreamReader()),
+ methodRejects(t, ReadableStreamReader.prototype, 'read', realReadableStream(), true)
+ ]);
+
+}, 'ReadableStreamReader.prototype.read enforces a brand check');
+
+test(() => {
+
+ methodThrows(ReadableStreamReader.prototype, 'releaseLock', fakeReadableStreamReader());
+ methodThrows(ReadableStreamReader.prototype, 'releaseLock', realReadableStream(), true);
+
}, 'ReadableStreamReader.prototype.releaseLock enforces a brand check');
-test(function() {
- assert_throws(new TypeError(), function() { new ReadableStreamController(fakeReadableStream()); }, 'Constructing a ReadableStreamController should throw');
+test(() => {
+
+ assert_throws(new TypeError(), () => new ReadableStreamController(fakeReadableStream()),
+ 'Constructing a ReadableStreamController should throw');
+
}, 'ReadableStreamController enforces a brand check on its argument');
-test(function() {
- assert_throws(new TypeError(), function() { new ReadableStreamController(realReadableStream()); }, 'Constructing a ReadableStreamController should throw');
+test(() => {
+
+ assert_throws(new TypeError(), () => new ReadableStreamController(realReadableStream()),
+ 'Constructing a ReadableStreamController should throw');
+
}, 'ReadableStreamController can\'t be given a fully-constructed ReadableStream');
-test(function() {
+test(() => {
+
methodThrows(ReadableStreamController.prototype, 'close', fakeReadableStreamController());
+
}, 'ReadableStreamController.prototype.close enforces a brand check');
-test(function() {
+test(() => {
+
methodThrows(ReadableStreamController.prototype, 'enqueue', fakeReadableStreamController());
+
}, 'ReadableStreamController.prototype.enqueue enforces a brand check');
-test(function() {
+test(() => {
+
methodThrows(ReadableStreamController.prototype, 'error', fakeReadableStreamController());
+
}, 'ReadableStreamController.prototype.error enforces a brand check');
done();
diff --git a/reference-implementation/web-platform-tests/readable-streams/cancel.html b/reference-implementation/web-platform-tests/readable-streams/cancel.html
index b59fbdbfa..bfdd513a3 100644
--- a/reference-implementation/web-platform-tests/readable-streams/cancel.html
+++ b/reference-implementation/web-platform-tests/readable-streams/cancel.html
@@ -4,6 +4,7 @@
+
+
+