// META: global=jsshell
// 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(new TypeError(), () => new WebAssembly.Global());
}, "No arguments");

test(() => {
  const argument = { "value": "i32" };
  assert_throws(new 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(new 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(new TypeError(), () => new WebAssembly.Global(argument));
  }
}, "Invalid type argument");

test(() => {
  const argument = { "value": "i64" };
  const global = new WebAssembly.Global(argument);
  assert_throws(new TypeError(), () => global.value);
  assert_throws(new TypeError(), () => global.valueOf());
}, "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"],
    [{ valueOf() { return "8" } }, 8, "object with valueOf"],
  ];
  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}`);
  }
}