Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 433 insertions, 0 deletions

diff --git a/testing/web-platform/tests/wasm/jsapi/global/constructor.any.js b/testing/web-platform/tests/wasm/jsapi/global/constructor.any.js
new file mode 100644
index 0000000000..f83f77a5c3
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/global/constructor.any.js
@@ -0,0 +1,171 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_Global(actual, expected) {
+  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Global.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(actual), "extensible");
+
+  assert_equals(actual.value, expected, "value");
+  assert_equals(actual.valueOf(), expected, "valueOf");
+}
+
+test(() => {
+  assert_function_name(WebAssembly.Global, "Global", "WebAssembly.Global");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Global, 1, "WebAssembly.Global");
+}, "length");
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.Global());
+}, "No arguments");
+
+test(() => {
+  const argument = { "value": "i32" };
+  assert_throws_js(TypeError, () => WebAssembly.Global(argument));
+}, "Calling");
+
+test(() => {
+  const order = [];
+
+  new WebAssembly.Global({
+    get value() {
+      order.push("descriptor value");
+      return {
+        toString() {
+          order.push("descriptor value toString");
+          return "f64";
+        },
+      };
+    },
+
+    get mutable() {
+      order.push("descriptor mutable");
+      return false;
+    },
+  }, {
+    valueOf() {
+      order.push("value valueOf()");
+    }
+  });
+
+  assert_array_equals(order, [
+    "descriptor mutable",
+    "descriptor value",
+    "descriptor value toString",
+    "value valueOf()",
+  ]);
+}, "Order of evaluation");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws_js(TypeError,
+                     () => new WebAssembly.Global(invalidArgument),
+                     `new Global(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const invalidTypes = ["i16", "i128", "f16", "f128", "u32", "u64", "i32\0"];
+  for (const value of invalidTypes) {
+    const argument = { value };
+    assert_throws_js(TypeError, () => new WebAssembly.Global(argument));
+  }
+}, "Invalid type argument");
+
+test(() => {
+  const argument = { "value": "v128" };
+  assert_throws_js(TypeError, () => new WebAssembly.Global(argument));
+}, "Construct v128 global");
+
+test(() => {
+  const argument = { "value": "i64" };
+  const global = new WebAssembly.Global(argument);
+  assert_Global(global, 0n);
+}, "i64 with default");
+
+for (const type of ["i32", "f32", "f64"]) {
+  test(() => {
+    const argument = { "value": type };
+    const global = new WebAssembly.Global(argument);
+    assert_Global(global, 0);
+  }, `Default value for type ${type}`);
+
+  const valueArguments = [
+    [undefined, 0],
+    [null, 0],
+    [true, 1],
+    [false, 0],
+    [2, 2],
+    ["3", 3],
+    [{ toString() { return "5" } }, 5, "object with toString returning string"],
+    [{ valueOf() { return "8" } }, 8, "object with valueOf returning string"],
+    [{ toString() { return 6 } }, 6, "object with toString returning number"],
+    [{ valueOf() { return 9 } }, 9, "object with valueOf returning number"],
+  ];
+  for (const [value, expected, name = format_value(value)] of valueArguments) {
+    test(() => {
+      const argument = { "value": type };
+      const global = new WebAssembly.Global(argument, value);
+      assert_Global(global, expected);
+    }, `Explicit value ${name} for type ${type}`);
+  }
+
+  test(() => {
+    const argument = { "value": type };
+    assert_throws_js(TypeError, () => new WebAssembly.Global(argument, 0n));
+  }, `BigInt value for type ${type}`);
+}
+
+const valueArguments = [
+  [undefined, 0n],
+  [true, 1n],
+  [false, 0n],
+  ["3", 3n],
+  [123n, 123n],
+  [{ toString() { return "5" } }, 5n, "object with toString returning string"],
+  [{ valueOf() { return "8" } }, 8n, "object with valueOf returning string"],
+  [{ toString() { return 6n } }, 6n, "object with toString returning bigint"],
+  [{ valueOf() { return 9n } }, 9n, "object with valueOf returning bigint"],
+];
+for (const [value, expected, name = format_value(value)] of valueArguments) {
+  test(() => {
+    const argument = { "value": "i64" };
+    const global = new WebAssembly.Global(argument, value);
+    assert_Global(global, expected);
+  }, `Explicit value ${name} for type i64`);
+}
+
+const invalidBigints = [
+  null,
+  666,
+  { toString() { return 5 } },
+  { valueOf() { return 8 } },
+  Symbol(),
+];
+for (const invalidBigint of invalidBigints) {
+  test(() => {
+    var argument = { "value": "i64" };
+    assert_throws_js(TypeError, () => new WebAssembly.Global(argument, invalidBigint));
+  }, `Pass non-bigint as i64 Global value: ${format_value(invalidBigint)}`);
+}
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument, 0, {});
+  assert_Global(global, 0);
+}, "Stray argument");
diff --git a/testing/web-platform/tests/wasm/jsapi/global/toString.any.js b/testing/web-platform/tests/wasm/jsapi/global/toString.any.js
new file mode 100644
index 0000000000..b308498982
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/global/toString.any.js
@@ -0,0 +1,17 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument);
+  assert_class_string(global, "WebAssembly.Global");
+}, "Object.prototype.toString on an Global");
+
+test(() => {
+  assert_own_property(WebAssembly.Global.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WebAssembly.Global", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists on the prototype with the appropriate descriptor");
diff --git a/testing/web-platform/tests/wasm/jsapi/global/type.tentative.any.js b/testing/web-platform/tests/wasm/jsapi/global/type.tentative.any.js
new file mode 100644
index 0000000000..78d612529d
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/global/type.tentative.any.js
@@ -0,0 +1,65 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_type(argument) {
+    const myglobal = new WebAssembly.Global(argument);
+    const globaltype = myglobal.type();
+
+    assert_equals(globaltype.value, argument.value);
+    assert_equals(globaltype.mutable, argument.mutable);
+}
+
+test(() => {
+    assert_type({ "value": "i32", "mutable": true});
+}, "i32, mutable");
+
+test(() => {
+    assert_type({ "value": "i32", "mutable": false});
+}, "i32, immutable");
+
+test(() => {
+    assert_type({ "value": "i64", "mutable": true});
+}, "i64, mutable");
+
+test(() => {
+    assert_type({ "value": "i64", "mutable": false});
+}, "i64, immutable");
+
+test(() => {
+    assert_type({ "value": "f32", "mutable": true});
+}, "f32, mutable");
+
+test(() => {
+    assert_type({ "value": "f32", "mutable": false});
+}, "f32, immutable");
+
+test(() => {
+    assert_type({ "value": "f64", "mutable": true});
+}, "f64, mutable");
+
+test(() => {
+    assert_type({ "value": "f64", "mutable": false});
+}, "f64, immutable");
+
+test(() => {
+    assert_type({"value": "externref", "mutable": true})
+}, "externref, mutable")
+
+test(() => {
+    assert_type({"value": "externref", "mutable": false})
+}, "externref, immutable")
+
+test(() => {
+    assert_type({"value": "funcref", "mutable": true})
+}, "funcref, mutable")
+
+test(() => {
+    assert_type({"value": "funcref", "mutable": false})
+}, "funcref, immutable")
+
+test(() => {
+    const myglobal = new WebAssembly.Global({"value": "i32", "mutable": true});
+    const propertyNames = Object.getOwnPropertyNames(myglobal.type());
+    assert_equals(propertyNames[0], "mutable");
+    assert_equals(propertyNames[1], "value");
+}, "key ordering");
diff --git a/testing/web-platform/tests/wasm/jsapi/global/value-get-set.any.js b/testing/web-platform/tests/wasm/jsapi/global/value-get-set.any.js
new file mode 100644
index 0000000000..bee5581f41
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/global/value-get-set.any.js
@@ -0,0 +1,152 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+
+test(() => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Global,
+    WebAssembly.Global.prototype,
+  ];
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  for (const thisValue of thisValues) {
+    assert_throws_js(TypeError, () => getter.call(thisValue), `getter with this=${format_value(thisValue)}`);
+    assert_throws_js(TypeError, () => setter.call(thisValue, 1), `setter with this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+for (const type of ["i32", "i64", "f32", "f64"]) {
+  const [initial, value, invalid] = type === "i64" ? [0n, 1n, 2] : [0, 1, 2n];
+  const immutableOptions = [
+    [{}, "missing"],
+    [{ "mutable": undefined }, "undefined"],
+    [{ "mutable": null }, "null"],
+    [{ "mutable": false }, "false"],
+    [{ "mutable": "" }, "empty string"],
+    [{ "mutable": 0 }, "zero"],
+  ];
+  for (const [opts, name] of immutableOptions) {
+    test(() => {
+      opts.value = type;
+      const global = new WebAssembly.Global(opts);
+      assert_equals(global.value, initial, "initial value");
+      assert_equals(global.valueOf(), initial, "initial valueOf");
+
+      assert_throws_js(TypeError, () => global.value = value);
+
+      assert_equals(global.value, initial, "post-set value");
+      assert_equals(global.valueOf(), initial, "post-set valueOf");
+    }, `Immutable ${type} (${name})`);
+
+    test(t => {
+      opts.value = type;
+      const global = new WebAssembly.Global(opts);
+      assert_equals(global.value, initial, "initial value");
+      assert_equals(global.valueOf(), initial, "initial valueOf");
+
+      const value = {
+        valueOf: t.unreached_func("should not call valueOf"),
+        toString: t.unreached_func("should not call toString"),
+      };
+      assert_throws_js(TypeError, () => global.value = value);
+
+      assert_equals(global.value, initial, "post-set value");
+      assert_equals(global.valueOf(), initial, "post-set valueOf");
+    }, `Immutable ${type} with ToNumber side-effects (${name})`);
+  }
+
+  const mutableOptions = [
+    [{ "mutable": true }, "true"],
+    [{ "mutable": 1 }, "one"],
+    [{ "mutable": "x" }, "string"],
+    [Object.create({ "mutable": true }), "true on prototype"],
+  ];
+  for (const [opts, name] of mutableOptions) {
+    test(() => {
+      opts.value = type;
+      const global = new WebAssembly.Global(opts);
+      assert_equals(global.value, initial, "initial value");
+      assert_equals(global.valueOf(), initial, "initial valueOf");
+
+      global.value = value;
+
+      assert_throws_js(TypeError, () => global.value = invalid);
+
+      assert_equals(global.value, value, "post-set value");
+      assert_equals(global.valueOf(), value, "post-set valueOf");
+    }, `Mutable ${type} (${name})`);
+  }
+}
+
+test(() => {
+  const argument = { "value": "i64", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+
+  assert_equals(global.value, 0n, "initial value using ToJSValue");
+
+  const valid = [
+    [123n, 123n],
+    [2n ** 63n, - (2n ** 63n)],
+    [true, 1n],
+    [false, 0n],
+    ["456", 456n],
+  ];
+  for (const [input, output] of valid) {
+    global.value = input;
+    assert_equals(global.valueOf(), output, "post-set valueOf");
+  }
+
+  const invalid = [
+    undefined,
+    null,
+    0,
+    1,
+    4.2,
+    Symbol(),
+  ];
+  for (const input of invalid) {
+    assert_throws_js(TypeError, () => global.value = input);
+  }
+}, "i64 mutability");
+
+test(() => {
+  const argument = { "value": "i32", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  assert_throws_js(TypeError, () => setter.call(global));
+}, "Calling setter without argument");
+
+test(() => {
+  const argument = { "value": "i32", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  assert_equals(getter.call(global, {}), 0);
+  assert_equals(setter.call(global, 1, {}), undefined);
+  assert_equals(global.value, 1);
+}, "Stray argument");
diff --git a/testing/web-platform/tests/wasm/jsapi/global/valueOf.any.js b/testing/web-platform/tests/wasm/jsapi/global/valueOf.any.js
new file mode 100644
index 0000000000..5bcb171825
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/global/valueOf.any.js
@@ -0,0 +1,28 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+
+test(() => {
+  const argument = { "value": "i32" };
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Global,
+    WebAssembly.Global.prototype,
+  ];
+
+  const fn = WebAssembly.Global.prototype.valueOf;
+
+  for (const thisValue of thisValues) {
+    assert_throws_js(TypeError, () => fn.call(thisValue), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument, 0);
+  assert_equals(global.valueOf({}), 0);
+}, "Stray argument");