Adding upstream version 124.0.1.upstream/124.0.1

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

3 files changed, 620 insertions, 0 deletions

diff --git a/testing/web-platform/tests/wasm/jsapi/gc/casts.tentative.any.js b/testing/web-platform/tests/wasm/jsapi/gc/casts.tentative.any.js
new file mode 100644
index 0000000000..cce06224fd
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/gc/casts.tentative.any.js
@@ -0,0 +1,332 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let exports = {};
+setup(() => {
+  const builder = new WasmModuleBuilder();
+  const structIndex = builder.addStruct([makeField(kWasmI32, true)]);
+  const arrayIndex = builder.addArray(kWasmI32, true);
+  const structIndex2 = builder.addStruct([makeField(kWasmF32, true)]);
+  const arrayIndex2 = builder.addArray(kWasmF32, true);
+  const funcIndex = builder.addType({ params: [], results: [] });
+  const funcIndex2 = builder.addType({ params: [], results: [kWasmI32] });
+
+  const argFunctions = [
+    { name: "any", code: kWasmAnyRef },
+    { name: "eq", code: kWasmEqRef },
+    { name: "struct", code: kWasmStructRef },
+    { name: "array", code: kWasmArrayRef },
+    { name: "i31", code: kWasmI31Ref },
+    { name: "func", code: kWasmFuncRef },
+    { name: "extern", code: kWasmExternRef },
+    { name: "none", code: kWasmNullRef },
+    { name: "nofunc", code: kWasmNullFuncRef },
+    { name: "noextern", code: kWasmNullExternRef },
+    { name: "concreteStruct", code: structIndex },
+    { name: "concreteArray", code: arrayIndex },
+    { name: "concreteFunc", code: funcIndex },
+  ];
+
+  for (const desc of argFunctions) {
+    builder
+      .addFunction(desc.name + "Arg", makeSig_v_x(wasmRefType(desc.code)))
+      .addBody([])
+      .exportFunc();
+
+    builder
+      .addFunction(desc.name + "NullableArg", makeSig_v_x(wasmRefNullType(desc.code)))
+      .addBody([])
+      .exportFunc();
+  }
+
+  builder
+    .addFunction("makeStruct", makeSig_r_v(wasmRefType(structIndex)))
+    .addBody([...wasmI32Const(42),
+              ...GCInstr(kExprStructNew), structIndex])
+    .exportFunc();
+
+  builder
+    .addFunction("makeArray", makeSig_r_v(wasmRefType(arrayIndex)))
+    .addBody([...wasmI32Const(5), ...wasmI32Const(42),
+              ...GCInstr(kExprArrayNew), arrayIndex])
+    .exportFunc();
+
+  builder
+    .addFunction("makeStruct2", makeSig_r_v(wasmRefType(structIndex2)))
+    .addBody([...wasmF32Const(42),
+              ...GCInstr(kExprStructNew), structIndex2])
+    .exportFunc();
+
+  builder
+    .addFunction("makeArray2", makeSig_r_v(wasmRefType(arrayIndex2)))
+    .addBody([...wasmF32Const(42), ...wasmI32Const(5),
+              ...GCInstr(kExprArrayNew), arrayIndex2])
+    .exportFunc();
+
+  builder
+    .addFunction("testFunc", funcIndex)
+    .addBody([])
+    .exportFunc();
+
+  builder
+    .addFunction("testFunc2", funcIndex2)
+    .addBody([...wasmI32Const(42)])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+  const module = new WebAssembly.Module(buffer);
+  const instance = new WebAssembly.Instance(module, {});
+  exports = instance.exports;
+});
+
+test(() => {
+  exports.anyArg(exports.makeStruct());
+  exports.anyArg(exports.makeArray());
+  exports.anyArg(42);
+  exports.anyArg(42n);
+  exports.anyArg("foo");
+  exports.anyArg({});
+  exports.anyArg(() => {});
+  exports.anyArg(exports.testFunc);
+  assert_throws_js(TypeError, () => exports.anyArg(null));
+
+  exports.anyNullableArg(null);
+  exports.anyNullableArg(exports.makeStruct());
+  exports.anyNullableArg(exports.makeArray());
+  exports.anyNullableArg(42);
+  exports.anyNullableArg(42n);
+  exports.anyNullableArg("foo");
+  exports.anyNullableArg({});
+  exports.anyNullableArg(() => {});
+  exports.anyNullableArg(exports.testFunc);
+}, "anyref casts");
+
+test(() => {
+  exports.eqArg(exports.makeStruct());
+  exports.eqArg(exports.makeArray());
+  exports.eqArg(42);
+  assert_throws_js(TypeError, () => exports.eqArg(42n));
+  assert_throws_js(TypeError, () => exports.eqArg("foo"));
+  assert_throws_js(TypeError, () => exports.eqArg({}));
+  assert_throws_js(TypeError, () => exports.eqArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.eqArg(() => {}));
+  assert_throws_js(TypeError, () => exports.eqArg(null));
+
+  exports.eqNullableArg(null);
+  exports.eqNullableArg(exports.makeStruct());
+  exports.eqNullableArg(exports.makeArray());
+  exports.eqNullableArg(42);
+  assert_throws_js(TypeError, () => exports.eqNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.eqNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.eqNullableArg({}));
+  assert_throws_js(TypeError, () => exports.eqNullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.eqNullableArg(() => {}));
+}, "eqref casts");
+
+test(() => {
+  exports.structArg(exports.makeStruct());
+  assert_throws_js(TypeError, () => exports.structArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.structArg(42));
+  assert_throws_js(TypeError, () => exports.structArg(42n));
+  assert_throws_js(TypeError, () => exports.structArg("foo"));
+  assert_throws_js(TypeError, () => exports.structArg({}));
+  assert_throws_js(TypeError, () => exports.structArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.structArg(() => {}));
+  assert_throws_js(TypeError, () => exports.structArg(null));
+
+  exports.structNullableArg(null);
+  exports.structNullableArg(exports.makeStruct());
+  assert_throws_js(TypeError, () => exports.structNullableArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.structNullableArg(42));
+  assert_throws_js(TypeError, () => exports.structNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.structNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.structNullableArg({}));
+  assert_throws_js(TypeError, () => exports.structNullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.structNullableArg(() => {}));
+}, "structref casts");
+
+test(() => {
+  exports.arrayArg(exports.makeArray());
+  assert_throws_js(TypeError, () => exports.arrayArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.arrayArg(42));
+  assert_throws_js(TypeError, () => exports.arrayArg(42n));
+  assert_throws_js(TypeError, () => exports.arrayArg("foo"));
+  assert_throws_js(TypeError, () => exports.arrayArg({}));
+  assert_throws_js(TypeError, () => exports.arrayArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.arrayArg(() => {}));
+  assert_throws_js(TypeError, () => exports.arrayArg(null));
+
+  exports.arrayNullableArg(null);
+  exports.arrayNullableArg(exports.makeArray());
+  assert_throws_js(TypeError, () => exports.arrayNullableArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg(42));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg({}));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.arrayNullableArg(() => {}));
+}, "arrayref casts");
+
+test(() => {
+  exports.i31Arg(42);
+  assert_throws_js(TypeError, () => exports.i31Arg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.i31Arg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.i31Arg(42n));
+  assert_throws_js(TypeError, () => exports.i31Arg("foo"));
+  assert_throws_js(TypeError, () => exports.i31Arg({}));
+  assert_throws_js(TypeError, () => exports.i31Arg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.i31Arg(() => {}));
+  assert_throws_js(TypeError, () => exports.i31Arg(null));
+
+  exports.i31NullableArg(null);
+  exports.i31NullableArg(42);
+  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.i31NullableArg(42n));
+  assert_throws_js(TypeError, () => exports.i31NullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.i31NullableArg({}));
+  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.i31NullableArg(() => {}));
+}, "i31ref casts");
+
+test(() => {
+  exports.funcArg(exports.testFunc);
+  assert_throws_js(TypeError, () => exports.funcArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.funcArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.funcArg(42));
+  assert_throws_js(TypeError, () => exports.funcArg(42n));
+  assert_throws_js(TypeError, () => exports.funcArg("foo"));
+  assert_throws_js(TypeError, () => exports.funcArg({}));
+  assert_throws_js(TypeError, () => exports.funcArg(() => {}));
+  assert_throws_js(TypeError, () => exports.funcArg(null));
+
+  exports.funcNullableArg(null);
+  exports.funcNullableArg(exports.testFunc);
+  assert_throws_js(TypeError, () => exports.funcNullableArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.funcNullableArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.funcNullableArg(42));
+  assert_throws_js(TypeError, () => exports.funcNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.funcNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.funcNullableArg({}));
+  assert_throws_js(TypeError, () => exports.funcNullableArg(() => {}));
+}, "funcref casts");
+
+test(() => {
+  exports.externArg(exports.makeArray());
+  exports.externArg(exports.makeStruct());
+  exports.externArg(42);
+  exports.externArg(42n);
+  exports.externArg("foo");
+  exports.externArg({});
+  exports.externArg(exports.testFunc);
+  exports.externArg(() => {});
+  assert_throws_js(TypeError, () => exports.externArg(null));
+
+  exports.externNullableArg(null);
+  exports.externNullableArg(exports.makeArray());
+  exports.externNullableArg(exports.makeStruct());
+  exports.externNullableArg(42);
+  exports.externNullableArg(42n);
+  exports.externNullableArg("foo");
+  exports.externNullableArg({});
+  exports.externNullableArg(exports.testFunc);
+  exports.externNullableArg(() => {});
+}, "externref casts");
+
+test(() => {
+  for (const nullfunc of [exports.noneArg, exports.nofuncArg, exports.noexternArg]) {
+    assert_throws_js(TypeError, () => nullfunc(exports.makeStruct()));
+    assert_throws_js(TypeError, () => nullfunc(exports.makeArray()));
+    assert_throws_js(TypeError, () => nullfunc(42));
+    assert_throws_js(TypeError, () => nullfunc(42n));
+    assert_throws_js(TypeError, () => nullfunc("foo"));
+    assert_throws_js(TypeError, () => nullfunc({}));
+    assert_throws_js(TypeError, () => nullfunc(exports.testFunc));
+    assert_throws_js(TypeError, () => nullfunc(() => {}));
+    assert_throws_js(TypeError, () => nullfunc(null));
+  }
+
+  for (const nullfunc of [exports.noneNullableArg, exports.nofuncNullableArg, exports.noexternNullableArg]) {
+    nullfunc(null);
+    assert_throws_js(TypeError, () => nullfunc(exports.makeStruct()));
+    assert_throws_js(TypeError, () => nullfunc(exports.makeArray()));
+    assert_throws_js(TypeError, () => nullfunc(42));
+    assert_throws_js(TypeError, () => nullfunc(42n));
+    assert_throws_js(TypeError, () => nullfunc("foo"));
+    assert_throws_js(TypeError, () => nullfunc({}));
+    assert_throws_js(TypeError, () => nullfunc(exports.testFunc));
+    assert_throws_js(TypeError, () => nullfunc(() => {}));
+  }
+}, "null casts");
+
+test(() => {
+  exports.concreteStructArg(exports.makeStruct());
+  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.makeStruct2()));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(42));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteStructArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteStructArg({}));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(() => {}));
+  assert_throws_js(TypeError, () => exports.concreteStructArg(null));
+
+  exports.concreteStructNullableArg(null);
+  exports.concreteStructNullableArg(exports.makeStruct());
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.makeStruct2()));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(42));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg({}));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(() => {}));
+}, "concrete struct casts");
+
+test(() => {
+  exports.concreteArrayArg(exports.makeArray());
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.makeArray2()));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(42));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg({}));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(() => {}));
+  assert_throws_js(TypeError, () => exports.concreteArrayArg(null));
+
+  exports.concreteArrayNullableArg(null);
+  exports.concreteArrayNullableArg(exports.makeArray());
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.makeArray2()));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(42));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg({}));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.testFunc));
+  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(() => {}));
+}, "concrete array casts");
+
+test(() => {
+  exports.concreteFuncArg(exports.testFunc);
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.testFunc2));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(42));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg({}));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(() => {}));
+  assert_throws_js(TypeError, () => exports.concreteFuncArg(null));
+
+  exports.concreteFuncNullableArg(null);
+  exports.concreteFuncNullableArg(exports.testFunc);
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.testFunc2));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.makeArray()));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.makeStruct()));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(42));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(42n));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg("foo"));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg({}));
+  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(() => {}));
+}, "concrete func casts");
diff --git a/testing/web-platform/tests/wasm/jsapi/gc/exported-object.tentative.any.js b/testing/web-platform/tests/wasm/jsapi/gc/exported-object.tentative.any.js
new file mode 100644
index 0000000000..b572f14006
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/gc/exported-object.tentative.any.js
@@ -0,0 +1,190 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let functions = {};
+setup(() => {
+  const builder = new WasmModuleBuilder();
+
+  const structIndex = builder.addStruct([makeField(kWasmI32, true)]);
+  const arrayIndex = builder.addArray(kWasmI32, true);
+  const structRef = wasmRefType(structIndex);
+  const arrayRef = wasmRefType(arrayIndex);
+
+  builder
+    .addFunction("makeStruct", makeSig_r_v(structRef))
+    .addBody([...wasmI32Const(42),
+              ...GCInstr(kExprStructNew), structIndex])
+    .exportFunc();
+
+  builder
+    .addFunction("makeArray", makeSig_r_v(arrayRef))
+    .addBody([...wasmI32Const(5), ...wasmI32Const(42),
+              ...GCInstr(kExprArrayNew), arrayIndex])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+  const module = new WebAssembly.Module(buffer);
+  const instance = new WebAssembly.Instance(module, {});
+  functions = instance.exports;
+});
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_equals(struct.foo, undefined);
+  assert_equals(struct[0], undefined);
+  assert_equals(array.foo, undefined);
+  assert_equals(array[0], undefined);
+}, "property access");
+
+test(() => {
+  "use strict";
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => { struct.foo = 5; });
+  assert_throws_js(TypeError, () => { array.foo = 5; });
+  assert_throws_js(TypeError, () => { struct[0] = 5; });
+  assert_throws_js(TypeError, () => { array[0] = 5; });
+}, "property assignment (strict mode)");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => { struct.foo = 5; });
+  assert_throws_js(TypeError, () => { array.foo = 5; });
+  assert_throws_js(TypeError, () => { struct[0] = 5; });
+  assert_throws_js(TypeError, () => { array[0] = 5; });
+}, "property assignment (non-strict mode)");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_equals(Object.getOwnPropertyNames(struct).length, 0);
+  assert_equals(Object.getOwnPropertyNames(array).length, 0);
+}, "ownPropertyNames");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => Object.defineProperty(struct, "foo", { value: 1 }));
+  assert_throws_js(TypeError, () => Object.defineProperty(array, "foo", { value: 1 }));
+}, "defineProperty");
+
+test(() => {
+  "use strict";
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => delete struct.foo);
+  assert_throws_js(TypeError, () => delete struct[0]);
+  assert_throws_js(TypeError, () => delete array.foo);
+  assert_throws_js(TypeError, () => delete array[0]);
+}, "delete (strict mode)");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => delete struct.foo);
+  assert_throws_js(TypeError, () => delete struct[0]);
+  assert_throws_js(TypeError, () => delete array.foo);
+  assert_throws_js(TypeError, () => delete array[0]);
+}, "delete (non-strict mode)");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_equals(Object.getPrototypeOf(struct), null);
+  assert_equals(Object.getPrototypeOf(array), null);
+}, "getPrototypeOf");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => Object.setPrototypeOf(struct, {}));
+  assert_throws_js(TypeError, () => Object.setPrototypeOf(array, {}));
+}, "setPrototypeOf");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_false(Object.isExtensible(struct));
+  assert_false(Object.isExtensible(array));
+}, "isExtensible");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => Object.preventExtensions(struct));
+  assert_throws_js(TypeError, () => Object.preventExtensions(array));
+}, "preventExtensions");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => Object.seal(struct));
+  assert_throws_js(TypeError, () => Object.seal(array));
+}, "sealing");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_equals(typeof struct, "object");
+  assert_equals(typeof array, "object");
+}, "typeof");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => struct.toString());
+  assert_equals(Object.prototype.toString.call(struct), "[object Object]");
+  assert_throws_js(TypeError, () => array.toString());
+  assert_equals(Object.prototype.toString.call(array), "[object Object]");
+}, "toString");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  assert_throws_js(TypeError, () => struct.valueOf());
+  assert_equals(Object.prototype.valueOf.call(struct), struct);
+  assert_throws_js(TypeError, () => array.valueOf());
+  assert_equals(Object.prototype.valueOf.call(array), array);
+}, "valueOf");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  const map = new Map();
+  map.set(struct, "struct");
+  map.set(array, "array");
+  assert_equals(map.get(struct), "struct");
+  assert_equals(map.get(array), "array");
+}, "GC objects as map keys");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  const set = new Set();
+  set.add(struct);
+  set.add(array);
+  assert_true(set.has(struct));
+  assert_true(set.has(array));
+}, "GC objects as set element");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  const map = new WeakMap();
+  map.set(struct, "struct");
+  map.set(array, "array");
+  assert_equals(map.get(struct), "struct");
+  assert_equals(map.get(array), "array");
+}, "GC objects as weak map keys");
+
+test(() => {
+  const struct = functions.makeStruct();
+  const array = functions.makeArray();
+  const set = new WeakSet();
+  set.add(struct);
+  set.add(array);
+  assert_true(set.has(struct));
+  assert_true(set.has(array));
+}, "GC objects as weak set element");
diff --git a/testing/web-platform/tests/wasm/jsapi/gc/i31.tentative.any.js b/testing/web-platform/tests/wasm/jsapi/gc/i31.tentative.any.js
new file mode 100644
index 0000000000..17fd82440c
--- /dev/null
+++ b/testing/web-platform/tests/wasm/jsapi/gc/i31.tentative.any.js
@@ -0,0 +1,98 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let exports = {};
+setup(() => {
+  const builder = new WasmModuleBuilder();
+  const i31Ref = wasmRefType(kWasmI31Ref);
+  const i31NullableRef = wasmRefNullType(kWasmI31Ref);
+  const anyRef = wasmRefType(kWasmAnyRef);
+
+  builder
+    .addFunction("makeI31", makeSig_r_x(i31Ref, kWasmI32))
+    .addBody([kExprLocalGet, 0,
+              ...GCInstr(kExprI31New)])
+    .exportFunc();
+
+  builder
+    .addFunction("castI31", makeSig_r_x(kWasmI32, anyRef))
+    .addBody([kExprLocalGet, 0,
+              ...GCInstr(kExprRefCast), kI31RefCode,
+              ...GCInstr(kExprI31GetU)])
+    .exportFunc();
+
+  builder
+    .addFunction("getI31", makeSig_r_x(kWasmI32, i31Ref))
+    .addBody([kExprLocalGet, 0,
+              ...GCInstr(kExprI31GetS)])
+    .exportFunc();
+
+  builder
+    .addFunction("argI31", makeSig_v_x(i31NullableRef))
+    .addBody([])
+    .exportFunc();
+
+  builder
+    .addGlobal(i31NullableRef, true, [...wasmI32Const(0), ...GCInstr(kExprI31New)])
+  builder
+    .addExportOfKind("i31Global", kExternalGlobal, 0);
+
+  builder
+    .addTable(i31NullableRef, 10)
+  builder
+    .addExportOfKind("i31Table", kExternalTable, 0);
+
+  const buffer = builder.toBuffer();
+  const module = new WebAssembly.Module(buffer);
+  const instance = new WebAssembly.Instance(module, {});
+  exports = instance.exports;
+});
+
+test(() => {
+  assert_equals(exports.makeI31(42), 42);
+  assert_equals(exports.makeI31(2 ** 30 - 1), 2 ** 30 - 1);
+  assert_equals(exports.makeI31(2 ** 30), -(2 ** 30));
+  assert_equals(exports.makeI31(-(2 ** 30)), -(2 ** 30));
+  assert_equals(exports.makeI31(2 ** 31 - 1), -1);
+  assert_equals(exports.makeI31(2 ** 31), 0);
+}, "i31ref conversion to Number");
+
+test(() => {
+  assert_equals(exports.getI31(exports.makeI31(42)), 42);
+  assert_equals(exports.getI31(42), 42);
+  assert_equals(exports.getI31(2.0 ** 30 - 1), 2 ** 30 - 1);
+  assert_equals(exports.getI31(-(2 ** 30)), -(2 ** 30));
+}, "Number conversion to i31ref");
+
+test(() => {
+  exports.argI31(null);
+  assert_throws_js(TypeError, () => exports.argI31(2 ** 30));
+  assert_throws_js(TypeError, () => exports.argI31(-(2 ** 30) - 1));
+  assert_throws_js(TypeError, () => exports.argI31(2n));
+  assert_throws_js(TypeError, () => exports.argI31(() => 3));
+  assert_throws_js(TypeError, () => exports.argI31(exports.getI31));
+}, "Check i31ref argument type");
+
+test(() => {
+  assert_equals(exports.castI31(42), 42);
+  assert_equals(exports.castI31(2 ** 30 - 1), 2 ** 30 - 1);
+  assert_throws_js(WebAssembly.RuntimeError, () => { exports.castI31(2 ** 30); });
+  assert_throws_js(WebAssembly.RuntimeError, () => { exports.castI31(-(2 ** 30) - 1); });
+  assert_throws_js(WebAssembly.RuntimeError, () => { exports.castI31(2 ** 32); });
+}, "Numbers in i31 range are i31ref, not hostref");
+
+test(() => {
+  assert_equals(exports.i31Global.value, 0);
+  exports.i31Global.value = 42;
+  assert_throws_js(TypeError, () => exports.i31Global.value = 2 ** 30);
+  assert_throws_js(TypeError, () => exports.i31Global.value = -(2 ** 30) - 1);
+  assert_equals(exports.i31Global.value, 42);
+}, "i31ref global");
+
+test(() => {
+  assert_equals(exports.i31Table.get(0), null);
+  exports.i31Table.set(0, 42);
+  assert_throws_js(TypeError, () => exports.i31Table.set(0, 2 ** 30));
+  assert_throws_js(TypeError, () => exports.i31Table.set(0, -(2 ** 30) - 1));
+  assert_equals(exports.i31Table.get(0), 42);
+}, "i31ref table");