Attachment 340735 Details for Bug 185773 – Patch

[patch] Patch

bug-185773-20180518135917.patch (text/plain), 136.72 KB, created by Chris Dumez on 2018-05-18 13:59:18 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Chris Dumez

Created: 2018-05-18 13:59:18 PDT

Size: 136.72 KB

patch

obsolete

>Subversion Revision: 231959
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 57b817aa08444a4e7c9b8cc583c5390b6ffce825..d235b812949f25848fa6a72277a05d602d9ec03b 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,23 @@
>+2018-05-18  Chris Dumez  <cdumez@apple.com>
>+
>+        File's structured serialization should serialize lastModified attribute
>+        https://bugs.webkit.org/show_bug.cgi?id=185773
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Update our implementation for the stuctured serialization of a File to include
>+        its lastModified attribute, as per:
>+        - https://w3c.github.io/FileAPI/#file-section
>+
>+        No new tests, rebaselined existing test.
>+
>+        * bindings/js/SerializedScriptValue.cpp:
>+        (WebCore::CloneSerializer::write):
>+        (WebCore::CloneDeserializer::readFile):
>+        * fileapi/File.cpp:
>+        (WebCore::File::File):
>+        * fileapi/File.h:
>+
> 2018-05-18  Chris Dumez  <cdumez@apple.com>
> 
>         Unreviewed, rolling out r231935.
>diff --git a/Source/WebCore/bindings/js/SerializedScriptValue.cpp b/Source/WebCore/bindings/js/SerializedScriptValue.cpp
>index b01808129ccbb2dfa32beb75000aee2d158627d4..31fc7ff69cd21d7f0440d8256dab3d78e2dde597 100644
>--- a/Source/WebCore/bindings/js/SerializedScriptValue.cpp
>+++ b/Source/WebCore/bindings/js/SerializedScriptValue.cpp
>@@ -278,8 +278,9 @@ static unsigned countUsages(CryptoKeyUsageBitmap usages)
>  * Version 4. added support for serializing non-index properties of arrays.
>  * Version 5. added support for Map and Set types.
>  * Version 6. added support for 8-bit strings.
>+ * Version 7. added support for File's lastModified attribute.
>  */
>-static const unsigned CurrentVersion = 6;
>+static const unsigned CurrentVersion = 7;
> static const unsigned TerminatorTag = 0xFFFFFFFF;
> static const unsigned StringPoolTag = 0xFFFFFFFE;
> static const unsigned NonIndexPropertiesTag = 0xFFFFFFFD;
>@@ -363,7 +364,7 @@ static const unsigned StringDataIs8BitFlag = 0x80000000;
>  *    FileTag FileData
>  *
>  * FileData :-
>- *    <path:StringData> <url:StringData> <type:StringData> <name:StringData>
>+ *    <path:StringData> <url:StringData> <type:StringData> <name:StringData> <lastModified:double>
>  *
>  * FileList :-
>  *    FileListTag <length:uint32_t>(<file:FileData>){length}
>@@ -1236,6 +1237,7 @@ private:
>         write(file.url());
>         write(file.type());
>         write(file.name());
>+        write(file.lastModifiedOverride().value_or(-1));
>     }
> 
> #if ENABLE(SUBTLE_CRYPTO)
>@@ -2036,6 +2038,9 @@ private:
>         CachedStringRef name;
>         if (!readStringData(name))
>             return false;
>+        double lastModified;
>+        if (!read(lastModified))
>+            return false;
> 
>         // If the blob URL for this file has an associated blob file path, prefer that one over the "built-in" path.
>         String filePath = blobFilePathForBlobURL(url->string());
>@@ -2043,7 +2048,7 @@ private:
>             filePath = path->string();
> 
>         if (m_isDOMGlobalObject)
>-            file = File::deserialize(filePath, URL(URL(), url->string()), type->string(), name->string());
>+            file = File::deserialize(filePath, URL(URL(), url->string()), type->string(), name->string(), lastModified >= 0 ? std::make_optional(lastModified) : std::nullopt);
>         return true;
>     }
> 
>diff --git a/Source/WebCore/fileapi/File.cpp b/Source/WebCore/fileapi/File.cpp
>index e695aa586cb418c631f3f6583cb69b513668aaef..dc06757d5ab5c3f632673ffbdda4a4435f839aec 100644
>--- a/Source/WebCore/fileapi/File.cpp
>+++ b/Source/WebCore/fileapi/File.cpp
>@@ -63,10 +63,11 @@ File::File(const String& path, const String& nameOverride)
>     ThreadableBlobRegistry::registerFileBlobURL(m_internalURL, path, m_type);
> }
> 
>-File::File(DeserializationContructor, const String& path, const URL& url, const String& type, const String& name)
>+File::File(DeserializationContructor, const String& path, const URL& url, const String& type, const String& name, std::optional<double> lastModified)
>     : Blob(deserializationContructor, url, type, -1, path)
>     , m_path(path)
>     , m_name(name)
>+    , m_overrideLastModifiedDate(lastModified)
> {
> }
> 
>diff --git a/Source/WebCore/fileapi/File.h b/Source/WebCore/fileapi/File.h
>index f797c4a315f7f3d3d2f441da2ff077e288d230e8..081c8db32f7d748ea18573d4cdd96c09fe8fdd21 100644
>--- a/Source/WebCore/fileapi/File.h
>+++ b/Source/WebCore/fileapi/File.h
>@@ -52,9 +52,9 @@ public:
>         return adoptRef(*new File(WTFMove(blobPartVariants), filename, propertyBag));
>     }
> 
>-    static Ref<File> deserialize(const String& path, const URL& srcURL, const String& type, const String& name)
>+    static Ref<File> deserialize(const String& path, const URL& srcURL, const String& type, const String& name, std::optional<double> lastModified = std::nullopt)
>     {
>-        return adoptRef(*new File(deserializationContructor, path, srcURL, type, name));
>+        return adoptRef(*new File(deserializationContructor, path, srcURL, type, name, lastModified));
>     }
> 
>     // Create a file with a name exposed to the author (via File.name and associated DOM properties) that differs from the one provided in the path.
>@@ -84,6 +84,7 @@ public:
>     void setRelativePath(const String& relativePath) { m_relativePath = relativePath; }
>     const String& name() const { return m_name; }
>     WEBCORE_EXPORT double lastModified() const;
>+    const std::optional<double>& lastModifiedOverride() const { return m_overrideLastModifiedDate; }
> 
>     static String contentTypeForFile(const String& path);
> 
>@@ -100,7 +101,7 @@ private:
>     File(const Blob&, const String& name);
>     File(const File&, const String& name);
> 
>-    File(DeserializationContructor, const String& path, const URL& srcURL, const String& type, const String& name);
>+    File(DeserializationContructor, const String& path, const URL& srcURL, const String& type, const String& name, std::optional<double> lastModified);
> 
>     static void computeNameAndContentType(const String& path, const String& nameOverride, String& effectiveName, String& effectiveContentType);
> #if ENABLE(FILE_REPLACEMENT)
>@@ -111,7 +112,7 @@ private:
>     String m_relativePath;
>     String m_name;
> 
>-    std::optional<int64_t> m_overrideLastModifiedDate;
>+    std::optional<double> m_overrideLastModifiedDate;
>     mutable std::optional<bool> m_isDirectory;
> };
> 
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 2bb8eb8d89b8b11a226b7bf7ff39a2fe64025496..c01b8bc2942b26a77db027999beb10094a6f4693 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,14 @@
>+2018-05-18  Chris Dumez  <cdumez@apple.com>
>+
>+        File's structured serialization should serialize lastModified attribute
>+        https://bugs.webkit.org/show_bug.cgi?id=185773
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Unskip structured serialization tests that no longer fail / time out.
>+
>+        * TestExpectations:
>+
> 2018-05-18  Chris Dumez  <cdumez@apple.com>
> 
>         Unreviewed, rolling out r231935.
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index 341cea138ab37929a8e8f29d39a075f69c8b5ec0..70e1a855fa5f39e8156e315969a901c274f8edf0 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,33 @@
>+2018-05-18  Chris Dumez  <cdumez@apple.com>
>+
>+        File's structured serialization should serialize lastModified attribute
>+        https://bugs.webkit.org/show_bug.cgi?id=185773
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Re-sync workers/semantics/structured-clone WPT tests after:
>+        https://github.com/w3c/web-platform-tests/pull/9218
>+
>+        * web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js: Added.
>+        (runStructuredCloneBatteryOfTests):
>+        * web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js: Added.
>+        (structuredCloneBatteryOfTests.push.async.f):
>+        * web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests.js: Renamed from LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/common.js.
>+        (async.compare_Blob):
>+        (get_canvas_1x1_transparent_black):
>+        (get_canvas_1x1_non_transparent_non_black):
>+        (compare_ImageBitmap):
>+        (structuredCloneBatteryOfTests.push.async.f):
>+        * web-platform-tests/html/webappapis/structured-clone/w3c-import.log: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/w3c-import.log.
>+        * web-platform-tests/workers/semantics/structured-clone/dedicated-expected.txt:
>+        * web-platform-tests/workers/semantics/structured-clone/dedicated.html:
>+        * web-platform-tests/workers/semantics/structured-clone/dedicated.js: Removed.
>+        * web-platform-tests/workers/semantics/structured-clone/shared-expected.txt:
>+        * web-platform-tests/workers/semantics/structured-clone/shared.html:
>+        * web-platform-tests/workers/semantics/structured-clone/shared.js: Removed.
>+        * web-platform-tests/workers/semantics/structured-clone/w3c-import.log:
>+        * web-platform-tests/workers/semantics/structured-clone/worker-common.js: Removed.
>+
> 2018-05-18  Antoine Quint  <graouts@apple.com>
> 
>         [Web Animations] Turn Web Animations with CSS integration on for test runners
>diff --git a/LayoutTests/TestExpectations b/LayoutTests/TestExpectations
>index d6f76431ccd6a2214832512d42c7e2041fd552ee..f0de02a517b274994a896adcef09e7d6953674b7 100644
>--- a/LayoutTests/TestExpectations
>+++ b/LayoutTests/TestExpectations
>@@ -241,8 +241,6 @@ imported/w3c/web-platform-tests/workers/interfaces/WorkerUtils/importScripts/006
> imported/w3c/web-platform-tests/workers/nested_worker.worker.html [ Skip ]
> imported/w3c/web-platform-tests/workers/opaque-origin.html [ Skip ]
> imported/w3c/web-platform-tests/workers/semantics/interface-objects/003.html [ Skip ]
>-imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html [ Skip ]
>-imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html [ Skip ]
> imported/w3c/web-platform-tests/workers/semantics/multiple-workers/003.html [ Skip ]
> imported/w3c/web-platform-tests/workers/semantics/multiple-workers/005.html [ Skip ]
> imported/w3c/web-platform-tests/workers/Worker_cross_origin_security_err.htm [ Skip ]
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..624f98344c8b2a2ebf0876080cccc8b6a6a2bd71
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js
>@@ -0,0 +1,39 @@
>+/**
>+ * 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.
>+ * - `noTransferTests`: When true, disables tests with transferables
>+ */
>+
>+function runStructuredCloneBatteryOfTests(runner) {
>+  const defaultRunner = {
>+    setup() {},
>+    preTest() {},
>+    postTest() {},
>+    teardown() {}
>+  };
>+  runner = Object.assign({}, defaultRunner, runner);
>+
>+  let setupPromise = runner.setup();
>+  const allTests = structuredCloneBatteryOfTests.map(test => {
>+
>+    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/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..744f1168196001f4eff1975d369ae1d4f41db229
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/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/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests.js b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..40bcd8031b220bd75811468cde0a4c3bb6c15621
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests.js
>@@ -0,0 +1,586 @@
>+/* This file is mostly a remix of @zcorpanâs web worker test suite */
>+
>+structuredCloneBatteryOfTests = [];
>+
>+function check(description, input, callback) {
>+  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);
>+    }
>+  });
>+}
>+
>+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 (var 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('Array primitives', [undefined,
>+                           null,
>+                           true,
>+                           false,
>+                           '',
>+                           '\uD800',
>+                           '\uDC00',
>+                           '\u0000',
>+                           '\uDBFF\uDFFD',
>+                           0.2,
>+                           0,
>+                           -0,
>+                           NaN,
>+                           Infinity,
>+                           -Infinity,
>+                           9007199254740992,
>+                           -9007199254740992,
>+                           9007199254740994,
>+                           -9007199254740994], 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) {
>+  var Type = window[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'));
>+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() {
>+  var 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 = new Response(actual).arrayBuffer();
>+  const ab2 = new Response(input).arrayBuffer();
>+  assert_equals(ab1.btyeLength, 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
>+  var 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() {
>+    var buffer = new ArrayBuffer(arr.length);
>+    var view = new DataView(buffer);
>+    for (var 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('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() {
>+  var input = document.createElement('input');
>+  input.type = 'file';
>+  return input.files;
>+}
>+check('FileList empty', func_FileList_empty, compare_FileList);
>+check('Array FileList object, FileList empty', [func_FileList_empty()], compare_Array(enumerate_props(compare_FileList)));
>+check('Object FileList object, FileList empty', {'x':func_FileList_empty()}, compare_Object(enumerate_props(compare_FileList)));
>+
>+function compare_ArrayBufferView(view) {
>+  var Type = window[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 (var 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() {
>+  var canvas = document.createElement('canvas');
>+  var ctx = canvas.getContext('2d');
>+  return ctx.createImageData(1, 1);
>+}
>+check('ImageData 1x1 transparent black', func_ImageData_1x1_transparent_black, compare_ImageData);
>+function func_ImageData_1x1_non_transparent_non_black() {
>+  var canvas = document.createElement('canvas');
>+  var ctx = canvas.getContext('2d');
>+  var 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);
>+check('Array ImageData object, ImageData 1x1 transparent black', [func_ImageData_1x1_transparent_black()], compare_Array(enumerate_props(compare_ImageData)));
>+check('Array ImageData object, ImageData 1x1 non-transparent non-black', [func_ImageData_1x1_non_transparent_non_black()], compare_Array(enumerate_props(compare_ImageData)));
>+check('Object ImageData object, ImageData 1x1 transparent black', {'x':func_ImageData_1x1_transparent_black()}, compare_Object(enumerate_props(compare_ImageData)));
>+check('Object ImageData object, ImageData 1x1 non-transparent non-black', {'x':func_ImageData_1x1_non_transparent_non_black()}, compare_Object(enumerate_props(compare_ImageData)));
>+
>+
>+check('Array sparse', new Array(10), compare_Array(enumerate_props(compare_primitive)));
>+check('Array with non-index property', function() {
>+  var 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() {
>+  var rv = [];
>+  rv[0] = rv;
>+  return rv;
>+}, compare_Array(check_circular_property('0')));
>+check('Object with circular reference', function() {
>+  var 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() {
>+  var obj = {}
>+  return [obj, obj];
>+}, compare_Array(check_identical_property_values('0', '1')));
>+check('Object with identical property values', function() {
>+  var 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() {
>+  var Foo = function() {};
>+  Foo.prototype = {'foo':'bar'};
>+  return new Foo();
>+}, compare_Object(check_absent_property('foo')));
>+
>+check('Object with non-enumerable property', function() {
>+  var 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() {
>+  var 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() {
>+  var 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() {
>+  var canvas = document.createElement('canvas');
>+  canvas.width = 1;
>+  canvas.height = 1;
>+  return canvas;
>+}
>+
>+function get_canvas_1x1_non_transparent_non_black() {
>+  var canvas = document.createElement('canvas');
>+  canvas.width = 1;
>+  canvas.height = 1;
>+  var ctx = canvas.getContext('2d');
>+  var 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) {
>+    var canvas = get_canvas_1x1_transparent_black();
>+    const bm = await createImageBitmap(canvas);
>+    const copy = await runner.structuredClone(bm);
>+    compare_ImageBitmap(bm, copy);
>+  }
>+});
>+
>+structuredCloneBatteryOfTests.push({
>+  description: 'ImageBitmap 1x1 non-transparent non-black',
>+  async f(runner) {
>+    var canvas = get_canvas_1x1_non_transparent_non_black();
>+    const bm = await createImageBitmap(canvas);
>+    const copy = await runner.structuredClone(bm);
>+    compare_ImageBitmap(bm, copy);
>+  }
>+});
>+
>+structuredCloneBatteryOfTests.push({
>+  description: 'Array ImageBitmap object, ImageBitmap 1x1 transparent black',
>+  async f(runner) {
>+    var 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);
>+  }
>+});
>+
>+structuredCloneBatteryOfTests.push({
>+  description: 'Array ImageBitmap object, ImageBitmap 1x1 transparent non-black',
>+  async f(runner) {
>+    var 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);
>+  }
>+});
>+
>+structuredCloneBatteryOfTests.push({
>+  description: 'Object ImageBitmap object, ImageBitmap 1x1 transparent black',
>+  async f(runner) {
>+    var 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);
>+  }
>+});
>+
>+structuredCloneBatteryOfTests.push({
>+  description: 'Object ImageBitmap object, ImageBitmap 1x1 transparent non-black',
>+  async f(runner) {
>+    var 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);
>+  }
>+});
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/w3c-import.log
>new file mode 100644
>index 0000000000000000000000000000000000000000..4753241bef44d372818f03f71203f6f873212d28
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/w3c-import.log
>@@ -0,0 +1,19 @@
>+The tests in this directory were imported from the W3C repository.
>+Do NOT modify these tests directly in WebKit.
>+Instead, create a pull request on the WPT github:
>+	https://github.com/w3c/web-platform-tests
>+
>+Then run the Tools/Scripts/import-w3c-tests in WebKit to reimport
>+
>+Do NOT modify or remove this file.
>+
>+------------------------------------------------------------------------
>+Properties requiring vendor prefixes:
>+None
>+Property values requiring vendor prefixes:
>+None
>+------------------------------------------------------------------------
>+List of files:
>+/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js
>+/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js
>+/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/structured-clone/structured-clone-battery-of-tests.js
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/common.js b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/common.js
>deleted file mode 100644
>index 56c2a30040183c7bbe7b3f65eab91412fe06dafb..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/common.js
>+++ /dev/null
>@@ -1,596 +0,0 @@
>-function createWorker(msg) {
>-  // `type` is defined in the test case itself
>-  if (type == 'dedicated')
>-    return new Worker('dedicated.js#'+encodeURIComponent(msg));
>-  else if (type == 'shared')
>-    return (new SharedWorker('shared.js#'+encodeURIComponent(msg))).port;
>-  else
>-    assert_unreached('invalid or missing `type`');
>-}
>-
>-function check(msg, input, callback, test_obj) {
>-  if (!test_obj)
>-    test_obj = async_test(msg);
>-  test_obj.step(function() {
>-    var w = createWorker(msg);
>-    if (typeof input === 'function')
>-      input = this.step(input);
>-    w.postMessage(input);
>-    w.onmessage = this.step_func(function(ev) { callback(ev.data, input, this); });
>-  });
>-}
>-
>-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 (var 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('Array primitives', [undefined,
>-                           null,
>-                           true,
>-                           false,
>-                           '',
>-                           '\uD800',
>-                           '\uDC00',
>-                           '\u0000',
>-                           '\uDBFF\uDFFD',
>-                           0.2,
>-                           0,
>-                           -0,
>-                           NaN,
>-                           Infinity,
>-                           -Infinity,
>-                           9007199254740992,
>-                           -9007199254740992,
>-                           9007199254740994,
>-                           -9007199254740994], 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) {
>-  var Type = window[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'));
>-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() {
>-  var 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'))));
>-
>-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);
>-  var ev_reader = new FileReader();
>-  var input_reader = new FileReader();
>-  var read_count = 0;
>-  var read_done = test_obj.step_func(function() {
>-    read_count++;
>-    if (read_count == 2) {
>-      var ev_result = ev_reader.result;
>-      var input_result = input_reader.result;
>-      assert_equals(ev_result.byteLength, input_result.byteLength, 'byteLength');
>-      var ev_view = new DataView(ev_result);
>-      var input_view = new DataView(input_result);
>-      for (var i = 0; i < ev_result.byteLength; ++i) {
>-        assert_equals(ev_view.getUint8(i), input_view.getUint8(i), 'getUint8('+i+')');
>-      }
>-      if (test_obj)
>-        test_obj.done();
>-    }
>-  });
>-  var read_error = test_obj.step_func(function() { assert_unreached('FileReader error'); });
>-  ev_reader.readAsArrayBuffer(actual);
>-  ev_reader.onload = read_done;
>-  ev_reader.onabort = ev_reader.onerror = read_error;
>-  input_reader.readAsArrayBuffer(input);
>-  input_reader.onload = read_done;
>-  input_reader.onabort = input_reader.onerror = read_error;
>-}
>-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
>-  var 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() {
>-    var buffer = new ArrayBuffer(arr.length);
>-    var view = new DataView(buffer);
>-    for (var 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);
>-
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_basic)], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob basic');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_bytes([0xD800]))], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob unpaired high surrogate (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_bytes([0xDC00]))], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob unpaired low surrogate (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_bytes([0xD800, 0xDC00]))], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob paired surrogates (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_empty)], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob empty');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_Blob_NUL)], compare_Array(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Array Blob object, Blob NUL');
>-
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_basic)}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob basic');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_bytes([0xD800]))}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob unpaired high surrogate (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_bytes([0xDC00]))}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob unpaired low surrogate (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_bytes([0xD800, 0xDC00]))}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob paired surrogates (invalid utf-8)');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_empty)}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob empty');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_Blob_NUL)}, compare_Object(enumerate_props(compare_Blob, test_obj), true), test_obj);
>-}, 'Object Blob object, Blob NUL');
>-
>-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() {
>-  var input = document.createElement('input');
>-  input.type = 'file';
>-  return input.files;
>-}
>-check('FileList empty', func_FileList_empty, compare_FileList);
>-check('Array FileList object, FileList empty', [func_FileList_empty], compare_Array(enumerate_props(compare_FileList)));
>-check('Object FileList object, FileList empty', {'x':func_FileList_empty}, compare_Object(enumerate_props(compare_FileList)));
>-
>-function compare_ArrayBufferView(view) {
>-  var Type = window[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 (var 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() {
>-  var canvas = document.createElement('canvas');
>-  var ctx = canvas.getContext('2d');
>-  return ctx.createImageData(1, 1);
>-}
>-check('ImageData 1x1 transparent black', func_ImageData_1x1_transparent_black, compare_ImageData);
>-function func_ImageData_1x1_non_transparent_non_black() {
>-  var canvas = document.createElement('canvas');
>-  var ctx = canvas.getContext('2d');
>-  var 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);
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_ImageData_1x1_transparent_black)], compare_Array(enumerate_props(compare_ImageData)), test_obj);
>-}, 'Array ImageData object, ImageData 1x1 transparent black');
>-async_test(function(test_obj) {
>-  check(test_obj.name, [test_obj.step(func_ImageData_1x1_non_transparent_non_black)], compare_Array(enumerate_props(compare_ImageData)), test_obj);
>-}, 'Array ImageData object, ImageData 1x1 non-transparent non-black');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_ImageData_1x1_transparent_black)}, compare_Object(enumerate_props(compare_ImageData)), test_obj);
>-}, 'Object ImageData object, ImageData 1x1 transparent black');
>-async_test(function(test_obj) {
>-  check(test_obj.name, {'x':test_obj.step(func_ImageData_1x1_non_transparent_non_black)}, compare_Object(enumerate_props(compare_ImageData)), test_obj);
>-}, 'Object ImageData object, ImageData 1x1 non-transparent non-black');
>-
>-function compare_ImageBitmap(actual, input, test_obj) {
>-  if (typeof actual === 'string')
>-    assert_unreached(actual);
>-  assert_equals(actual instanceof ImageBitmap, 'instanceof ImageBitmap');
>-  assert_not_equals(actual, input);
>-  // XXX paint the ImageBitmap on a canvas and check the data
>-  if (test_obj)
>-    test_obj.done();
>-}
>-function get_canvas_1x1_transparent_black() {
>-  var canvas = document.createElement('canvas');
>-  canvas.width = 1;
>-  canvas.height = 1;
>-  return canvas;
>-}
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_transparent_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, image, compare_ImageBitmap, test_obj); });
>-}, 'ImageBitmap 1x1 transparent black');
>-function get_canvas_1x1_non_transparent_non_black() {
>-  var canvas = document.createElement('canvas');
>-  canvas.width = 1;
>-  canvas.height = 1;
>-  var ctx = canvas.getContext('2d');
>-  var 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;
>-}
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_non_transparent_non_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, image, compare_ImageBitmap, test_obj); });
>-}, 'ImageBitmap 1x1 non-transparent non-black');
>-
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_transparent_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, [image], compare_Array(enumerate_props(compare_ImageBitmap)), test_obj); });
>-}, 'Array ImageBitmap object, ImageBitmap 1x1 transparent black');
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_non_transparent_non_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, [image], compare_Array(enumerate_props(compare_ImageBitmap)), test_obj); });
>-}, 'Array ImageBitmap object, ImageBitmap 1x1 non-transparent non-black');
>-
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_transparent_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, {'x':image}, compare_Object(enumerate_props(compare_ImageBitmap)), test_obj); });
>-}, 'Object ImageBitmap object, ImageBitmap 1x1 transparent black');
>-async_test(function(test_obj) {
>-  var canvas = get_canvas_1x1_non_transparent_non_black();
>-  createImageBitmap(canvas, function(image) { check(test_obj.name, {'x':image}, compare_Object(enumerate_props(compare_ImageBitmap)), test_obj); });
>-}, 'Object ImageBitmap object, ImageBitmap 1x1 non-transparent non-black');
>-
>-check('Array sparse', new Array(10), compare_Array(enumerate_props(compare_primitive)));
>-check('Array with non-index property', function() {
>-  var 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() {
>-  var rv = [];
>-  rv[0] = rv;
>-  return rv;
>-}, compare_Array(check_circular_property('0')));
>-check('Object with circular reference', function() {
>-  var 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() {
>-  var obj = {}
>-  return [obj, obj];
>-}, compare_Array(check_identical_property_values('0', '1')));
>-check('Object with identical property values', function() {
>-  var 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() {
>-  var Foo = function() {};
>-  Foo.prototype = {'foo':'bar'};
>-  return new Foo();
>-}, compare_Object(check_absent_property('foo')));
>-
>-check('Object with non-enumerable property', function() {
>-  var 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() {
>-  var 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() {
>-  var rv = {};
>-  Object.defineProperty(rv, 'foo', {value:'bar', enumerable:true, writable:true, configurable:false});
>-  return rv;
>-}, compare_Object(check_configurable_property('foo')));
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated-expected.txt
>index cad234d3ecefbb5d57ba387fe6b274adbb9f4c2a..57b71d41661e56a4538c4aaf9e0d9657173cddff 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated-expected.txt
>@@ -1,6 +1,4 @@
> 
>-Harness Error (TIMEOUT), message = null
>-
> PASS primitive undefined 
> PASS primitive null 
> PASS primitive true 
>@@ -52,57 +50,51 @@ PASS Date 8.64e15
> PASS Array Date objects 
> PASS Object Date objects 
> PASS RegExp flags and lastIndex 
>-FAIL RegExp sticky flag assert_unreached: FAIL: unknown test Reached unreachable code
>-FAIL RegExp unicode flag assert_unreached: FAIL: unknown test Reached unreachable code
>+FAIL RegExp sticky flag assert_equals: sticky expected true but got false
>+FAIL RegExp unicode flag assert_equals: unicode expected true but got false
> PASS RegExp empty 
> PASS RegExp slash 
> PASS RegExp new line 
> PASS Array RegExp object, RegExp flags and lastIndex 
>-FAIL Array RegExp object, RegExp sticky flag assert_unreached: FAIL: unknown test Reached unreachable code
>-FAIL Array RegExp object, RegExp unicode flag assert_unreached: FAIL: unknown test Reached unreachable code
>+FAIL Array RegExp object, RegExp sticky flag assert_equals: sticky expected true but got false
>+FAIL Array RegExp object, RegExp unicode flag assert_equals: unicode expected true but got false
> PASS Array RegExp object, RegExp empty 
> PASS Array RegExp object, RegExp slash 
> PASS Array RegExp object, RegExp new line 
> PASS Object RegExp object, RegExp flags and lastIndex 
>-FAIL Object RegExp object, RegExp sticky flag assert_unreached: FAIL: unknown test Reached unreachable code
>-FAIL Object RegExp object, RegExp unicode flag assert_unreached: FAIL: unknown test Reached unreachable code
>+FAIL Object RegExp object, RegExp sticky flag assert_equals: sticky expected true but got false
>+FAIL Object RegExp object, RegExp unicode flag assert_equals: unicode expected true but got false
> PASS Object RegExp object, RegExp empty 
> PASS Object RegExp object, RegExp slash 
> PASS Object RegExp object, RegExp new line 
>-FAIL Blob basic assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Blob unpaired high surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Blob unpaired low surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Blob paired surrogates (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Blob empty assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Blob NUL assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob basic assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob unpaired high surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob unpaired low surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob paired surrogates (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob empty assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Array Blob object, Blob NUL assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob basic assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob unpaired high surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob unpaired low surrogate (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob paired surrogates (invalid utf-8) assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob empty assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL Object Blob object, Blob NUL assert_unreached: FAIL ReferenceError: Can't find variable: File Reached unreachable code
>-FAIL File basic assert_true: instanceof File expected true got false
>-FAIL FileList empty assert_unreached: FAIL ReferenceError: Can't find variable: FileList Reached unreachable code
>-FAIL Array FileList object, FileList empty The object can not be cloned.
>-FAIL Object FileList object, FileList empty The object can not be cloned.
>+PASS Blob basic 
>+PASS Blob unpaired high surrogate (invalid utf-8) 
>+PASS Blob unpaired low surrogate (invalid utf-8) 
>+PASS Blob paired surrogates (invalid utf-8) 
>+PASS Blob empty 
>+PASS Blob NUL 
>+PASS Array Blob object, Blob basic 
>+PASS Array Blob object, Blob unpaired high surrogate (invalid utf-8) 
>+PASS Array Blob object, Blob unpaired low surrogate (invalid utf-8) 
>+PASS Array Blob object, Blob paired surrogates (invalid utf-8) 
>+PASS Array Blob object, Blob empty 
>+PASS Array Blob object, Blob NUL 
>+PASS Object Blob object, Blob basic 
>+PASS Object Blob object, Blob unpaired high surrogate (invalid utf-8) 
>+PASS Object Blob object, Blob unpaired low surrogate (invalid utf-8) 
>+PASS Object Blob object, Blob paired surrogates (invalid utf-8) 
>+PASS Object Blob object, Blob empty 
>+PASS Object Blob object, Blob NUL 
>+PASS File basic 
>+PASS FileList empty 
>+PASS Array FileList object, FileList empty 
>+PASS Object FileList object, FileList empty 
> PASS ImageData 1x1 transparent black 
> PASS ImageData 1x1 non-transparent non-black 
> PASS Array ImageData object, ImageData 1x1 transparent black 
> PASS Array ImageData object, ImageData 1x1 non-transparent non-black 
> PASS Object ImageData object, ImageData 1x1 transparent black 
> PASS Object ImageData object, ImageData 1x1 non-transparent non-black 
>-TIMEOUT ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT ImageBitmap 1x1 non-transparent non-black Test timed out
>-TIMEOUT Array ImageBitmap object, ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT Array ImageBitmap object, ImageBitmap 1x1 non-transparent non-black Test timed out
>-TIMEOUT Object ImageBitmap object, ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT Object ImageBitmap object, ImageBitmap 1x1 non-transparent non-black Test timed out
> PASS Array sparse 
> PASS Array with non-index property 
> PASS Object with index property and length 
>@@ -114,4 +106,12 @@ PASS Object with property on prototype
> PASS Object with non-enumerable property 
> PASS Object with non-writable property 
> PASS Object with non-configurable property 
>+FAIL ImageBitmap 1x1 transparent black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+FAIL ImageBitmap 1x1 non-transparent non-black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+FAIL Array ImageBitmap object, ImageBitmap 1x1 transparent black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+FAIL Array ImageBitmap object, ImageBitmap 1x1 transparent non-black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+FAIL Object ImageBitmap object, ImageBitmap 1x1 transparent black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+FAIL Object ImageBitmap object, ImageBitmap 1x1 transparent non-black promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+PASS ArrayBuffer 
>+PASS MessagePort 
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html
>index 5dd8c3561e9634f27f2804a55ef7e88528f2cc65..2f1732c13b3d330f2176dc9f45a552fb506d514e 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html
>@@ -2,8 +2,31 @@
> <title>structured clone to dedicated worker</title>
> <script src="/resources/testharness.js"></script>
> <script src="/resources/testharnessreport.js"></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests.js></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js></script>
> <div id=log></div>
> <script>
>-var type = 'dedicated';
>+  runStructuredCloneBatteryOfTests({
>+    setup() {
>+      const blob = new Blob([`
>+        onmessage = ev => postMessage(ev.data, ev.data.transfer);
>+      `], {type: 'text/javascript'});
>+      this.blobURL = URL.createObjectURL(blob);
>+      this.worker = new Worker(this.blobURL);
>+    },
>+    structuredClone(data, transfer) {
>+      return new Promise(resolve => {
>+        this.worker.addEventListener('message', function f(ev) {
>+          this.worker.removeEventListener('message', f);
>+          resolve(ev.data.data);
>+        }.bind(this));
>+        this.worker.postMessage({data, transfer}, transfer);
>+      });
>+    },
>+    teardown() {
>+      this.worker.terminate();
>+      URL.revokeObjectURL(this.blobURL);
>+    }
>+  });
> </script>
>-<script src="common.js"></script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.js b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.js
>deleted file mode 100644
>index 4744578b2295e487f3ac6fb3d4c760c8aa07501e..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.js
>+++ /dev/null
>@@ -1,4 +0,0 @@
>-importScripts('worker-common.js');
>-onmessage = function(ev) {
>-  check(ev.data, self);
>-};
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared-expected.txt
>index 8c6b6c64c8cae3e61d18d6405d122bc00b29941a..93285f824f97899f4f75a06efef8fecf2ed9072d 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared-expected.txt
>@@ -1,117 +1,4 @@
>+CONSOLE MESSAGE: line 19: ReferenceError: Can't find variable: SharedWorker
> 
>-Harness Error (TIMEOUT), message = null
>-
>-FAIL primitive undefined Can't find variable: SharedWorker
>-FAIL primitive null Can't find variable: SharedWorker
>-FAIL primitive true Can't find variable: SharedWorker
>-FAIL primitive false Can't find variable: SharedWorker
>-FAIL primitive string, empty string Can't find variable: SharedWorker
>-FAIL primitive string, lone high surrogate Can't find variable: SharedWorker
>-FAIL primitive string, lone low surrogate Can't find variable: SharedWorker
>-FAIL primitive string, NUL Can't find variable: SharedWorker
>-FAIL primitive string, astral character Can't find variable: SharedWorker
>-FAIL primitive number, 0.2 Can't find variable: SharedWorker
>-FAIL primitive number, 0 Can't find variable: SharedWorker
>-FAIL primitive number, -0 Can't find variable: SharedWorker
>-FAIL primitive number, NaN Can't find variable: SharedWorker
>-FAIL primitive number, Infinity Can't find variable: SharedWorker
>-FAIL primitive number, -Infinity Can't find variable: SharedWorker
>-FAIL primitive number, 9007199254740992 Can't find variable: SharedWorker
>-FAIL primitive number, -9007199254740992 Can't find variable: SharedWorker
>-FAIL primitive number, 9007199254740994 Can't find variable: SharedWorker
>-FAIL primitive number, -9007199254740994 Can't find variable: SharedWorker
>-FAIL Array primitives Can't find variable: SharedWorker
>-FAIL Object primitives Can't find variable: SharedWorker
>-FAIL Boolean true Can't find variable: SharedWorker
>-FAIL Boolean false Can't find variable: SharedWorker
>-FAIL Array Boolean objects Can't find variable: SharedWorker
>-FAIL Object Boolean objects Can't find variable: SharedWorker
>-FAIL String empty string Can't find variable: SharedWorker
>-FAIL String lone high surrogate Can't find variable: SharedWorker
>-FAIL String lone low surrogate Can't find variable: SharedWorker
>-FAIL String NUL Can't find variable: SharedWorker
>-FAIL String astral character Can't find variable: SharedWorker
>-FAIL Array String objects Can't find variable: SharedWorker
>-FAIL Object String objects Can't find variable: SharedWorker
>-FAIL Number 0.2 Can't find variable: SharedWorker
>-FAIL Number 0 Can't find variable: SharedWorker
>-FAIL Number -0 Can't find variable: SharedWorker
>-FAIL Number NaN Can't find variable: SharedWorker
>-FAIL Number Infinity Can't find variable: SharedWorker
>-FAIL Number -Infinity Can't find variable: SharedWorker
>-FAIL Number 9007199254740992 Can't find variable: SharedWorker
>-FAIL Number -9007199254740992 Can't find variable: SharedWorker
>-FAIL Number 9007199254740994 Can't find variable: SharedWorker
>-FAIL Number -9007199254740994 Can't find variable: SharedWorker
>-FAIL Array Number objects Can't find variable: SharedWorker
>-FAIL Object Number objects Can't find variable: SharedWorker
>-FAIL Date 0 Can't find variable: SharedWorker
>-FAIL Date -0 Can't find variable: SharedWorker
>-FAIL Date -8.64e15 Can't find variable: SharedWorker
>-FAIL Date 8.64e15 Can't find variable: SharedWorker
>-FAIL Array Date objects Can't find variable: SharedWorker
>-FAIL Object Date objects Can't find variable: SharedWorker
>-FAIL RegExp flags and lastIndex Can't find variable: SharedWorker
>-FAIL RegExp sticky flag Can't find variable: SharedWorker
>-FAIL RegExp unicode flag Can't find variable: SharedWorker
>-FAIL RegExp empty Can't find variable: SharedWorker
>-FAIL RegExp slash Can't find variable: SharedWorker
>-FAIL RegExp new line Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp flags and lastIndex Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp sticky flag Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp unicode flag Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp empty Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp slash Can't find variable: SharedWorker
>-FAIL Array RegExp object, RegExp new line Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp flags and lastIndex Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp sticky flag Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp unicode flag Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp empty Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp slash Can't find variable: SharedWorker
>-FAIL Object RegExp object, RegExp new line Can't find variable: SharedWorker
>-FAIL Blob basic Can't find variable: SharedWorker
>-FAIL Blob unpaired high surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Blob unpaired low surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Blob paired surrogates (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Blob empty Can't find variable: SharedWorker
>-FAIL Blob NUL Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob basic Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob unpaired high surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob unpaired low surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob paired surrogates (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob empty Can't find variable: SharedWorker
>-FAIL Array Blob object, Blob NUL Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob basic Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob unpaired high surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob unpaired low surrogate (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob paired surrogates (invalid utf-8) Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob empty Can't find variable: SharedWorker
>-FAIL Object Blob object, Blob NUL Can't find variable: SharedWorker
>-FAIL File basic Can't find variable: SharedWorker
>-FAIL FileList empty Can't find variable: SharedWorker
>-FAIL Array FileList object, FileList empty Can't find variable: SharedWorker
>-FAIL Object FileList object, FileList empty Can't find variable: SharedWorker
>-FAIL ImageData 1x1 transparent black Can't find variable: SharedWorker
>-FAIL ImageData 1x1 non-transparent non-black Can't find variable: SharedWorker
>-FAIL Array ImageData object, ImageData 1x1 transparent black Can't find variable: SharedWorker
>-FAIL Array ImageData object, ImageData 1x1 non-transparent non-black Can't find variable: SharedWorker
>-FAIL Object ImageData object, ImageData 1x1 transparent black Can't find variable: SharedWorker
>-FAIL Object ImageData object, ImageData 1x1 non-transparent non-black Can't find variable: SharedWorker
>-TIMEOUT ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT ImageBitmap 1x1 non-transparent non-black Test timed out
>-TIMEOUT Array ImageBitmap object, ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT Array ImageBitmap object, ImageBitmap 1x1 non-transparent non-black Test timed out
>-TIMEOUT Object ImageBitmap object, ImageBitmap 1x1 transparent black Test timed out
>-TIMEOUT Object ImageBitmap object, ImageBitmap 1x1 non-transparent non-black Test timed out
>-FAIL Array sparse Can't find variable: SharedWorker
>-FAIL Array with non-index property Can't find variable: SharedWorker
>-FAIL Object with index property and length Can't find variable: SharedWorker
>-FAIL Array with circular reference Can't find variable: SharedWorker
>-FAIL Object with circular reference Can't find variable: SharedWorker
>-FAIL Array with identical property values Can't find variable: SharedWorker
>-FAIL Object with identical property values Can't find variable: SharedWorker
>-FAIL Object with property on prototype Can't find variable: SharedWorker
>-FAIL Object with non-enumerable property Can't find variable: SharedWorker
>-FAIL Object with non-writable property Can't find variable: SharedWorker
>-FAIL Object with non-configurable property Can't find variable: SharedWorker
>+FAIL structured clone to shared worker ReferenceError: Can't find variable: SharedWorker
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html
>index 6f74354d4828e864b7da131029bdd890104227f7..793da8ff3a754454066a28d5c514d4e7f9d8a86a 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html
>@@ -2,8 +2,35 @@
> <title>structured clone to shared worker</title>
> <script src="/resources/testharness.js"></script>
> <script src="/resources/testharnessreport.js"></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests.js></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests-with-transferables.js></script>
>+<script src=/html/webappapis/structured-clone/structured-clone-battery-of-tests-harness.js></script>
> <div id=log></div>
> <script>
>-var type = 'shared';
>+  runStructuredCloneBatteryOfTests({
>+    setup() {
>+      const blob = new Blob([`
>+        onconnect = ev => {
>+          const port = ev.ports[0];
>+          port.onmessage = ev => port.postMessage(ev.data, ev.data.transfer);
>+        };
>+      `], {type: 'text/javascript'});
>+      this.blobURL = URL.createObjectURL(blob);
>+      this.worker = new SharedWorker(this.blobURL);
>+      this.port = this.worker.port;
>+    },
>+    structuredClone(data, transfer) {
>+      return new Promise(resolve => {
>+        this.port.addEventListener('message', function f(ev) {
>+          this.port.removeEventListener('message', f);
>+          resolve(ev.data.data);
>+        }.bind(this));
>+        this.port.start();
>+        this.port.postMessage({data, transfer}, transfer);
>+      });
>+    },
>+    teardown() {
>+      URL.revokeObjectURL(this.blobURL);
>+    }
>+  });
> </script>
>-<script src="common.js"></script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.js b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.js
>deleted file mode 100644
>index 372a9ec98d63c14d41087602f8611bf3c70c4534..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-importScripts('worker-common.js');
>-onconnect = function(connect_ev) {
>-  connect_ev.ports[0].onmessage = function(message_ev) {
>-    check(message_ev.data, this);
>-  };
>-};
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/w3c-import.log
>index 3bc4f81eb4b9cb60a05e423e911c9f34c9135a4c..f22254e1cca0705b40cecd940ea8a12726e9e665 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/w3c-import.log
>@@ -14,9 +14,5 @@ Property values requiring vendor prefixes:
> None
> ------------------------------------------------------------------------
> List of files:
>-/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/common.js
> /LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.html
>-/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/dedicated.js
> /LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.html
>-/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/shared.js
>-/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/worker-common.js
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/worker-common.js b/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/worker-common.js
>deleted file mode 100644
>index fd63ff5a5d717ba1e2752947a123949d6e210f49..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/structured-clone/worker-common.js
>+++ /dev/null
>@@ -1,1018 +0,0 @@
>-var msg = decodeURIComponent(location.hash.substr(1));
>-
>-var log = [];
>-function check_true(actual, msg) {
>-  if (actual !== true) {
>-    log.push(msg);
>-    return false;
>-  }
>-  return true;
>-}
>-
>-function check_Blob(msg, input, port, expect_File, orig_input) {
>-  expect_File = !!expect_File;
>-  orig_input = orig_input || input;
>-  try {
>-    var expected;
>-    switch (msg) {
>-      case 'Blob basic':
>-      case 'File basic':
>-        expected = [0x66, 0x6F, 0x6F];
>-        expected.type = 'text/x-bar';
>-        if (expect_File) {
>-          expected.name = 'bar';
>-          expected.lastModified = 42;
>-        }
>-        break;
>-      case 'Blob unpaired high surrogate (invalid utf-8)':
>-        expected = [0xED, 0xA0, 0x80];
>-        expected.type = '';
>-        break;
>-      case 'Blob unpaired low surrogate (invalid utf-8)':
>-        expected = [0xED, 0xB0, 0x80];
>-        expected.type = '';
>-        break;
>-      case 'Blob paired surrogates (invalid utf-8)':
>-        expected = [0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80];
>-        expected.type = '';
>-        break;
>-      case 'Blob empty':
>-        expected = [];
>-        expected.type = '';
>-        break;
>-      case 'Blob NUL':
>-        var expected = [0x00];
>-        expected.type = '';
>-        break;
>-      default:
>-        check_true(false, 'check_Blob: unknown test');
>-        return;
>-        break;
>-    }
>-    if (check_true(input instanceof Blob, 'input instanceof Blob') &&
>-        check_true((input instanceof File) == expect_File, '(input instanceof File) == expect_File') &&
>-        check_true(input.size === expected.length, 'input.size === expected.length') &&
>-        check_true(input.type === expected.type, 'input.type === expected.type')) {
>-      if (!expect_File || (check_true(input.name === expected.name, 'input.name === expected.name') &&
>-                           check_true(input.lastModified === expected.lastModified))) {
>-        var reader = new FileReader();
>-        var read_done = function() {
>-          try {
>-            var result = reader.result;
>-            check_true(result.byteLength === expected.length, 'result.byteLength === expected.length')
>-            var view = new DataView(result);
>-            for (var i = 0; i < result.byteLength; ++i) {
>-              check_true(view.getUint8(i) === expected[i], 'view.getUint8('+i+') === expected['+i+']')
>-            }
>-            if (log.length === 0) {
>-              port.postMessage(orig_input);
>-            } else {
>-              port.postMessage('FAIL '+log);
>-            }
>-            close();
>-          } catch(ex) {
>-            postMessage('FAIL '+ex);
>-            close();
>-          }
>-        }
>-        var read_error = function() { port.postMessage('FAIL (got FileReader error)'); close(); };
>-        reader.readAsArrayBuffer(input);
>-        reader.onload = read_done;
>-        reader.onabort = reader.onerror = read_error;
>-      }
>-    } else {
>-      port.postMessage('FAIL '+log);
>-      close();
>-    }
>-  } catch(ex) {
>-    postMessage('FAIL '+ex);
>-    close();
>-  }
>-}
>-
>-function check_ImageData(input, expected) {
>-  if (check_true(input instanceof ImageData, 'input instanceof ImageData') &&
>-      check_true(input.width === expected.width, 'input.width === '+expected.width) &&
>-      check_true(input.height === expected.height, 'input.height === '+expected.height) &&
>-      check_true(input.data instanceof Uint8ClampedArray, 'input.data instanceof Uint8ClampedArray') &&
>-      check_true(input.data.length === expected.data.length, 'input.data.length === '+expected.data.length) &&
>-      check_true(!('CanvasPixelArray' in self), "!('CanvasPixelArray' in self)")) {
>-    for (var i = 0; i < input.length; ++i) {
>-      if (!(check_true(input.data[i] === expected.data[i], 'input.data['+i+'] === '+expected.data[i]))) {
>-        return false;
>-      }
>-    }
>-    return true;
>-  }
>-  return false;
>-}
>-
>-function check_ImageBitmap(input, expected) {
>-  return check_true(input instanceof ImageBitmap, 'input instanceof ImageBitmap');
>-  // XXX paint it on a proxy canvas and check the data
>-}
>-
>-function check_RegExp(msg, input) {
>-  // XXX ES6 spec doesn't define exact serialization for `source` (it allows several ways to escape)
>-  switch (msg) {
>-    case 'RegExp flags and lastIndex':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === 'foo', "input.source === 'foo'") &&
>-             check_true(input.global === true, "input.global === true") &&
>-             check_true(input.ignoreCase === true, "input.ignoreCase === true") &&
>-             check_true(input.multiline === true, "input.multiline === true") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    case 'RegExp sticky flag':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === 'foo', "input.source === 'foo'") &&
>-             check_true(input.global === false, "input.global === false") &&
>-             check_true(input.ignoreCase === false, "input.ignoreCase === false") &&
>-             check_true(input.multiline === false, "input.multiline === false") &&
>-             check_true(input.sticky === true, "input.sticky === true") &&
>-             check_true(input.unicode === false, "input.unicode === false") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    case 'RegExp unicode flag':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === 'foo', "input.source === 'foo'") &&
>-             check_true(input.global === false, "input.global === false") &&
>-             check_true(input.ignoreCase === false, "input.ignoreCase === false") &&
>-             check_true(input.multiline === false, "input.multiline === false") &&
>-             check_true(input.sticky === false, "input.sticky === false") &&
>-             check_true(input.unicode === true, "input.unicode === true") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    case 'RegExp empty':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === '(?:)', "input.source === '(?:)'") &&
>-             check_true(input.global === false, "input.global === false") &&
>-             check_true(input.ignoreCase === false, "input.ignoreCase === false") &&
>-             check_true(input.multiline === false, "input.multiline === false") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    case 'RegExp slash':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === '\\/', "input.source === '\\\\/'") &&
>-             check_true(input.global === false, "input.global === false") &&
>-             check_true(input.ignoreCase === false, "input.ignoreCase === false") &&
>-             check_true(input.multiline === false, "input.multiline === false") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    case 'RegExp new line':
>-      return check_true(input instanceof RegExp, "input instanceof RegExp") &&
>-             check_true(input.source === '\\n', "input.source === '\\\\n'") &&
>-             check_true(input.global === false, "input.global === false") &&
>-             check_true(input.ignoreCase === false, "input.ignoreCase === false") &&
>-             check_true(input.multiline === false, "input.multiline === false") &&
>-             check_true(input.lastIndex === 0, "input.lastIndex === 0");
>-      break;
>-    default:
>-      check_true(false, 'check_RegExp: unknown test');
>-      return false;
>-      break;
>-  }
>-}
>-
>-function check_FileList(msg, input) {
>-  try {
>-    return check_true(input instanceof FileList, 'input instanceof FileList') &&
>-           check_true(input.length === 0, 'input.length === 0');
>-  } catch(ex) {
>-    return check_true(false, ex);
>-  }
>-}
>-
>-function check(input, port) {
>-  try {
>-    switch (msg) {
>-      case 'primitive undefined':
>-        if (check_true(input === undefined, 'input === undefined')) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive null':
>-        if (check_true(input === null, 'input === null')) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive true':
>-        if (check_true(input === true, 'input === true')) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive false':
>-        if (check_true(input === false, 'input === false')) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive string, empty string':
>-        if (check_true(input === '', "input === ''")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive string, lone high surrogate':
>-        if (check_true(input === '\uD800', "input === '\uD800'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive string, lone low surrogate':
>-        if (check_true(input === '\uDC00', "input === '\uDC00'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive string, NUL':
>-        if (check_true(input === '\u0000', "input === '\u0000'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive string, astral character':
>-        if (check_true(input === '\uDBFF\uDFFD', "input === '\uDBFF\uDFFD'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, 0.2':
>-        if (check_true(input === 0.2, "input === 0.2")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, 0':
>-        if (check_true(input === 0, "input === 0") &&
>-            check_true(1/input === Infinity, "1/input === Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, -0':
>-        if (check_true(input === 0, "input === 0") &&
>-            check_true(1/input === -Infinity, "1/input === -Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, NaN':
>-        if (check_true(input !== input, "input !== input")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, Infinity':
>-        if (check_true(input === Infinity, "input === Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, -Infinity':
>-        if (check_true(input === -Infinity, "input === -Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, 9007199254740992':
>-        if (check_true(input === 9007199254740992, "input === 9007199254740992")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, -9007199254740992':
>-        if (check_true(input === -9007199254740992, "input === -9007199254740992")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, 9007199254740994':
>-        if (check_true(input === 9007199254740994, "input === 9007199254740994")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'primitive number, -9007199254740994':
>-        if (check_true(input === -9007199254740994, "input === -9007199254740994")) {
>-          port.postMessage(input);
>-          close();
>-          break;
>-        }
>-      case 'Array primitives':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 19, 'input.length === 19') &&
>-            check_true(input[0] === undefined, 'input[0] === undefined') &&
>-            check_true(input[1] === null, 'input[1] === null') &&
>-            check_true(input[2] === true, 'input[2] === true') &&
>-            check_true(input[3] === false, 'input[3] === false') &&
>-            check_true(input[4] === '', "input[4] === ''") &&
>-            check_true(input[5] === '\uD800', "input[5] === '\\uD800'") &&
>-            check_true(input[6] === '\uDC00', "input[6] === '\\uDC00'") &&
>-            check_true(input[7] === '\u0000', "input[7] === '\\u0000'") &&
>-            check_true(input[8] === '\uDBFF\uDFFD', "input[8] === '\\uDBFF\\uDFFD'") &&
>-            check_true(input[9] === 0.2, "input[9] === 0.2") &&
>-            check_true(1/input[10] === Infinity, "1/input[10] === Infinity") &&
>-            check_true(1/input[11] === -Infinity, "1/input[11] === -Infinity") &&
>-            check_true(input[12] !== input[11], "input[12] !== input[11]") &&
>-            check_true(input[13] === Infinity, "input[13] === Infinity") &&
>-            check_true(input[14] === -Infinity, "input[14] === -Infinity") &&
>-            check_true(input[15] === 9007199254740992, "input[15] === 9007199254740992") &&
>-            check_true(input[16] === -9007199254740992, "input[16] === -9007199254740992") &&
>-            check_true(input[17] === 9007199254740994, "input[17] === 9007199254740994") &&
>-            check_true(input[18] === -9007199254740994, "input[18] === -9007199254740994")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object primitives':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_true(input['undefined'] === undefined, "input['undefined'] === undefined") &&
>-              check_true(input['null'] === null, "input['null'] === null") &&
>-              check_true(input['true'] === true, "input['true'] === true") &&
>-              check_true(input['false'] === false, "input['false'] === false") &&
>-              check_true(input['empty'] === '', "input['empty'] === ''") &&
>-              check_true(input['high surrogate'] === '\uD800', "input['high surrogate'] === '\uD800'") &&
>-              check_true(input['low surrogate'] === '\uDC00', "input['low surrogate'] === '\uDC00'") &&
>-              check_true(input['nul'] === '\u0000', "input['nul'] === '\u0000'") &&
>-              check_true(input['astral'] === '\uDBFF\uDFFD', "input['astral'] === '\uDBFF\uDFFD'") &&
>-              check_true(input['0.2'] === 0.2, "input['0.2'] === 0.2") &&
>-              check_true(1/input['0'] === Infinity, "1/input['0'] === Infinity") &&
>-              check_true(1/input['-0'] === -Infinity, "1/input['-0'] === -Infinity") &&
>-              check_true(input['NaN'] !== input['NaN'], "input['NaN'] !== input['NaN']") &&
>-              check_true(input['Infinity'] === Infinity, "input['Infinity'] === Infinity") &&
>-              check_true(input['-Infinity'] === -Infinity, "input['-Infinity'] === -Infinity") &&
>-              check_true(input['9007199254740992'] === 9007199254740992, "input['9007199254740992'] === 9007199254740992") &&
>-              check_true(input['-9007199254740992'] === -9007199254740992, "input['-9007199254740992'] === -9007199254740992") &&
>-              check_true(input['9007199254740994'] === 9007199254740994, "input['9007199254740994'] === 9007199254740994") &&
>-              check_true(input['-9007199254740994'] === -9007199254740994, "input['9007199254740994'] === -9007199254740994")) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 19, 'i === 19')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Boolean true':
>-        if (check_true(input instanceof Boolean, "input instanceof Boolean") &&
>-            check_true(String(input) === 'true', "String(input) === 'true'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Boolean false':
>-        if (check_true(input instanceof Boolean, "input instanceof Boolean") &&
>-            check_true(String(input) === 'false', "String(input) === 'false'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array Boolean objects':
>-        (function() {
>-          if (check_true(input instanceof Array, 'input instanceof Array') &&
>-              check_true(input.length === 2, 'input.length === 2') &&
>-              check_true(String(input[0]) === 'true', "String(input[0]) === 'true'") &&
>-              check_true(String(input[1]) === 'false', "String(input[1]) === 'false'")) {
>-            for (var i = 0; i < input.length; ++i) {
>-              if (!check_true(input[i] instanceof Boolean, 'input['+i+'] instanceof Boolean'))
>-                return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'Object Boolean objects':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_true(String(input['true']) === 'true', "String(input['true']) === 'true'") &&
>-              check_true(String(input['false']) === 'false', "String(input['false']) === 'false'")) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-              if (!check_true(input[x] instanceof Boolean, 'input['+x+'] instanceof Boolean'))
>-                return;
>-            }
>-            if (check_true(i === 2, 'i === 2')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'String empty string':
>-        if (check_true(input instanceof String, "input instanceof String") &&
>-            check_true(String(input) === '', "String(input) === ''")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'String lone high surrogate':
>-        if (check_true(input instanceof String, "input instanceof String") &&
>-            check_true(String(input) === '\uD800', "String(input) === '\\uD800'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'String lone low surrogate':
>-        if (check_true(input instanceof String, "input instanceof String") &&
>-            check_true(String(input) === '\uDC00', "String(input) === '\\uDC00'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'String NUL':
>-        if (check_true(input instanceof String, "input instanceof String") &&
>-            check_true(String(input) === '\u0000', "String(input) === '\\u0000'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'String astral character':
>-        if (check_true(input instanceof String, "input instanceof String") &&
>-            check_true(String(input) === '\uDBFF\uDFFD', "String(input) === '\\uDBFF\\uDFFD'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array String objects':
>-        (function() {
>-          if (check_true(input instanceof Array, 'input instanceof Array') &&
>-              check_true(input.length === 5, 'input.length === 5') &&
>-              check_true(String(input[0]) === '', "String(input[0]) === ''") &&
>-              check_true(String(input[1]) === '\uD800', "String(input[1]) === '\\uD800'") &&
>-              check_true(String(input[2]) === '\uDC00', "String(input[1]) === '\\uDC00'") &&
>-              check_true(String(input[3]) === '\u0000', "String(input[2]) === '\\u0000'") &&
>-              check_true(String(input[4]) === '\uDBFF\uDFFD', "String(input[3]) === '\\uDBFF\\uDFFD'")) {
>-            for (var i = 0; i < input.length; ++i) {
>-              if (!check_true(input[i] instanceof String, 'input['+i+'] instanceof String'))
>-                return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'Object String objects':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_true(String(input['empty']) === '', "String(input['empty']) === ''") &&
>-              check_true(String(input['high surrogate']) === '\uD800', "String(input['high surrogate']) === '\\uD800'") &&
>-              check_true(String(input['low surrogate']) === '\uDC00', "String(input['low surrogate']) === '\\uDC00'") &&
>-              check_true(String(input['nul']) === '\u0000', "String(input['nul']) === '\\u0000'") &&
>-              check_true(String(input['astral']) === '\uDBFF\uDFFD', "String(input['astral']) === '\\uDBFF\\uDFFD'")) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-              if (!check_true(input[x] instanceof String, 'input['+x+'] instanceof Boolean'))
>-                return;
>-            }
>-            if (check_true(i === 5, 'i === 5')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Number 0.2':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === 0.2, "Number(input) === 0.2")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number 0':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(1/Number(input) === Infinity, "1/Number(input) === Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number -0':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(1/Number(input) === -Infinity, "1/Number(input) === -Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number NaN':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) !== Number(input), "Number(input) !== Number(input)")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number Infinity':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === Infinity, "Number(input) === Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number -Infinity':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === -Infinity, "Number(input) === -Infinity")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number 9007199254740992':
>-        if (check_true(input instanceof Number) &&
>-            check_true(Number(input) === 9007199254740992, "Number(input) === 9007199254740992")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number -9007199254740992':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === -9007199254740992, "Number(input) === -9007199254740992")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number 9007199254740994':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === 9007199254740994, "Number(input) === 9007199254740994")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Number -9007199254740994':
>-        if (check_true(input instanceof Number, "input instanceof Number") &&
>-            check_true(Number(input) === -9007199254740994, "Number(input) === -9007199254740994")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array Number objects':
>-        (function() {
>-          if (check_true(input instanceof Array, 'input instanceof Array') &&
>-              check_true(input.length === 10, 'input.length === 10') &&
>-              check_true(Number(input[0]) === 0.2, "Number(input[0]) === 0.2") &&
>-              check_true(1/Number(input[1]) === Infinity, "1/Number(input[1]) === Infinity") &&
>-              check_true(1/Number(input[2]) === -Infinity, "1/Number(input[2]) === -Infinity") &&
>-              check_true(Number(input[3]) !== Number(input[3]), "Number(input[3]) !== Number(input[3])") &&
>-              check_true(Number(input[4]) === Infinity, "Number(input[4]) === Infinity") &&
>-              check_true(Number(input[5]) === -Infinity, "Number(input[5]) === -Infinity") &&
>-              check_true(Number(input[6]) === 9007199254740992, "Number(input[6]) === 9007199254740992") &&
>-              check_true(Number(input[7]) === -9007199254740992, "Number(input[7]) === -9007199254740992") &&
>-              check_true(Number(input[8]) === 9007199254740994, "Number(input[8]) === 9007199254740994") &&
>-              check_true(Number(input[9]) === -9007199254740994, "Number(input[9]) === -9007199254740994")) {
>-            for (var i = 0; i < input.length; ++i) {
>-              if (!check_true(input[i] instanceof Number, 'input['+i+'] instanceof Number'))
>-                return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'Object Number objects':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_true(Number(input['0.2']) === 0.2, "Number(input['0.2']) === 0.2") &&
>-              check_true(1/Number(input['0']) === Infinity, "1/Number(input['0']) === Infinity") &&
>-              check_true(1/Number(input['-0']) === -Infinity, "1/Number(input['-0']) === -Infinity") &&
>-              check_true(Number(input['NaN']) !== Number(input['NaN']), "Number(input['NaN']) !== Number(input['NaN'])") &&
>-              check_true(Number(input['Infinity']) === Infinity, "Number(input['Infinity']) === Infinity") &&
>-              check_true(Number(input['-Infinity']) === -Infinity, "Number(input['-Infinity']) === -Infinity") &&
>-              check_true(Number(input['9007199254740992']) === 9007199254740992, "Number(input['9007199254740992']) === 9007199254740992") &&
>-              check_true(Number(input['-9007199254740992']) === -9007199254740992, "Number(input['-9007199254740992']) === -9007199254740992") &&
>-              check_true(Number(input['9007199254740994']) === 9007199254740994, "Number(input['9007199254740994']) === 9007199254740994") &&
>-              check_true(Number(input['-9007199254740994']) === -9007199254740994, "Number(input['-9007199254740994']) === -9007199254740994")) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-              if (!check_true(input[x] instanceof Number, 'input['+x+'] instanceof Number'))
>-                return;
>-            }
>-            if (check_true(i === 10, 'i === 10')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Date 0':
>-        if (check_true(input instanceof Date, "input instanceof Date") &&
>-            check_true(1/Number(input) === 1/Number(new Date(0)), "1/Number(input) === 1/Number(new Date(0))")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Date -0':
>-        if (check_true(input instanceof Date, "input instanceof Date") &&
>-            check_true(1/Number(input) === 1/Number(new Date(-0)), "1/Number(input) === 1/Number(new Date(-0))")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Date -8.64e15':
>-        if (check_true(input instanceof Date, "input instanceof Date") &&
>-            check_true(Number(input) === -8.64e15, "Number(input) === -8.64e15")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Date 8.64e15':
>-        if (check_true(input instanceof Date, "input instanceof Date") &&
>-            check_true(Number(input) === 8.64e15, "Number(input) === 8.64e15")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array Date objects':
>-        (function() {
>-          if (check_true(input instanceof Array, 'input instanceof Array') &&
>-              check_true(input.length === 4, 'input.length === 4') &&
>-              check_true(1/Number(input[0]) === 1/new Date(0), '1/Number(input[0]) === 1/new Date(0)') &&
>-              check_true(1/Number(input[1]) === 1/new Date(-0), '1/Number(input[1]) === 1/new Date(-0)') &&
>-              check_true(Number(input[2]) === -8.64e15, 'Number(input[2]) === -8.64e15') &&
>-              check_true(Number(input[3]) === 8.64e15, 'Number(input[3]) === 8.64e15')) {
>-            for (var i = 0; i < input.length; ++i) {
>-              if (!check_true(input[i] instanceof Date, 'input['+i+'] instanceof Date'))
>-                return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'Object Date objects':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_true(1/Number(input['0']) === 1/new Date(0), "1/Number(input['0']) === 1/new Date(0)") &&
>-              check_true(1/Number(input['-0']) === 1/new Date(-0), "1/Number(input[1]) === 1/new Date(-0)") &&
>-              check_true(Number(input['-8.64e15']) === -8.64e15, "Number(input['-8.64e15']) === -8.64e15") &&
>-              check_true(Number(input['8.64e15']) === 8.64e15, "Number(input['8.64e15']) === 8.64e15")) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-              if (!check_true(input[x] instanceof Date, 'input['+x+'] instanceof Date'))
>-                return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'RegExp flags and lastIndex':
>-      case 'RegExp empty':
>-      case 'RegExp slash':
>-      case 'RegExp new line':
>-        if (check_RegExp(msg, input)) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array RegExp object, RegExp flags and lastIndex':
>-      case 'Array RegExp object, RegExp empty':
>-      case 'Array RegExp object, RegExp slash':
>-      case 'Array RegExp object, RegExp new line':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_RegExp(msg.substr('Array RegExp object, '.length), input[0])) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object RegExp object, RegExp flags and lastIndex':
>-      case 'Object RegExp object, RegExp empty':
>-      case 'Object RegExp object, RegExp slash':
>-      case 'Object RegExp object, RegExp new line':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_RegExp(msg.substr('Object RegExp object, '.length), input['x'])) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Blob basic':
>-      case 'Blob unpaired high surrogate (invalid utf-8)':
>-      case 'Blob unpaired low surrogate (invalid utf-8)':
>-      case 'Blob paired surrogates (invalid utf-8)':
>-      case 'Blob empty':
>-      case 'Blob NUL':
>-        check_Blob(msg, input, port);
>-        // no postMessage or close here, check_Blob takes care of that
>-        break;
>-      case 'Array Blob object, Blob basic':
>-      case 'Array Blob object, Blob unpaired high surrogate (invalid utf-8)':
>-      case 'Array Blob object, Blob unpaired low surrogate (invalid utf-8)':
>-      case 'Array Blob object, Blob paired surrogates (invalid utf-8)':
>-      case 'Array Blob object, Blob empty':
>-      case 'Array Blob object, Blob NUL':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1')) {
>-          check_Blob(msg.substr('Array Blob object, '.length), input[0], port, false, input);
>-          // no postMessage or close here, check_Blob takes care of that
>-        }
>-        break;
>-      case 'Object Blob object, Blob basic':
>-      case 'Object Blob object, Blob unpaired high surrogate (invalid utf-8)':
>-      case 'Object Blob object, Blob unpaired low surrogate (invalid utf-8)':
>-      case 'Object Blob object, Blob paired surrogates (invalid utf-8)':
>-      case 'Object Blob object, Blob empty':
>-      case 'Object Blob object, Blob NUL':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)')) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              check_Blob(msg.substr('Object Blob object, '.length), input['x'], port, false, input);
>-              // no postMessage or close here, check_Blob takes care of that
>-            }
>-          }
>-        })();
>-        break;
>-      case 'File basic':
>-        check_Blob(msg, input, port, true);
>-        // no postMessage or close here, check_Blob takes care of that
>-        break;
>-      case 'FileList empty':
>-        if (check_FileList(msg, input)) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array FileList object, FileList empty':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_FileList(msg.substr('Array FileList object, '.length), input[0])) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object FileList object, FileList empty':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_FileList(msg.substr('Array FileList object, '.length), input['x'])) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'ImageData 1x1 transparent black':
>-        if (check_ImageData(input, {width:1, height:1, data:[0,0,0,0]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'ImageData 1x1 non-transparent non-black':
>-        if (check_ImageData(input, {width:1, height:1, data:[100, 101, 102, 103]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array ImageData object, ImageData 1x1 transparent black':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_ImageData(input[0], {width:1, height:1, data:[0,0,0,0]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array ImageData object, ImageData 1x1 non-transparent non-black':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_ImageData(input[0], {width:1, height:1, data:[100, 101, 102, 103]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object ImageData object, ImageData 1x1 transparent black':
>-        (function(){
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_ImageData(input['x'], {width:1, height:1, data:[0,0,0,0]})) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Object ImageData object, ImageData 1x1 non-transparent non-black':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_ImageData(input['x'], {width:1, height:1, data:[100, 101, 102, 103]})) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'ImageBitmap 1x1 transparent black':
>-        if (check_ImageBitmap(input, {width:1, height:1, data:[0, 0, 0, 0]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'ImageBitmap 1x1 non-transparent non-black':
>-        if (check_ImageBitmap(input, {width:1, height:1, data:[100, 101, 102, 103]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array ImageBitmap object, ImageBitmap 1x1 transparent black':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_ImageBitmap(input[0], {width:1, height:1, data:[0, 0, 0, 0]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array ImageBitmap object, ImageBitmap 1x1 non-transparent non-black':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_ImageBitmap(input[0], {width:1, height:1, data:[100, 101, 102, 103]})) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object ImageBitmap object, ImageBitmap 1x1 transparent black':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_ImageBitmap(input['x'], {width:1, height:1, data:[0, 0, 0, 0]})) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Object ImageBitmap object, ImageBitmap 1x1 non-transparent non-black':
>-        (function() {
>-          if (check_true(input instanceof Object, 'input instanceof Object') &&
>-              check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-              check_ImageBitmap(input['x'], {width:1, height:1, data:[100, 101, 102, 103]})) {
>-            var i = 0;
>-            for (var x in input) {
>-              i++;
>-            }
>-            if (check_true(i === 1, 'i === 1')) {
>-              port.postMessage(input);
>-              close();
>-            }
>-          }
>-        })();
>-        break;
>-      case 'Array sparse':
>-        (function() {
>-          if (check_true(input instanceof Array, 'input instanceof Array') &&
>-              check_true(input.length === 10, 'input.length === 10')) {
>-            for (var x in input) {
>-              check_true(false, 'unexpected enumerable property '+x);
>-              return;
>-            }
>-            port.postMessage(input);
>-            close();
>-          }
>-        })();
>-        break;
>-      case 'Array with non-index property':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 0, 'input.length === 0') &&
>-            check_true(input.foo === 'bar', "input.foo === 'bar'")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object with index property and length':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(input[0] === 'foo', "input[0] === 'foo'") &&
>-            check_true(input.length === 1, 'input.length === 1')) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array with circular reference':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 1, 'input.length === 1') &&
>-            check_true(input[0] === input, "input[0] === input")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object with circular reference':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(input['x'] === input, "input['x'] === input")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Array with identical property values':
>-        if (check_true(input instanceof Array, 'input instanceof Array') &&
>-            check_true(input.length === 2, 'input.length === 2') &&
>-            check_true(input[0] === input[1], "input[0] === input[1]")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object with identical property values':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(input['x'] === input['y'], "input['x'] === input['y']")) {
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object with property on prototype':
>-      case 'Object with non-enumerable property':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(!('foo' in input), "!('foo' in input)")) {
>-          input = {};
>-          Object.defineProperty(input, 'foo', {value:'bar', enumerable:false, writable:true, configurable:true});
>-          port.postMessage(input);
>-          close();
>-        }
>-        break;
>-      case 'Object with non-writable property':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(input.foo === 'bar', "input.foo === bar")) {
>-          input.foo += ' baz';
>-          if (check_true(input.foo === 'bar baz', "input.foo === 'bar baz'")) {
>-            input = {};
>-            Object.defineProperty(input, 'foo', {value:'bar', enumerable:true, writable:false, configurable:true});
>-            port.postMessage(input);
>-            close();
>-          }
>-        }
>-        break;
>-      case 'Object with non-configurable property':
>-        if (check_true(input instanceof Object, 'input instanceof Object') &&
>-            check_true(!(input instanceof Array), '!(input instanceof Array)') &&
>-            check_true(input.foo === 'bar', "input.foo === bar")) {
>-          delete input.foo;
>-          if (check_true(!('foo' in input), "!('foo' in input)")) {
>-            input = {};
>-            Object.defineProperty(input, 'foo', {value:'bar', enumerable:true, writable:true, configurable:false});
>-            port.postMessage(input);
>-            close();
>-          }
>-        }
>-        break;
>-
>-      default:
>-        port.postMessage('FAIL: unknown test');
>-        close();
>-    }
>-    if (log.length > 0) {
>-      port.postMessage('FAIL '+log);
>-      close();
>-    }
>-  } catch (ex) {
>-    port.postMessage('FAIL '+ex);
>-    close();
>-  }
>-}

Actions: View | Formatted Diff | Diff

Attachments on bug 185773: 340735 | 340741 | 340744 | 340747 | 340770 | 340886 | 340889 | 340892 | 340939