From 0f26f4a565e0fd37244557ee7bcf3dc205eb7330 Mon Sep 17 00:00:00 2001 From: Domenic Denicola Date: Mon, 23 Nov 2015 16:13:12 -0500 Subject: [PATCH] Clean up more web platform tests Use promise_test instead of async_test; lint them; use ES2015 features --- reference-implementation/package.json | 4 +- .../web-platform-tests/.eslintrc | 292 ++++ .../byte-length-queuing-strategy.js | 22 +- .../count-queuing-strategy.js | 18 +- .../readable-streams/bad-strategies.js | 205 +-- .../bad-underlying-sources.js | 29 +- .../readable-streams/brand-checks.js | 179 ++- .../readable-streams/cancel.html | 1 + .../readable-streams/cancel.js | 395 ++--- .../count-queuing-strategy-integration.js | 356 +++-- .../readable-streams/general.html | 1 + .../readable-streams/general.js | 1337 +++++++++-------- .../readable-streams/pipe-through.js | 34 +- .../readable-stream-reader.js | 942 ++++++------ .../readable-streams/tee.js | 535 +++---- .../readable-streams/templated.html | 1 + .../readable-streams/templated.js | 236 ++- .../resources/rs-test-templates.js | 1097 ++++++-------- .../web-platform-tests/resources/rs-utils.js | 302 ++-- .../resources/test-utils.js | 67 +- 20 files changed, 3146 insertions(+), 2907 deletions(-) create mode 100644 reference-implementation/web-platform-tests/.eslintrc 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 @@ + + +