Update web-platform-tests to revision 36634cbcf3253dfe8d220990a27ad4eeebf8ec2f

tests/wpt/web-platform-tests/wasm/jsapi/constructor/compile.any.js

@@ -68,6 +68,10 @@ promise_test(() => {
   return WebAssembly.compile(emptyModuleBinary).then(assert_Module);
 }, "Result type");
 
+promise_test(() => {
+  return WebAssembly.compile(emptyModuleBinary, {}).then(assert_Module);
+}, "Stray argument");
+
 promise_test(() => {
   const buffer = new WasmModuleBuilder().toBuffer();
   assert_equals(buffer[0], 0);

tests/wpt/web-platform-tests/wasm/jsapi/constructor/validate.any.js

@@ -94,3 +94,7 @@ for (const [module, expected] of modules) {
     }
   }
 }
+
+test(() => {
+  assert_true(WebAssembly.validate(emptyModuleBinary, {}));
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/global/constructor.any.js

@@ -119,3 +119,9 @@ for (const type of ["i32", "f32", "f64"]) {
     }, `Explicit value ${name} for type ${type}`);
   }
 }
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument, 0, {});
+  assert_Global(global, 0);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/global/value-get-set.any.js

@@ -92,3 +92,20 @@ test(() => {
 
   assert_throws(new 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");

tests/wpt/web-platform-tests/wasm/jsapi/global/valueOf.any.js

@@ -20,3 +20,9 @@ test(() => {
     assert_throws(new 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");

tests/wpt/web-platform-tests/wasm/jsapi/instance/exports.any.js

@@ -33,6 +33,20 @@ test(() => {
   }
 }, "Branding");
 
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const instance = new WebAssembly.Instance(module);
+  const exports = instance.exports;
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Instance.prototype, "exports");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(instance, {}), exports);
+}, "Stray argument");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const instance = new WebAssembly.Instance(module);

tests/wpt/web-platform-tests/wasm/jsapi/instanceTestFactory.js

@@ -214,4 +214,16 @@ const instanceTestFactory = [
       };
     }
   ],
+
+  [
+    "stray argument",
+    function() {
+      return {
+        buffer: emptyModuleBinary,
+        args: [{}, {}],
+        exports: {},
+        verify: () => {}
+      };
+    }
+  ],
 ];

tests/wpt/web-platform-tests/wasm/jsapi/memory/buffer.any.js

@@ -26,6 +26,20 @@ test(() => {
   }
 }, "Branding");
 
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const buffer = memory.buffer;
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Memory.prototype, "buffer");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(memory, {}), buffer);
+}, "Stray argument");
+
 test(() => {
   const argument = { "initial": 0 };
   const memory = new WebAssembly.Memory(argument);

tests/wpt/web-platform-tests/wasm/jsapi/memory/constructor.any.js

@@ -139,3 +139,9 @@ test(() => {
   const memory = new WebAssembly.Memory(argument);
   assert_Memory(memory, { "size": 4 });
 }, "Non-zero initial");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument, {});
+  assert_Memory(memory, { "size": 0 });
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/memory/grow.any.js

@@ -168,3 +168,18 @@ for (const value of outOfRangeValues) {
     assert_throws(new TypeError(), () => memory.grow(value));
   }, `Out-of-range argument: ${format_value(value)}`);
 }
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2, {});
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/module/constructor.any.js

@@ -58,3 +58,8 @@ test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   assert_true(Object.isExtensible(module));
 }, "Extensibility");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary, {});
+  assert_equals(Object.getPrototypeOf(module), WebAssembly.Module.prototype);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/module/customSections.any.js

@@ -160,3 +160,8 @@ test(() => {
     bytes,
   ]);
 }, "Custom sections with U+FFFD");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_sections(WebAssembly.Module.customSections(module, "", {}), []);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/module/exports.any.js

@@ -128,3 +128,9 @@ test(() => {
   ];
   assert_exports(exports, expected);
 }, "exports");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const exports = WebAssembly.Module.exports(module, {});
+  assert_exports(exports, []);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/module/imports.any.js

@@ -118,3 +118,9 @@ test(() => {
   ];
   assert_imports(imports, expected);
 }, "imports");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const imports = WebAssembly.Module.imports(module, {});
+  assert_imports(imports, []);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/table/constructor.any.js

@@ -96,6 +96,12 @@ test(() => {
   assert_Table(table, { "length": 5 });
 }, "Basic (non-zero)");
 
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 0 };
+  const table = new WebAssembly.Table(argument, {});
+  assert_Table(table, { "length": 0 });
+}, "Stray argument");
+
 test(() => {
   const proxy = new Proxy({}, {
     has(o, x) {

tests/wpt/web-platform-tests/wasm/jsapi/table/get-set.any.js

@@ -220,3 +220,11 @@ test(() => {
   assert_equals(called, 1);
 }, "Order of argument conversion");
 
+test(() => {
+  const {fn} = functions;
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+
+  assert_equals(table.get(0, {}), null);
+  assert_equals(table.set(0, fn, {}), undefined);
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/table/grow.any.js

@@ -84,3 +84,13 @@ for (const value of outOfRangeValues) {
     assert_throws(new TypeError(), () => table.grow(value));
   }, `Out-of-range argument: ${format_value(value)}`);
 }
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, nulls(5), "before");
+
+  const result = table.grow(3, {});
+  assert_equals(result, 5);
+  assert_equal_to_array(table, nulls(8), "after");
+}, "Stray argument");

tests/wpt/web-platform-tests/wasm/jsapi/table/length.any.js

@@ -26,6 +26,20 @@ test(() => {
   }
 }, "Branding");
 
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 2 };
+  const table = new WebAssembly.Table(argument);
+  assert_equals(table.length, 2, "Initial length");
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Table.prototype, "length");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(table, {}), 2);
+}, "Stray argument");
+
 test(() => {
   const argument = { "element": "anyfunc", "initial": 2 };
   const table = new WebAssembly.Table(argument);