From d0a898681f8d5a5fcd53fa2ab8e0a3da807791be Mon Sep 17 00:00:00 2001 From: Ethan Arrowood Date: Fri, 13 Aug 2021 11:31:04 -0600 Subject: [PATCH] lib: add structuredClone() global MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/39759 Fixes: https://github.com/nodejs/node/issues/39713 Reviewed-By: Anna Henningsen Reviewed-By: James M Snell Reviewed-By: Antoine du Hamel Reviewed-By: Michaël Zasso Reviewed-By: Filip Skokan --- .eslintrc.js | 1 + lib/.eslintrc.yaml | 2 + lib/internal/bootstrap/node.js | 5 + lib/internal/structured_clone.js | 21 + test/common/index.js | 7 + test/fixtures/wpt/README.md | 1 + ...ructured-clone-battery-of-tests-harness.js | 44 ++ ...one-battery-of-tests-with-transferables.js | 22 + .../structured-clone-battery-of-tests.js | 618 ++++++++++++++++++ .../structured-clone/structured-clone.any.js | 9 + test/fixtures/wpt/versions.json | 6 +- test/parallel/test-bootstrap-modules.js | 1 + test/parallel/test-global.js | 1 + test/parallel/test-structuredClone-global.js | 19 + .../html/webappapis/structured-clone.json | 5 + test/wpt/test-structured-clone.js | 13 + 16 files changed, 774 insertions(+), 1 deletion(-) create mode 100644 lib/internal/structured_clone.js create mode 100644 test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js create mode 100644 test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js create mode 100644 test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests.js create mode 100644 test/fixtures/wpt/html/webappapis/structured-clone/structured-clone.any.js create mode 100644 test/parallel/test-structuredClone-global.js create mode 100644 test/wpt/status/html/webappapis/structured-clone.json create mode 100644 test/wpt/test-structured-clone.js diff --git a/.eslintrc.js b/.eslintrc.js index be332590ba7260..a8ab92feb0338b 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -362,5 +362,6 @@ module.exports = { btoa: 'readable', atob: 'readable', performance: 'readable', + structuredClone: 'readable', }, }; diff --git a/lib/.eslintrc.yaml b/lib/.eslintrc.yaml index 49013e1f8ee8b5..9f209505db9c33 100644 --- a/lib/.eslintrc.yaml +++ b/lib/.eslintrc.yaml @@ -81,6 +81,8 @@ rules: message: "Use `const { performance } = require('perf_hooks');` instead of the global." - name: queueMicrotask message: "Use `const { queueMicrotask } = require('internal/process/task_queues');` instead of the global." + - name: structuredClone + message: "Use `const { structuredClone } = require('internal/structured_clone');` instead of the global." # Custom rules in tools/eslint-rules node-core/lowercase-name-for-primitive: error node-core/non-ascii-character: error diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js index ab63dd0604ea41..ae4eac502803e7 100644 --- a/lib/internal/bootstrap/node.js +++ b/lib/internal/bootstrap/node.js @@ -254,6 +254,11 @@ if (!config.noBrowserGlobals) { // Non-standard extensions: defineOperation(globalThis, 'clearImmediate', timers.clearImmediate); defineOperation(globalThis, 'setImmediate', timers.setImmediate); + + const { + structuredClone, + } = require('internal/structured_clone'); + defineOperation(globalThis, 'structuredClone', structuredClone); } // Set the per-Environment callback that will be called diff --git a/lib/internal/structured_clone.js b/lib/internal/structured_clone.js new file mode 100644 index 00000000000000..1d5d0ed511c9cc --- /dev/null +++ b/lib/internal/structured_clone.js @@ -0,0 +1,21 @@ +'use strict'; + +const { + MessageChannel, + receiveMessageOnPort, +} = require('internal/worker/io'); + +let channel; +function structuredClone(value, transfer) { + // TODO: Improve this with a more efficient solution that avoids + // instantiating a MessageChannel + channel ??= new MessageChannel(); + channel.port1.unref(); + channel.port2.unref(); + channel.port1.postMessage(value, transfer); + return receiveMessageOnPort(channel.port2).message; +} + +module.exports = { + structuredClone +}; diff --git a/test/common/index.js b/test/common/index.js index 2ac4538cbea804..18d6444419152d 100644 --- a/test/common/index.js +++ b/test/common/index.js @@ -293,6 +293,13 @@ if (global.PerformanceMeasure) { knownGlobals.push(global.PerformanceMeasure); } +// TODO(@ethan-arrowood): Similar to previous checks, this can be temporary +// until v16.x is EOL. Once all supported versions have structuredClone we +// can add this to the list above instead. +if (global.structuredClone) { + knownGlobals.push(global.structuredClone); +} + function allowGlobals(...allowlist) { knownGlobals = knownGlobals.concat(allowlist); } diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md index 7c795981d793a6..8cd6c98684ebd9 100644 --- a/test/fixtures/wpt/README.md +++ b/test/fixtures/wpt/README.md @@ -18,6 +18,7 @@ Last update: - hr-time: https://github.com/web-platform-tests/wpt/tree/9910784394/hr-time - html/webappapis/atob: https://github.com/web-platform-tests/wpt/tree/f267e1dca6/html/webappapis/atob - html/webappapis/microtask-queuing: https://github.com/web-platform-tests/wpt/tree/2c5c3c4c27/html/webappapis/microtask-queuing +- html/webappapis/structured-clone: https://github.com/web-platform-tests/wpt/tree/47d3fb280c/html/webappapis/structured-clone - html/webappapis/timers: https://github.com/web-platform-tests/wpt/tree/5873f2d8f1/html/webappapis/timers - interfaces: https://github.com/web-platform-tests/wpt/tree/fc086c82d5/interfaces - performance-timeline: https://github.com/web-platform-tests/wpt/tree/17ebc3aea0/performance-timeline diff --git a/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js new file mode 100644 index 00000000000000..660477dca4c621 --- /dev/null +++ b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js @@ -0,0 +1,44 @@ +/** + * Runs a collection of tests that determine if an API implements structured clone + * correctly. + * + * The `runner` parameter has the following properties: + * - `setup()`: An optional function run once before testing starts + * - `teardown()`: An option function run once after all tests are done + * - `preTest()`: An optional, async function run before a test + * - `postTest()`: An optional, async function run after a test is done + * - `structuredClone(obj, transferList)`: Required function that somehow + * structurally clones an object. + * - `hasDocument`: When true, disables tests that require a document. True by default. + */ + +function runStructuredCloneBatteryOfTests(runner) { + const defaultRunner = { + setup() {}, + preTest() {}, + postTest() {}, + teardown() {}, + hasDocument: true + }; + runner = Object.assign({}, defaultRunner, runner); + + let setupPromise = runner.setup(); + const allTests = structuredCloneBatteryOfTests.map(test => { + + if (!runner.hasDocument && test.requiresDocument) { + return; + } + + return new Promise(resolve => { + promise_test(async _ => { + test = await test; + await setupPromise; + await runner.preTest(test); + await test.f(runner) + await runner.postTest(test); + resolve(); + }, test.description); + }).catch(_ => {}); + }); + Promise.all(allTests).then(_ => runner.teardown()); +} diff --git a/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js new file mode 100644 index 00000000000000..744f1168196001 --- /dev/null +++ b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js @@ -0,0 +1,22 @@ +structuredCloneBatteryOfTests.push({ + description: 'ArrayBuffer', + async f(runner) { + const buffer = new Uint8Array([1]).buffer; + const copy = await runner.structuredClone(buffer, [buffer]); + assert_equals(buffer.byteLength, 0); + assert_equals(copy.byteLength, 1); + } +}); + +structuredCloneBatteryOfTests.push({ + description: 'MessagePort', + async f(runner) { + const {port1, port2} = new MessageChannel(); + const copy = await runner.structuredClone(port2, [port2]); + const msg = new Promise(resolve => port1.onmessage = resolve); + copy.postMessage('ohai'); + assert_equals((await msg).data, 'ohai'); + } +}); + +// TODO: ImageBitmap diff --git a/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests.js b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests.js new file mode 100644 index 00000000000000..0c96ded2088357 --- /dev/null +++ b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone-battery-of-tests.js @@ -0,0 +1,618 @@ +/* This file is mostly a remix of @zcorpan’s web worker test suite */ + +structuredCloneBatteryOfTests = []; + +function check(description, input, callback, requiresDocument = false) { + testObjMock = { + done() {}, + step_func(f) {return _ => f()}, + }; + + structuredCloneBatteryOfTests.push({ + description, + async f(runner) { + let newInput = input; + if (typeof input === 'function') { + newInput = input(); + } + const copy = await runner.structuredClone(newInput); + await callback(copy, newInput, testObjMock); + }, + requiresDocument + }); +} + +function compare_primitive(actual, input, test_obj) { + assert_equals(actual, input); + if (test_obj) + test_obj.done(); +} +function compare_Array(callback, callback_is_async) { + return function(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Array, 'instanceof Array'); + assert_not_equals(actual, input); + assert_equals(actual.length, input.length, 'length'); + callback(actual, input); + if (test_obj && !callback_is_async) + test_obj.done(); + } +} + +function compare_Object(callback, callback_is_async) { + return function(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Object, 'instanceof Object'); + assert_false(actual instanceof Array, 'instanceof Array'); + assert_not_equals(actual, input); + callback(actual, input); + if (test_obj && !callback_is_async) + test_obj.done(); + } +} + +function enumerate_props(compare_func, test_obj) { + return function(actual, input) { + for (const x in input) { + compare_func(actual[x], input[x], test_obj); + } + }; +} + +check('primitive undefined', undefined, compare_primitive); +check('primitive null', null, compare_primitive); +check('primitive true', true, compare_primitive); +check('primitive false', false, compare_primitive); +check('primitive string, empty string', '', compare_primitive); +check('primitive string, lone high surrogate', '\uD800', compare_primitive); +check('primitive string, lone low surrogate', '\uDC00', compare_primitive); +check('primitive string, NUL', '\u0000', compare_primitive); +check('primitive string, astral character', '\uDBFF\uDFFD', compare_primitive); +check('primitive number, 0.2', 0.2, compare_primitive); +check('primitive number, 0', 0, compare_primitive); +check('primitive number, -0', -0, compare_primitive); +check('primitive number, NaN', NaN, compare_primitive); +check('primitive number, Infinity', Infinity, compare_primitive); +check('primitive number, -Infinity', -Infinity, compare_primitive); +check('primitive number, 9007199254740992', 9007199254740992, compare_primitive); +check('primitive number, -9007199254740992', -9007199254740992, compare_primitive); +check('primitive number, 9007199254740994', 9007199254740994, compare_primitive); +check('primitive number, -9007199254740994', -9007199254740994, compare_primitive); +check('primitive BigInt, 0n', 0n, compare_primitive); +check('primitive BigInt, -0n', -0n, compare_primitive); +check('primitive BigInt, -9007199254740994000n', -9007199254740994000n, compare_primitive); +check('primitive BigInt, -9007199254740994000900719925474099400090071992547409940009007199254740994000n', -9007199254740994000900719925474099400090071992547409940009007199254740994000n, compare_primitive); + +check('Array primitives', [undefined, + null, + true, + false, + '', + '\uD800', + '\uDC00', + '\u0000', + '\uDBFF\uDFFD', + 0.2, + 0, + -0, + NaN, + Infinity, + -Infinity, + 9007199254740992, + -9007199254740992, + 9007199254740994, + -9007199254740994, + -12n, + -0n, + 0n], compare_Array(enumerate_props(compare_primitive))); +check('Object primitives', {'undefined':undefined, + 'null':null, + 'true':true, + 'false':false, + 'empty':'', + 'high surrogate':'\uD800', + 'low surrogate':'\uDC00', + 'nul':'\u0000', + 'astral':'\uDBFF\uDFFD', + '0.2':0.2, + '0':0, + '-0':-0, + 'NaN':NaN, + 'Infinity':Infinity, + '-Infinity':-Infinity, + '9007199254740992':9007199254740992, + '-9007199254740992':-9007199254740992, + '9007199254740994':9007199254740994, + '-9007199254740994':-9007199254740994}, compare_Object(enumerate_props(compare_primitive))); + +function compare_Boolean(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Boolean, 'instanceof Boolean'); + assert_equals(String(actual), String(input), 'converted to primitive'); + assert_not_equals(actual, input); + if (test_obj) + test_obj.done(); +} +check('Boolean true', new Boolean(true), compare_Boolean); +check('Boolean false', new Boolean(false), compare_Boolean); +check('Array Boolean objects', [new Boolean(true), new Boolean(false)], compare_Array(enumerate_props(compare_Boolean))); +check('Object Boolean objects', {'true':new Boolean(true), 'false':new Boolean(false)}, compare_Object(enumerate_props(compare_Boolean))); + +function compare_obj(what) { + const Type = self[what]; + return function(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Type, 'instanceof '+what); + assert_equals(Type(actual), Type(input), 'converted to primitive'); + assert_not_equals(actual, input); + if (test_obj) + test_obj.done(); + }; +} +check('String empty string', new String(''), compare_obj('String')); +check('String lone high surrogate', new String('\uD800'), compare_obj('String')); +check('String lone low surrogate', new String('\uDC00'), compare_obj('String')); +check('String NUL', new String('\u0000'), compare_obj('String')); +check('String astral character', new String('\uDBFF\uDFFD'), compare_obj('String')); +check('Array String objects', [new String(''), + new String('\uD800'), + new String('\uDC00'), + new String('\u0000'), + new String('\uDBFF\uDFFD')], compare_Array(enumerate_props(compare_obj('String')))); +check('Object String objects', {'empty':new String(''), + 'high surrogate':new String('\uD800'), + 'low surrogate':new String('\uDC00'), + 'nul':new String('\u0000'), + 'astral':new String('\uDBFF\uDFFD')}, compare_Object(enumerate_props(compare_obj('String')))); + +check('Number 0.2', new Number(0.2), compare_obj('Number')); +check('Number 0', new Number(0), compare_obj('Number')); +check('Number -0', new Number(-0), compare_obj('Number')); +check('Number NaN', new Number(NaN), compare_obj('Number')); +check('Number Infinity', new Number(Infinity), compare_obj('Number')); +check('Number -Infinity', new Number(-Infinity), compare_obj('Number')); +check('Number 9007199254740992', new Number(9007199254740992), compare_obj('Number')); +check('Number -9007199254740992', new Number(-9007199254740992), compare_obj('Number')); +check('Number 9007199254740994', new Number(9007199254740994), compare_obj('Number')); +check('Number -9007199254740994', new Number(-9007199254740994), compare_obj('Number')); +// BigInt does not have a non-throwing constructor +check('BigInt -9007199254740994n', Object(-9007199254740994n), compare_obj('BigInt')); + +check('Array Number objects', [new Number(0.2), + new Number(0), + new Number(-0), + new Number(NaN), + new Number(Infinity), + new Number(-Infinity), + new Number(9007199254740992), + new Number(-9007199254740992), + new Number(9007199254740994), + new Number(-9007199254740994)], compare_Array(enumerate_props(compare_obj('Number')))); +check('Object Number objects', {'0.2':new Number(0.2), + '0':new Number(0), + '-0':new Number(-0), + 'NaN':new Number(NaN), + 'Infinity':new Number(Infinity), + '-Infinity':new Number(-Infinity), + '9007199254740992':new Number(9007199254740992), + '-9007199254740992':new Number(-9007199254740992), + '9007199254740994':new Number(9007199254740994), + '-9007199254740994':new Number(-9007199254740994)}, compare_Object(enumerate_props(compare_obj('Number')))); + +function compare_Date(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Date, 'instanceof Date'); + assert_equals(Number(actual), Number(input), 'converted to primitive'); + assert_not_equals(actual, input); + if (test_obj) + test_obj.done(); +} +check('Date 0', new Date(0), compare_Date); +check('Date -0', new Date(-0), compare_Date); +check('Date -8.64e15', new Date(-8.64e15), compare_Date); +check('Date 8.64e15', new Date(8.64e15), compare_Date); +check('Array Date objects', [new Date(0), + new Date(-0), + new Date(-8.64e15), + new Date(8.64e15)], compare_Array(enumerate_props(compare_Date))); +check('Object Date objects', {'0':new Date(0), + '-0':new Date(-0), + '-8.64e15':new Date(-8.64e15), + '8.64e15':new Date(8.64e15)}, compare_Object(enumerate_props(compare_Date))); + +function compare_RegExp(expected_source) { + // XXX ES6 spec doesn't define exact serialization for `source` (it allows several ways to escape) + return function(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof RegExp, 'instanceof RegExp'); + assert_equals(actual.global, input.global, 'global'); + assert_equals(actual.ignoreCase, input.ignoreCase, 'ignoreCase'); + assert_equals(actual.multiline, input.multiline, 'multiline'); + assert_equals(actual.source, expected_source, 'source'); + assert_equals(actual.sticky, input.sticky, 'sticky'); + assert_equals(actual.unicode, input.unicode, 'unicode'); + assert_equals(actual.lastIndex, 0, 'lastIndex'); + assert_not_equals(actual, input); + if (test_obj) + test_obj.done(); + } +} +function func_RegExp_flags_lastIndex() { + const r = /foo/gim; + r.lastIndex = 2; + return r; +} +function func_RegExp_sticky() { + return new RegExp('foo', 'y'); +} +function func_RegExp_unicode() { + return new RegExp('foo', 'u'); +} +check('RegExp flags and lastIndex', func_RegExp_flags_lastIndex, compare_RegExp('foo')); +check('RegExp sticky flag', func_RegExp_sticky, compare_RegExp('foo')); +check('RegExp unicode flag', func_RegExp_unicode, compare_RegExp('foo')); +check('RegExp empty', new RegExp(''), compare_RegExp('(?:)')); +check('RegExp slash', new RegExp('/'), compare_RegExp('\\/')); +check('RegExp new line', new RegExp('\n'), compare_RegExp('\\n')); +check('Array RegExp object, RegExp flags and lastIndex', [func_RegExp_flags_lastIndex()], compare_Array(enumerate_props(compare_RegExp('foo')))); +check('Array RegExp object, RegExp sticky flag', function() { return [func_RegExp_sticky()]; }, compare_Array(enumerate_props(compare_RegExp('foo')))); +check('Array RegExp object, RegExp unicode flag', function() { return [func_RegExp_unicode()]; }, compare_Array(enumerate_props(compare_RegExp('foo')))); +check('Array RegExp object, RegExp empty', [new RegExp('')], compare_Array(enumerate_props(compare_RegExp('(?:)')))); +check('Array RegExp object, RegExp slash', [new RegExp('/')], compare_Array(enumerate_props(compare_RegExp('\\/')))); +check('Array RegExp object, RegExp new line', [new RegExp('\n')], compare_Array(enumerate_props(compare_RegExp('\\n')))); +check('Object RegExp object, RegExp flags and lastIndex', {'x':func_RegExp_flags_lastIndex()}, compare_Object(enumerate_props(compare_RegExp('foo')))); +check('Object RegExp object, RegExp sticky flag', function() { return {'x':func_RegExp_sticky()}; }, compare_Object(enumerate_props(compare_RegExp('foo')))); +check('Object RegExp object, RegExp unicode flag', function() { return {'x':func_RegExp_unicode()}; }, compare_Object(enumerate_props(compare_RegExp('foo')))); +check('Object RegExp object, RegExp empty', {'x':new RegExp('')}, compare_Object(enumerate_props(compare_RegExp('(?:)')))); +check('Object RegExp object, RegExp slash', {'x':new RegExp('/')}, compare_Object(enumerate_props(compare_RegExp('\\/')))); +check('Object RegExp object, RegExp new line', {'x':new RegExp('\n')}, compare_Object(enumerate_props(compare_RegExp('\\n')))); + +async function compare_Blob(actual, input, test_obj, expect_File) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Blob, 'instanceof Blob'); + if (!expect_File) + assert_false(actual instanceof File, 'instanceof File'); + assert_equals(actual.size, input.size, 'size'); + assert_equals(actual.type, input.type, 'type'); + assert_not_equals(actual, input); + const ab1 = await new Response(actual).arrayBuffer(); + const ab2 = await new Response(input).arrayBuffer(); + assert_equals(ab1.byteLength, ab2.byteLength, 'byteLength'); + const ta1 = new Uint8Array(ab1); + const ta2 = new Uint8Array(ab2); + for(let i = 0; i < ta1.size; i++) { + assert_equals(ta1[i], ta2[i]); + } +} +function func_Blob_basic() { + return new Blob(['foo'], {type:'text/x-bar'}); +} +check('Blob basic', func_Blob_basic, compare_Blob); + +function b(str) { + return parseInt(str, 2); +} +function encode_cesu8(codeunits) { + // http://www.unicode.org/reports/tr26/ section 2.2 + // only the 3-byte form is supported + const rv = []; + codeunits.forEach(function(codeunit) { + rv.push(b('11100000') + ((codeunit & b('1111000000000000')) >> 12)); + rv.push(b('10000000') + ((codeunit & b('0000111111000000')) >> 6)); + rv.push(b('10000000') + (codeunit & b('0000000000111111'))); + }); + return rv; +} +function func_Blob_bytes(arr) { + return function() { + const buffer = new ArrayBuffer(arr.length); + const view = new DataView(buffer); + for (let i = 0; i < arr.length; ++i) { + view.setUint8(i, arr[i]); + } + return new Blob([view]); + }; +} +check('Blob unpaired high surrogate (invalid utf-8)', func_Blob_bytes(encode_cesu8([0xD800])), compare_Blob); +check('Blob unpaired low surrogate (invalid utf-8)', func_Blob_bytes(encode_cesu8([0xDC00])), compare_Blob); +check('Blob paired surrogates (invalid utf-8)', func_Blob_bytes(encode_cesu8([0xD800, 0xDC00])), compare_Blob); + +function func_Blob_empty() { + return new Blob(['']); +} +check('Blob empty', func_Blob_empty , compare_Blob); +function func_Blob_NUL() { + return new Blob(['\u0000']); +} +check('Blob NUL', func_Blob_NUL, compare_Blob); + +check('Array Blob object, Blob basic', [func_Blob_basic()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, Blob unpaired high surrogate (invalid utf-8)', [func_Blob_bytes([0xD800])()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, Blob unpaired low surrogate (invalid utf-8)', [func_Blob_bytes([0xDC00])()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, Blob paired surrogates (invalid utf-8)', [func_Blob_bytes([0xD800, 0xDC00])()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, Blob empty', [func_Blob_empty()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, Blob NUL', [func_Blob_NUL()], compare_Array(enumerate_props(compare_Blob), true)); +check('Array Blob object, two Blobs', [func_Blob_basic(), func_Blob_empty()], compare_Array(enumerate_props(compare_Blob), true)); + +check('Object Blob object, Blob basic', {'x':func_Blob_basic()}, compare_Object(enumerate_props(compare_Blob), true)); +check('Object Blob object, Blob unpaired high surrogate (invalid utf-8)', {'x':func_Blob_bytes([0xD800])()}, compare_Object(enumerate_props(compare_Blob), true)); +check('Object Blob object, Blob unpaired low surrogate (invalid utf-8)', {'x':func_Blob_bytes([0xDC00])()}, compare_Object(enumerate_props(compare_Blob), true)); +check('Object Blob object, Blob paired surrogates (invalid utf-8)', {'x':func_Blob_bytes([0xD800, 0xDC00])() }, compare_Object(enumerate_props(compare_Blob), true)); +check('Object Blob object, Blob empty', {'x':func_Blob_empty()}, compare_Object(enumerate_props(compare_Blob), true)); +check('Object Blob object, Blob NUL', {'x':func_Blob_NUL()}, compare_Object(enumerate_props(compare_Blob), true)); + +function compare_File(actual, input, test_obj) { + assert_true(actual instanceof File, 'instanceof File'); + assert_equals(actual.name, input.name, 'name'); + assert_equals(actual.lastModified, input.lastModified, 'lastModified'); + compare_Blob(actual, input, test_obj, true); +} +function func_File_basic() { + return new File(['foo'], 'bar', {type:'text/x-bar', lastModified:42}); +} +check('File basic', func_File_basic, compare_File); + +function compare_FileList(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof FileList, 'instanceof FileList'); + assert_equals(actual.length, input.length, 'length'); + assert_not_equals(actual, input); + // XXX when there's a way to populate or construct a FileList, + // check the items in the FileList + if (test_obj) + test_obj.done(); +} +function func_FileList_empty() { + const input = document.createElement('input'); + input.type = 'file'; + return input.files; +} +check('FileList empty', func_FileList_empty, compare_FileList, true); +check('Array FileList object, FileList empty', () => ([func_FileList_empty()]), compare_Array(enumerate_props(compare_FileList)), true); +check('Object FileList object, FileList empty', () => ({'x':func_FileList_empty()}), compare_Object(enumerate_props(compare_FileList)), true); + +function compare_ArrayBufferView(view) { + const Type = self[view]; + return function(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof Type, 'instanceof '+view); + assert_equals(actual.length, input.length, 'length'); + assert_not_equals(actual.buffer, input.buffer, 'buffer'); + for (let i = 0; i < actual.length; ++i) { + assert_equals(actual[i], input[i], 'actual['+i+']'); + } + if (test_obj) + test_obj.done(); + }; +} +function compare_ImageData(actual, input, test_obj) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_equals(actual.width, input.width, 'width'); + assert_equals(actual.height, input.height, 'height'); + assert_not_equals(actual.data, input.data, 'data'); + compare_ArrayBufferView('Uint8ClampedArray')(actual.data, input.data, null); + if (test_obj) + test_obj.done(); +} +function func_ImageData_1x1_transparent_black() { + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + return ctx.createImageData(1, 1); +} +check('ImageData 1x1 transparent black', func_ImageData_1x1_transparent_black, compare_ImageData, true); +function func_ImageData_1x1_non_transparent_non_black() { + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + const imagedata = ctx.createImageData(1, 1); + imagedata.data[0] = 100; + imagedata.data[1] = 101; + imagedata.data[2] = 102; + imagedata.data[3] = 103; + return imagedata; +} +check('ImageData 1x1 non-transparent non-black', func_ImageData_1x1_non_transparent_non_black, compare_ImageData, true); +check('Array ImageData object, ImageData 1x1 transparent black', () => ([func_ImageData_1x1_transparent_black()]), compare_Array(enumerate_props(compare_ImageData)), true); +check('Array ImageData object, ImageData 1x1 non-transparent non-black', () => ([func_ImageData_1x1_non_transparent_non_black()]), compare_Array(enumerate_props(compare_ImageData)), true); +check('Object ImageData object, ImageData 1x1 transparent black', () => ({'x':func_ImageData_1x1_transparent_black()}), compare_Object(enumerate_props(compare_ImageData)), true); +check('Object ImageData object, ImageData 1x1 non-transparent non-black', () => ({'x':func_ImageData_1x1_non_transparent_non_black()}), compare_Object(enumerate_props(compare_ImageData)), true); + + +check('Array sparse', new Array(10), compare_Array(enumerate_props(compare_primitive))); +check('Array with non-index property', function() { + const rv = []; + rv.foo = 'bar'; + return rv; +}, compare_Array(enumerate_props(compare_primitive))); +check('Object with index property and length', {'0':'foo', 'length':1}, compare_Object(enumerate_props(compare_primitive))); +function check_circular_property(prop) { + return function(actual) { + assert_equals(actual[prop], actual); + }; +} +check('Array with circular reference', function() { + const rv = []; + rv[0] = rv; + return rv; +}, compare_Array(check_circular_property('0'))); +check('Object with circular reference', function() { + const rv = {}; + rv['x'] = rv; + return rv; +}, compare_Object(check_circular_property('x'))); +function check_identical_property_values(prop1, prop2) { + return function(actual) { + assert_equals(actual[prop1], actual[prop2]); + }; +} +check('Array with identical property values', function() { + const obj = {} + return [obj, obj]; +}, compare_Array(check_identical_property_values('0', '1'))); +check('Object with identical property values', function() { + const obj = {} + return {'x':obj, 'y':obj}; +}, compare_Object(check_identical_property_values('x', 'y'))); + +function check_absent_property(prop) { + return function(actual) { + assert_false(prop in actual); + }; +} +check('Object with property on prototype', function() { + const Foo = function() {}; + Foo.prototype = {'foo':'bar'}; + return new Foo(); +}, compare_Object(check_absent_property('foo'))); + +check('Object with non-enumerable property', function() { + const rv = {}; + Object.defineProperty(rv, 'foo', {value:'bar', enumerable:false, writable:true, configurable:true}); + return rv; +}, compare_Object(check_absent_property('foo'))); + +function check_writable_property(prop) { + return function(actual, input) { + assert_equals(actual[prop], input[prop]); + actual[prop] += ' baz'; + assert_equals(actual[prop], input[prop] + ' baz'); + }; +} +check('Object with non-writable property', function() { + const rv = {}; + Object.defineProperty(rv, 'foo', {value:'bar', enumerable:true, writable:false, configurable:true}); + return rv; +}, compare_Object(check_writable_property('foo'))); + +function check_configurable_property(prop) { + return function(actual, input) { + assert_equals(actual[prop], input[prop]); + delete actual[prop]; + assert_false('prop' in actual); + }; +} +check('Object with non-configurable property', function() { + const rv = {}; + Object.defineProperty(rv, 'foo', {value:'bar', enumerable:true, writable:true, configurable:false}); + return rv; +}, compare_Object(check_configurable_property('foo'))); + +/* The tests below are inspired by @zcorpan’s work but got some +more substantial changed due to their previous async setup */ + +function get_canvas_1x1_transparent_black() { + const canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return canvas; +} + +function get_canvas_1x1_non_transparent_non_black() { + const canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + const ctx = canvas.getContext('2d'); + const imagedata = ctx.getImageData(0, 0, 1, 1); + imagedata.data[0] = 100; + imagedata.data[1] = 101; + imagedata.data[2] = 102; + imagedata.data[3] = 103; + return canvas; +} + +function compare_ImageBitmap(actual, input) { + if (typeof actual === 'string') + assert_unreached(actual); + assert_true(actual instanceof ImageBitmap, 'instanceof ImageBitmap'); + assert_not_equals(actual, input); + // XXX paint the ImageBitmap on a canvas and check the data +} + +structuredCloneBatteryOfTests.push({ + description: 'ImageBitmap 1x1 transparent black', + async f(runner) { + const canvas = get_canvas_1x1_transparent_black(); + const bm = await createImageBitmap(canvas); + const copy = await runner.structuredClone(bm); + compare_ImageBitmap(bm, copy); + }, + requiresDocument: true +}); + +structuredCloneBatteryOfTests.push({ + description: 'ImageBitmap 1x1 non-transparent non-black', + async f(runner) { + const canvas = get_canvas_1x1_non_transparent_non_black(); + const bm = await createImageBitmap(canvas); + const copy = await runner.structuredClone(bm); + compare_ImageBitmap(bm, copy); + }, + requiresDocument: true +}); + +structuredCloneBatteryOfTests.push({ + description: 'Array ImageBitmap object, ImageBitmap 1x1 transparent black', + async f(runner) { + const canvas = get_canvas_1x1_transparent_black(); + const bm = [await createImageBitmap(canvas)]; + const copy = await runner.structuredClone(bm); + compare_Array(enumerate_props(compare_ImageBitmap))(bm, copy); + }, + requiresDocument: true +}); + +structuredCloneBatteryOfTests.push({ + description: 'Array ImageBitmap object, ImageBitmap 1x1 transparent non-black', + async f(runner) { + const canvas = get_canvas_1x1_non_transparent_non_black(); + const bm = [await createImageBitmap(canvas)]; + const copy = await runner.structuredClone(bm); + compare_Array(enumerate_props(compare_ImageBitmap))(bm, copy); + }, + requiresDocument: true +}); + +structuredCloneBatteryOfTests.push({ + description: 'Object ImageBitmap object, ImageBitmap 1x1 transparent black', + async f(runner) { + const canvas = get_canvas_1x1_transparent_black(); + const bm = {x: await createImageBitmap(canvas)}; + const copy = await runner.structuredClone(bm); + compare_Object(enumerate_props(compare_ImageBitmap))(bm, copy); + }, + requiresDocument: true +}); + +structuredCloneBatteryOfTests.push({ + description: 'Object ImageBitmap object, ImageBitmap 1x1 transparent non-black', + async f(runner) { + const canvas = get_canvas_1x1_non_transparent_non_black(); + const bm = {x: await createImageBitmap(canvas)}; + const copy = await runner.structuredClone(bm); + compare_Object(enumerate_props(compare_ImageBitmap))(bm, copy); + }, + requiresDocument: true +}); + +check('ObjectPrototype must lose its exotic-ness when cloned', + () => Object.prototype, + (copy, original) => { + assert_not_equals(copy, original); + assert_true(copy instanceof Object); + + const newProto = { some: 'proto' }; + // Must not throw: + Object.setPrototypeOf(copy, newProto); + + assert_equals(Object.getPrototypeOf(copy), newProto); + } +); diff --git a/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone.any.js b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone.any.js new file mode 100644 index 00000000000000..34f96f33fdf881 --- /dev/null +++ b/test/fixtures/wpt/html/webappapis/structured-clone/structured-clone.any.js @@ -0,0 +1,9 @@ +// META: title=structuredClone() tests +// META: script=/html/webappapis/structured-clone/structured-clone-battery-of-tests.js +// META: script=/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js +// META: script=/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js + +runStructuredCloneBatteryOfTests({ + structuredClone: (obj, transfer) => self.structuredClone(obj, { transfer }), + hasDocument: typeof document !== "undefined", +}); diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index 2eda2919ea9908..4ad5f68a33998b 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -31,6 +31,10 @@ "commit": "2c5c3c4c27d27a419c1fdba3e9879c2d22037074", "path": "html/webappapis/microtask-queuing" }, + "html/webappapis/structured-clone": { + "commit": "47d3fb280c9c632e684dee3b78ae1f4c5d5ba640", + "path": "html/webappapis/structured-clone" + }, "html/webappapis/timers": { "commit": "5873f2d8f1f7bbb9c64689e52d04498614632906", "path": "html/webappapis/timers" @@ -63,4 +67,4 @@ "commit": "cdd0f03df41b222aed098fbbb11c6a3cc500a86b", "path": "WebCryptoAPI" } -} \ No newline at end of file +} diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js index 37cdbca3300368..79614cfa1107db 100644 --- a/test/parallel/test-bootstrap-modules.js +++ b/test/parallel/test-bootstrap-modules.js @@ -114,6 +114,7 @@ const expectedModules = new Set([ 'NativeModule internal/streams/transform', 'NativeModule internal/streams/utils', 'NativeModule internal/streams/writable', + 'NativeModule internal/structured_clone', 'NativeModule internal/timers', 'NativeModule internal/url', 'NativeModule internal/util', diff --git a/test/parallel/test-global.js b/test/parallel/test-global.js index dbd3b06d290d31..60df2c1d73f463 100644 --- a/test/parallel/test-global.js +++ b/test/parallel/test-global.js @@ -51,6 +51,7 @@ builtinModules.forEach((moduleName) => { 'setImmediate', 'setInterval', 'setTimeout', + 'structuredClone', ]; assert.deepStrictEqual(new Set(Object.keys(global)), new Set(expected)); } diff --git a/test/parallel/test-structuredClone-global.js b/test/parallel/test-structuredClone-global.js new file mode 100644 index 00000000000000..ae6120c04e0005 --- /dev/null +++ b/test/parallel/test-structuredClone-global.js @@ -0,0 +1,19 @@ +// Flags: --expose-internals +'use strict'; +/* eslint-disable no-global-assign */ + +require('../common'); + +const { + structuredClone: _structuredClone +} = require('internal/structured_clone'); +const { + strictEqual +} = require('assert'); + +strictEqual(globalThis.structuredClone, _structuredClone); +structuredClone = undefined; +strictEqual(globalThis.structuredClone, undefined); + +// Restore the value for the known globals check. +structuredClone = _structuredClone; diff --git a/test/wpt/status/html/webappapis/structured-clone.json b/test/wpt/status/html/webappapis/structured-clone.json new file mode 100644 index 00000000000000..d2a7539641ffb5 --- /dev/null +++ b/test/wpt/status/html/webappapis/structured-clone.json @@ -0,0 +1,5 @@ +{ + "structured-clone.any.js": { + "skip": "Missing File API" + } +} diff --git a/test/wpt/test-structured-clone.js b/test/wpt/test-structured-clone.js new file mode 100644 index 00000000000000..98ef87184a6ce2 --- /dev/null +++ b/test/wpt/test-structured-clone.js @@ -0,0 +1,13 @@ +'use strict'; + +require('../common'); +const { WPTRunner } = require('../common/wpt'); + +const runner = new WPTRunner('html/webappapis/structured-clone'); + +runner.setInitScript(` + const { Blob } = require('buffer'); + global.Blob = Blob; +`); + +runner.runJsTests();