[wpt][webassembly][jspi] Add WPT tests for JSPI

Adding JavaScript Promise Integration tests from spec repo to WPT

BYPASS_LARGE_CHANGE_WARNING

Bug: 42202153
Change-Id: Ic691c83df8861456de69ab01fd048bf0c4472967
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5922662
Reviewed-by: Shu-yu Guo <[email protected]>
Commit-Queue: Francis McCabe <[email protected]>
Reviewed-by: Andreas Haas <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1370246}

Author: fgmccabe

wasm/jsapi/jspi/README.txt

@@ -0,0 +1,3 @@
+This suite tests JSPI.
+
+The tests are based on wasm spec tests.

wasm/jsapi/jspi/js-promise-integration.any.js

@@ -0,0 +1,372 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+// Test for invalid wrappers
+test(() => {
+  assert_throws_js(TypeError, () => WebAssembly.promising({}),
+      "Argument 0 must be a function");
+  assert_throws_js(TypeError, () => WebAssembly.promising(() => {}),
+      "Argument 0 must be a WebAssembly exported function");
+  assert_throws_js(TypeError, () => WebAssembly.Suspending(() => {}),
+      "WebAssembly.Suspending must be invoked with 'new'");
+  assert_throws_js(TypeError, () => new WebAssembly.Suspending({}),
+      "Argument 0 must be a function");
+
+  function asmModule() {
+      "use asm";
+
+      function x(v) {
+          v = v | 0;
+      }
+      return x;
+  }
+  assert_throws_js(TypeError, () => WebAssembly.promising(asmModule()),
+      "Argument 0 must be a WebAssembly exported function");
+},"Valid use of API");
+
+test(() => {
+  let builder = new WasmModuleBuilder();
+  builder.addGlobal(kWasmI32, true).exportAs('g');
+  builder.addFunction("test", kSig_i_v)
+      .addBody([
+          kExprI32Const, 42,
+          kExprGlobalSet, 0,
+          kExprI32Const, 0
+      ]).exportFunc();
+  let instance = builder.instantiate();
+  let wrapper = WebAssembly.promising(instance.exports.test);
+  wrapper();
+  assert_equals(42, instance.exports.g.value);
+},"Promising function always entered");
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  let import_index = builder.addImport('m', 'import', kSig_i_v);
+  builder.addFunction("test", kSig_i_i)
+      .addBody([
+          kExprCallFunction, import_index, // suspend
+      ]).exportFunc();
+  let js_import = () => 42;
+  let instance = builder.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+  let export_promise = wrapped_export();
+  assert_true(export_promise instanceof Promise);
+  assert_equals(await export_promise, 42);
+}, "Always get a Promise");
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  let import_index = builder.addImport('m', 'import', kSig_i_i);
+  builder.addFunction("test", kSig_i_i)
+      .addBody([
+          kExprLocalGet, 0,
+          kExprCallFunction, import_index, // suspend
+      ]).exportFunc();
+  let js_import = new WebAssembly.Suspending(() => Promise.resolve(42));
+  let instance = builder.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+  let export_promise = wrapped_export();
+  assert_true(export_promise instanceof Promise);
+  assert_equals(await export_promise, 42);
+}, "Suspend once");
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  builder.addGlobal(kWasmI32, true).exportAs('g');
+  let import_index = builder.addImport('m', 'import', kSig_i_v);
+  // void test() {
+  //   for (i = 0; i < 5; ++i) {
+  //     g = g + await import();
+  //   }
+  // }
+  builder.addFunction("test", kSig_v_i)
+      .addLocals({
+          i32_count: 1
+      })
+      .addBody([
+          kExprI32Const, 5,
+          kExprLocalSet, 1,
+          kExprLoop, kWasmStmt,
+          kExprCallFunction, import_index, // suspend
+          kExprGlobalGet, 0,
+          kExprI32Add,
+          kExprGlobalSet, 0,
+          kExprLocalGet, 1,
+          kExprI32Const, 1,
+          kExprI32Sub,
+          kExprLocalTee, 1,
+          kExprBrIf, 0,
+          kExprEnd,
+      ]).exportFunc();
+  let i = 0;
+
+  function js_import() {
+      return Promise.resolve(++i);
+  };
+  let wasm_js_import = new WebAssembly.Suspending(js_import);
+  let instance = builder.instantiate({
+      m: {
+          import: wasm_js_import
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+  let export_promise = wrapped_export();
+  assert_equals(instance.exports.g.value, 0);
+  assert_true(export_promise instanceof Promise);
+  await export_promise;
+  assert_equals(instance.exports.g.value, 15);
+}, "Suspend/resume in a loop");
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  let import_index = builder.addImport('m', 'import', kSig_i_v);
+  builder.addFunction("test", kSig_i_v)
+      .addBody([
+          kExprCallFunction, import_index, // suspend
+      ]).exportFunc();
+  let js_import = new WebAssembly.Suspending(() => Promise.resolve(42));
+  let instance = builder.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+  assert_equals(await wrapped_export(), 42);
+
+  // Also try with a JS function with a mismatching arity.
+  js_import = new WebAssembly.Suspending((unused) => Promise.resolve(42));
+  instance = builder.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  wrapped_export = WebAssembly.promising(instance.exports.test);
+  assert_equals(await wrapped_export(), 42);
+
+  // Also try with a proxy.
+  js_import = new WebAssembly.Suspending(new Proxy(() => Promise.resolve(42), {}));
+  instance = builder.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  wrapped_export = WebAssembly.promising(instance.exports.test);
+  assert_equals(await wrapped_export(), 42);
+},"Suspending with mismatched args and via Proxy");
+
+function recordAbeforeB() {
+  let AbeforeB = [];
+  let setA = () => {
+      AbeforeB.push("A")
+  }
+  let setB = () => {
+      AbeforeB.push("B")
+  }
+  let isAbeforeB = () =>
+      AbeforeB[0] == "A" && AbeforeB[1] == "B";
+
+  let isBbeforeA = () =>
+    AbeforeB[0] == "B" && AbeforeB[1] == "A";
+
+  return {
+      setA: setA,
+      setB: setB,
+      isAbeforeB: isAbeforeB,
+      isBbeforeA: isBbeforeA,
+  }
+}
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  let AbeforeB = recordAbeforeB();
+  let import42_index = builder.addImport('m', 'import42', kSig_i_i);
+  let importSetA_index = builder.addImport('m', 'setA', kSig_v_v);
+  builder.addFunction("test", kSig_i_i)
+      .addBody([
+          kExprLocalGet, 0,
+          kExprCallFunction, import42_index, // suspend?
+          kExprCallFunction, importSetA_index
+      ]).exportFunc();
+  let import42 = new WebAssembly.Suspending(() => Promise.resolve(42));
+  let instance = builder.instantiate({
+      m: {
+          import42: import42,
+          setA: AbeforeB.setA
+      }
+  });
+
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+
+  let exported_promise = wrapped_export();
+
+  AbeforeB.setB();
+
+  assert_equals(await exported_promise, 42);
+
+  assert_true(AbeforeB.isBbeforeA());
+}, "Make sure we actually suspend");
+
+promise_test(async () => {
+  let builder = new WasmModuleBuilder();
+  let AbeforeB = recordAbeforeB();
+  let import42_index = builder.addImport('m', 'import42', kSig_i_i);
+  let importSetA_index = builder.addImport('m', 'setA', kSig_v_v);
+  builder.addFunction("test", kSig_i_i)
+      .addBody([
+          kExprLocalGet, 0,
+          kExprCallFunction, import42_index, // suspend?
+          kExprCallFunction, importSetA_index
+      ]).exportFunc();
+  let import42 = new WebAssembly.Suspending(() => 42);
+  let instance = builder.instantiate({
+      m: {
+          import42: import42,
+          setA: AbeforeB.setA
+      }
+  });
+
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+
+  let exported_promise = wrapped_export();
+  AbeforeB.setB();
+  assert_true(AbeforeB.isAbeforeB());
+
+  assert_equals(await exported_promise, 42);
+}, "Do not suspend if the import's return value is not a Promise");
+
+promise_test(async (t) => {
+  let tag = new WebAssembly.Tag({
+      parameters: ['i32']
+  });
+  let builder = new WasmModuleBuilder();
+  let import_index = builder.addImport('m', 'import', kSig_i_i);
+  let tag_index = builder.addImportedTag('m', 'tag', kSig_v_i);
+  builder.addFunction("test", kSig_i_i)
+      .addBody([
+          kExprTry, kWasmI32,
+          kExprLocalGet, 0,
+          kExprCallFunction, import_index,
+          kExprCatch, tag_index,
+          kExprEnd
+      ]).exportFunc();
+
+  function js_import(unused) {
+      return Promise.reject(new WebAssembly.Exception(tag, [42]));
+  };
+  let wasm_js_import = new WebAssembly.Suspending(js_import);
+
+  let instance = builder.instantiate({
+      m: {
+          import: wasm_js_import,
+          tag: tag
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance.exports.test);
+  let export_promise = wrapped_export();
+  assert_true(export_promise instanceof Promise);
+  assert_equals(await export_promise, 42);
+}, "Catch rejected promise");
+
+async function TestSandwich(suspend) {
+  // Set up a 'sandwich' scenario. The call chain looks like:
+  // top (wasm) -> outer (js) -> bottom (wasm) -> inner (js)
+  // If 'suspend' is true, the inner JS function returns a Promise, which
+  // suspends the bottom wasm function, which returns a Promise, which suspends
+  // the top wasm function, which returns a Promise. The inner Promise
+  // resolves first, which resumes the bottom continuation. Then the outer
+  // promise resolves which resumes the top continuation.
+  // If 'suspend' is false, the bottom JS function returns a regular value and
+  // no computation is suspended.
+  let builder = new WasmModuleBuilder();
+  let inner_index = builder.addImport('m', 'inner', kSig_i_i);
+  let outer_index = builder.addImport('m', 'outer', kSig_i_i);
+  builder.addFunction("top", kSig_i_i)
+      .addBody([
+          kExprLocalGet, 0,
+          kExprCallFunction, outer_index
+      ]).exportFunc();
+  builder.addFunction("bottom", kSig_i_i)
+      .addBody([
+          kExprLocalGet, 0,
+          kExprCallFunction, inner_index
+      ]).exportFunc();
+
+  let inner = new WebAssembly.Suspending(() => suspend ? Promise.resolve(42) : 43);
+
+  let export_inner;
+  let outer = new WebAssembly.Suspending(() => export_inner());
+
+  let instance = builder.instantiate({
+      m: {
+          inner,
+          outer
+      }
+  });
+  export_inner = WebAssembly.promising(instance.exports.bottom);
+  let export_top = WebAssembly.promising(instance.exports.top);
+  let result = export_top();
+  assert_true(result instanceof Promise);
+  if (suspend)
+      assert_equals(await result, 42);
+  else
+      assert_equals(await result, 43);
+}
+
+promise_test(async () => {
+  TestSandwich(true);
+}, "Test sandwich with suspension");
+
+promise_test(async () => {
+  TestSandwich(false);
+}, "Test sandwich with no suspension");
+
+test(() => {
+  // Check that a promising function with no return is allowed.
+  let builder = new WasmModuleBuilder();
+  builder.addFunction("export", kSig_v_v).addBody([]).exportFunc();
+  let instance = builder.instantiate();
+  let export_wrapper = WebAssembly.promising(instance.exports.export);
+  let export_sig = export_wrapper.type();
+  assert_array_equals(export_sig.parameters, []);
+  assert_array_equals(export_sig.results, ['externref']);
+},"Promising with no return");
+
+promise_test(async () => {
+  let builder1 = new WasmModuleBuilder();
+  let import_index = builder1.addImport('m', 'import', kSig_i_v);
+  builder1.addFunction("f", kSig_i_v)
+      .addBody([
+          kExprCallFunction, import_index, // suspend
+          kExprI32Const, 1,
+          kExprI32Add,
+      ]).exportFunc();
+  let js_import = new WebAssembly.Suspending(() => Promise.resolve(1));
+  let instance1 = builder1.instantiate({
+      m: {
+          import: js_import
+      }
+  });
+  let builder2 = new WasmModuleBuilder();
+  import_index = builder2.addImport('m', 'import', kSig_i_v);
+  builder2.addFunction("main", kSig_i_v)
+      .addBody([
+          kExprCallFunction, import_index,
+          kExprI32Const, 1,
+          kExprI32Add,
+      ]).exportFunc();
+  let instance2 = builder2.instantiate({
+      m: {
+          import: instance1.exports.f
+      }
+  });
+  let wrapped_export = WebAssembly.promising(instance2.exports.main);
+  assert_equals(await wrapped_export(), 3);
+},"Suspend two modules");