Split memory64 JS API tests into separate files

test/js-api/memory/constructor-memory64.any.js

@@ -0,0 +1,52 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/memory/assertions.js
+
+const outOfRangeValuesI64 = [
+  -1n,
+  0x1_0000_0000_0000_0000n,
+];
+
+for (const value of outOfRangeValuesI64) {
+  test(() => {
+    assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": value }));
+  }, `Out-of-range initial i64 value in descriptor: ${format_value(value)}`);
+
+  test(() => {
+    assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 0n, "maximum": value }));
+  }, `Out-of-range maximum i64 value in descriptor: ${format_value(value)}`);
+}
+
+test(() => {
+  assert_throws_js(RangeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 10n, "maximum": 9n }));
+}, "Initial value exceeds maximum (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 0n };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 0, "address": "i64" });
+}, "Zero initial (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 4n };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 4, "address": "i64" });
+}, "Non-zero initial (i64)");
+
+test(() => {
+  const argument = { "initial": 1n, "address": "i64" };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 1, "address": "i64" });
+}, "Memory with i64 address constructor");
+
+test(() => {
+  const argument = { "address": "i64", "initial": "3" };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 3, "address": "i64" });
+}, "Memory with string value for initial (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": true };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 1, "address": "i64" });
+}, "Memory with boolean value for initial (i64)");

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

@@ -62,29 +62,10 @@ for (const value of outOfRangeValues) {
   }, `Out-of-range maximum value in descriptor: ${format_value(value)}`);
 }
 
-const outOfRangeValuesI64 = [
-  -1n,
-  0x1_0000_0000_0000_0000n,
-];
-
-for (const value of outOfRangeValuesI64) {
-  test(() => {
-    assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": value }));
-  }, `Out-of-range initial i64 value in descriptor: ${format_value(value)}`);
-
-  test(() => {
-    assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 0n, "maximum": value }));
-  }, `Out-of-range maximum i64 value in descriptor: ${format_value(value)}`);
-}
-
 test(() => {
   assert_throws_js(RangeError, () => new WebAssembly.Memory({ "initial": 10, "maximum": 9 }));
 }, "Initial value exceeds maximum");
 
-test(() => {
-  assert_throws_js(RangeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 10n, "maximum": 9n }));
-}, "Initial value exceeds maximum (i64)");
-
 test(() => {
   const proxy = new Proxy({}, {
     has(o, x) {
@@ -165,18 +146,6 @@ test(() => {
   assert_Memory(memory, { "size": 4 });
 }, "Non-zero initial");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 0n };
-  const memory = new WebAssembly.Memory(argument);
-  assert_Memory(memory, { "size": 0, "address": "i64" });
-}, "Zero initial (i64)");
-
-test(() => {
-  const argument = { "address": "i64", "initial": 4n };
-  const memory = new WebAssembly.Memory(argument);
-  assert_Memory(memory, { "size": 4, "address": "i64" });
-}, "Non-zero initial (i64)");
-
 test(() => {
   const argument = { "initial": 0 };
   const memory = new WebAssembly.Memory(argument, {});
@@ -195,36 +164,19 @@ test(() => {
   assert_Memory(memory, { "size": 1, "address": "i32" });
 }, "Memory with i32 address constructor");
 
-test(() => {
-  const argument = { "initial": 1n, "address": "i64" };
-  const memory = new WebAssembly.Memory(argument);
-  assert_Memory(memory, { "size": 1, "address": "i64" });
-}, "Memory with i64 address constructor");
-
 test(() => {
   const argument = { "initial": "3" };
   const memory = new WebAssembly.Memory(argument);
   assert_Memory(memory, { "size": 3 });
 }, "Memory with string value for initial");
 
-test(() => {
-  const argument = { "address": "i64", "initial": "3" };
-  const memory = new WebAssembly.Memory(argument);
-  assert_Memory(memory, { "size": 3, "address": "i64" });
-}, "Memory with string value for initial (i64)");
 
 test(() => {
   const argument = { "initial": true };
   const memory = new WebAssembly.Memory(argument);
   assert_Memory(memory, { "size": 1 });
 }, "Memory with boolean value for initial");
 
-test(() => {
-  const argument = { "address": "i64", "initial": true };
-  const memory = new WebAssembly.Memory(argument);
-  assert_Memory(memory, { "size": 1, "address": "i64" });
-}, "Memory with boolean value for initial (i64)");
-
 test(() => {
   assert_throws_js(TypeError, () => new WebAssembly.Memory({ "initial": 1, "address": "none" }));
 }, "Unknown memory address");

test/js-api/memory/grow-memory64.any.js

@@ -0,0 +1,97 @@
+// META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/memory/assertions.js
+
+test(() => {
+  const argument = { "address": "i64", "initial": 0n };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2n);
+  assert_equals(result, 0n);
+
+  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");
+}, "Zero initial (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 3n };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 3 }, "Buffer before growing");
+
+  const result = memory.grow(2n);
+  assert_equals(result, 3n);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
+}, "Non-zero initial (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2n);
+  assert_equals(result, 0n);
+
+  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");
+}, "Zero initial with respected maximum (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(1n);
+  assert_equals(result, 0n);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing once");
+  assert_ArrayBuffer(newMemory, { "size": 1 }, "New buffer after growing once");
+
+  const result2 = memory.grow(1n);
+  assert_equals(result2, 1n);
+
+  const newestMemory = memory.buffer;
+  assert_not_equals(newMemory, newestMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "New buffer after growing twice");
+  assert_ArrayBuffer(newMemory, { "detached": true }, "New buffer after growing twice");
+  assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
+}, "Zero initial with respected maximum grown twice (i64)");
+
+test(() => {
+  const argument = { "address": "i64", "initial": 1n, "maximum": 2n };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 1 }, "Buffer before growing");
+
+  assert_throws_js(RangeError, () => memory.grow(2n));
+  assert_equals(memory.buffer, oldMemory);
+  assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
+}, "Zero initial growing too much (i64)");
+
+const outOfRangeValuesI64 = [
+  -1n,
+  0x10000000000000000n,
+  "0x10000000000000000",
+];
+
+for (const value of outOfRangeValuesI64) {
+  test(() => {
+    const argument = { "address": "i64", "initial": 0n };
+    const memory = new WebAssembly.Memory(argument);
+    assert_throws_js(TypeError, () => memory.grow(value));
+  }, `Out-of-range i64 argument: ${format_value(value)}`);
+}
+

