Add JS-API tests for exception handling proposal

Author: takikawa

test/js-api/exception/constructor.any.js

@@ -0,0 +1,47 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+test(() => {
+  assert_function_name(WebAssembly.Exception, "Exception", "WebAssembly.Exception");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Exception, 1, "WebAssembly.Exception");
+}, "length");
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.Exception());
+}, "No arguments");
+
+test(() => {
+  const argument = { "parameters": [] };
+  assert_throws_js(TypeError, () => WebAssembly.Exception(argument));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws_js(TypeError,
+                     () => new WebAssembly.Exception(invalidArgument),
+                     `new Exception(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const invalidTypes = ["i16", "i128", "f16", "f128", "u32", "u64", "i32\0"];
+  for (const value of invalidTypes) {
+    const argument = { parameters: [value] };
+    assert_throws_js(TypeError, () => new WebAssembly.Exception(argument));
+  }
+}, "Invalid type parameter");

test/js-api/exception/toString.any.js

@@ -0,0 +1,17 @@
+// META: global=window,dedicatedworker,jsshell
+
+test(() => {
+  const argument = { "parameters": [] };
+  const exception = new WebAssembly.Exception(argument);
+  assert_class_string(exception, "WebAssembly.Exception");
+}, "Object.prototype.toString on an Exception");
+
+test(() => {
+  assert_own_property(WebAssembly.Exception.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(WebAssembly.Exception.prototype, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WebAssembly.Exception", "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");

test/js-api/exception/type.tentative.any.js

@@ -0,0 +1,21 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_type(argument) {
+    const exception = new WebAssembly.Exception(argument);
+    const exceptiontype = exception.type();
+
+    assert_array_equals(exceptiontype.parameters, argument.parameters);
+}
+
+test(() => {
+    assert_type({ "parameters": [] });
+}, "[]");
+
+test(() => {
+    assert_type({ "parameters": ["i32", "i64"] });
+}, "[i32 i64]");
+
+test(() => {
+    assert_type({ "parameters": ["i32", "i64", "f32", "f64"] });
+}, "[i32 i64 f32 f64]");

test/js-api/runtimeexception/constructor.any.js

@@ -0,0 +1,47 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+test(() => {
+  assert_function_name(WebAssembly.RuntimeException, "RuntimeException", "WebAssembly.RuntimeException");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.RuntimeException, 1, "WebAssembly.RuntimeException");
+}, "length");
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.RuntimeException());
+}, "No arguments");
+
+test(() => {
+  const argument = new WebAssembly.Exception({ parameters: [] });
+  assert_throws_js(TypeError, () => WebAssembly.RuntimeException(argument));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws_js(TypeError,
+                     () => new WebAssembly.RuntimeException(invalidArgument),
+                     `new RuntimeException(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const typesAndArgs = [["i32", 123n], ["i32", Symbol()], ["f32", 123n], ["f64", 123n], ["i64", undefined]];
+  for (const typeAndArg of typesAndArgs) {
+    const exn = new WebAssembly.Exception({ parameters: [typeAndArg[0]] });
+    assert_throws_js(TypeError, () => new WebAssembly.RuntimeException(exn, typeAndArg[1]));
+  }
+}, "Invalid exception argument");

test/js-api/runtimeexception/getArg.any.js

@@ -0,0 +1,58 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/memory/assertions.js
+
+test(() => {
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  assert_throws_js(TypeError, () => runtimeExn.getArg());
+  assert_throws_js(TypeError, () => runtimeExn.getArg(exn));
+}, "Missing arguments");
+
+test(() => {
+  const invalidValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {}
+  ];
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  for (argument of invalidValues) {
+    assert_throws_js(TypeError, () => runtimeExn.getArg(argument, 0));
+  }
+}, "Invalid exception argument");
+
+test(() => {
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  assert_throws_js(RangeError, () => runtimeExn.getArg(exn, 1));
+}, "Index out of bounds");
+
+test(() => {
+  const outOfRangeValues = [
+    undefined,
+    NaN,
+    Infinity,
+    -Infinity,
+    -1,
+    0x100000000,
+    0x1000000000,
+    "0x100000000",
+    { valueOf() { return 0x100000000; } },
+  ];
+
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  for (const value of outOfRangeValues) {
+    assert_throws_js(TypeError, () => runtimeExn.getArg(exn, value));
+  }
+}, "Getting out-of-range argument");
+
+test(() => {
+  const exn = new WebAssembly.Exception({ "parameters": ["i32"] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn, 42);
+  assert_equals(runtimeExn.getArg(exn, 0), 42);
+}, "getArg");

test/js-api/runtimeexception/is.any.js

@@ -0,0 +1,33 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/memory/assertions.js
+
+test(() => {
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  assert_throws_js(TypeError, () => runtimeExn.is());
+}, "Missing arguments");
+
+test(() => {
+  const invalidValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {}
+  ];
+  const exn = new WebAssembly.Exception({ "parameters": [] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn);
+  for (argument of invalidValues) {
+    assert_throws_js(TypeError, () => runtimeExn.is(argument));
+  }
+}, "Invalid exception argument");
+
+test(() => {
+  const exn1 = new WebAssembly.Exception({ "parameters": ["i32"] })
+  const exn2 = new WebAssembly.Exception({ "parameters": ["i32"] })
+  const runtimeExn = new WebAssembly.RuntimeException(exn1, 42);
+  assert_true(runtimeExn.is(exn1));
+  assert_false(runtimeExn.is(exn2));
+}, "is");

test/js-api/runtimeexception/toString.any.js

@@ -0,0 +1,18 @@
+// META: global=window,dedicatedworker,jsshell
+
+test(() => {
+  const argument = { "parameters": [] };
+  const exception = new WebAssembly.Exception(argument);
+  const runtimeException = new WebAssembly.RuntimeException(exception);
+  assert_class_string(runtimeException, "WebAssembly.RuntimeException");
+}, "Object.prototype.toString on a RuntimeException");
+
+test(() => {
+  assert_own_property(WebAssembly.RuntimeException.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(WebAssembly.RuntimeException.prototype, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WebAssembly.RuntimeException", "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");