test/js-api/memory/grow.any.js

@@ -47,21 +47,6 @@ test(() => {
   assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
 }, "Zero initial");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 0n };
-  const memory = new WebAssembly.Memory(argument);
-  const oldMemory = memory.buffer;
-  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
-
-  const result = memory.grow(2n);
-  assert_equals(result, 0n);
-
-  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");
-}, "Zero initial (i64)");
-
 test(() => {
   const argument = { "initial": { valueOf() { return 0 } } };
   const memory = new WebAssembly.Memory(argument);
@@ -92,21 +77,6 @@ test(() => {
   assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
 }, "Non-zero initial");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 3n };
-  const memory = new WebAssembly.Memory(argument);
-  const oldMemory = memory.buffer;
-  assert_ArrayBuffer(oldMemory, { "size": 3 }, "Buffer before growing");
-
-  const result = memory.grow(2n);
-  assert_equals(result, 3n);
-
-  const newMemory = memory.buffer;
-  assert_not_equals(oldMemory, newMemory);
-  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
-  assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
-}, "Non-zero initial (i64)");
-
 test(() => {
   const argument = { "initial": 0, "maximum": 2 };
   const memory = new WebAssembly.Memory(argument);
@@ -122,21 +92,6 @@ test(() => {
   assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
 }, "Zero initial with respected maximum");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
-  const memory = new WebAssembly.Memory(argument);
-  const oldMemory = memory.buffer;
-  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
-
-  const result = memory.grow(2n);
-  assert_equals(result, 0n);
-
-  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");
-}, "Zero initial with respected maximum (i64)");
-
 test(() => {
   const argument = { "initial": 0, "maximum": 2 };
   const memory = new WebAssembly.Memory(argument);
@@ -161,30 +116,6 @@ test(() => {
   assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
 }, "Zero initial with respected maximum grown twice");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
-  const memory = new WebAssembly.Memory(argument);
-  const oldMemory = memory.buffer;
-  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
-
-  const result = memory.grow(1n);
-  assert_equals(result, 0n);
-
-  const newMemory = memory.buffer;
-  assert_not_equals(oldMemory, newMemory);
-  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing once");
-  assert_ArrayBuffer(newMemory, { "size": 1 }, "New buffer after growing once");
-
-  const result2 = memory.grow(1n);
-  assert_equals(result2, 1n);
-
-  const newestMemory = memory.buffer;
-  assert_not_equals(newMemory, newestMemory);
-  assert_ArrayBuffer(oldMemory, { "detached": true }, "New buffer after growing twice");
-  assert_ArrayBuffer(newMemory, { "detached": true }, "New buffer after growing twice");
-  assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
-}, "Zero initial with respected maximum grown twice (i64)");
-
 test(() => {
   const argument = { "initial": 1, "maximum": 2 };
   const memory = new WebAssembly.Memory(argument);
@@ -196,17 +127,6 @@ test(() => {
   assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
 }, "Zero initial growing too much");
 
-test(() => {
-  const argument = { "address": "i64", "initial": 1n, "maximum": 2n };
-  const memory = new WebAssembly.Memory(argument);
-  const oldMemory = memory.buffer;
-  assert_ArrayBuffer(oldMemory, { "size": 1 }, "Buffer before growing");
-
-  assert_throws_js(RangeError, () => memory.grow(2n));
-  assert_equals(memory.buffer, oldMemory);
-  assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
-}, "Zero initial growing too much (i64)");
-
 const outOfRangeValues = [
   undefined,
   NaN,
@@ -227,20 +147,6 @@ for (const value of outOfRangeValues) {
   }, `Out-of-range argument: ${format_value(value)}`);
 }
 
-const outOfRangeValuesI64 = [
-  -1n,
-  0x10000000000000000n,
-  "0x10000000000000000",
-];
-
-for (const value of outOfRangeValuesI64) {
-  test(() => {
-    const argument = { "address": "i64", "initial": 0n };
-    const memory = new WebAssembly.Memory(argument);
-    assert_throws_js(TypeError, () => memory.grow(value));
-  }, `Out-of-range i64 argument: ${format_value(value)}`);
-}
-
 test(() => {
   const argument = { "initial": 0 };
   const memory = new WebAssembly.Memory(argument);