Skip to content

Commit 2929f44

Browse files
dschuffdschuff
authored
Split memory64 JS API tests into separate files (#2026)
Part of #1950, similarly to what was done with the memory64 core tests
1 parent 6f3007c commit 2929f44

File tree

8 files changed

+265
-249
lines changed

8 files changed

+265
-249
lines changed

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

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
// META: global=window,dedicatedworker,jsshell
2+
// META: script=/wasm/jsapi/assertions.js
3+
// META: script=/wasm/jsapi/memory/assertions.js
4+
5+
const outOfRangeValuesI64 = [
6+
-1n,
7+
0x1_0000_0000_0000_0000n,
8+
];
9+
10+
for (const value of outOfRangeValuesI64) {
11+
test(() => {
12+
assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": value }));
13+
}, `Out-of-range initial i64 value in descriptor: ${format_value(value)}`);
14+
15+
test(() => {
16+
assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 0n, "maximum": value }));
17+
}, `Out-of-range maximum i64 value in descriptor: ${format_value(value)}`);
18+
}
19+
20+
test(() => {
21+
assert_throws_js(RangeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 10n, "maximum": 9n }));
22+
}, "Initial value exceeds maximum (i64)");
23+
24+
test(() => {
25+
const argument = { "address": "i64", "initial": 0n };
26+
const memory = new WebAssembly.Memory(argument);
27+
assert_Memory(memory, { "size": 0, "address": "i64" });
28+
}, "Zero initial (i64)");
29+
30+
test(() => {
31+
const argument = { "address": "i64", "initial": 4n };
32+
const memory = new WebAssembly.Memory(argument);
33+
assert_Memory(memory, { "size": 4, "address": "i64" });
34+
}, "Non-zero initial (i64)");
35+
36+
test(() => {
37+
const argument = { "initial": 1n, "address": "i64" };
38+
const memory = new WebAssembly.Memory(argument);
39+
assert_Memory(memory, { "size": 1, "address": "i64" });
40+
}, "Memory with i64 address constructor");
41+
42+
test(() => {
43+
const argument = { "address": "i64", "initial": "3" };
44+
const memory = new WebAssembly.Memory(argument);
45+
assert_Memory(memory, { "size": 3, "address": "i64" });
46+
}, "Memory with string value for initial (i64)");
47+
48+
test(() => {
49+
const argument = { "address": "i64", "initial": true };
50+
const memory = new WebAssembly.Memory(argument);
51+
assert_Memory(memory, { "size": 1, "address": "i64" });
52+
}, "Memory with boolean value for initial (i64)");

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

Lines changed: 0 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -62,29 +62,10 @@ for (const value of outOfRangeValues) {
6262
}, `Out-of-range maximum value in descriptor: ${format_value(value)}`);
6363
}
6464

65-
const outOfRangeValuesI64 = [
66-
-1n,
67-
0x1_0000_0000_0000_0000n,
68-
];
69-
70-
for (const value of outOfRangeValuesI64) {
71-
test(() => {
72-
assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": value }));
73-
}, `Out-of-range initial i64 value in descriptor: ${format_value(value)}`);
74-
75-
test(() => {
76-
assert_throws_js(TypeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 0n, "maximum": value }));
77-
}, `Out-of-range maximum i64 value in descriptor: ${format_value(value)}`);
78-
}
79-
8065
test(() => {
8166
assert_throws_js(RangeError, () => new WebAssembly.Memory({ "initial": 10, "maximum": 9 }));
8267
}, "Initial value exceeds maximum");
8368

84-
test(() => {
85-
assert_throws_js(RangeError, () => new WebAssembly.Memory({ "address": "i64", "initial": 10n, "maximum": 9n }));
86-
}, "Initial value exceeds maximum (i64)");
87-
8869
test(() => {
8970
const proxy = new Proxy({}, {
9071
has(o, x) {
@@ -165,18 +146,6 @@ test(() => {
165146
assert_Memory(memory, { "size": 4 });
166147
}, "Non-zero initial");
167148

168-
test(() => {
169-
const argument = { "address": "i64", "initial": 0n };
170-
const memory = new WebAssembly.Memory(argument);
171-
assert_Memory(memory, { "size": 0, "address": "i64" });
172-
}, "Zero initial (i64)");
173-
174-
test(() => {
175-
const argument = { "address": "i64", "initial": 4n };
176-
const memory = new WebAssembly.Memory(argument);
177-
assert_Memory(memory, { "size": 4, "address": "i64" });
178-
}, "Non-zero initial (i64)");
179-
180149
test(() => {
181150
const argument = { "initial": 0 };
182151
const memory = new WebAssembly.Memory(argument, {});
@@ -195,36 +164,19 @@ test(() => {
195164
assert_Memory(memory, { "size": 1, "address": "i32" });
196165
}, "Memory with i32 address constructor");
197166

198-
test(() => {
199-
const argument = { "initial": 1n, "address": "i64" };
200-
const memory = new WebAssembly.Memory(argument);
201-
assert_Memory(memory, { "size": 1, "address": "i64" });
202-
}, "Memory with i64 address constructor");
203-
204167
test(() => {
205168
const argument = { "initial": "3" };
206169
const memory = new WebAssembly.Memory(argument);
207170
assert_Memory(memory, { "size": 3 });
208171
}, "Memory with string value for initial");
209172

210-
test(() => {
211-
const argument = { "address": "i64", "initial": "3" };
212-
const memory = new WebAssembly.Memory(argument);
213-
assert_Memory(memory, { "size": 3, "address": "i64" });
214-
}, "Memory with string value for initial (i64)");
215173

216174
test(() => {
217175
const argument = { "initial": true };
218176
const memory = new WebAssembly.Memory(argument);
219177
assert_Memory(memory, { "size": 1 });
220178
}, "Memory with boolean value for initial");
221179

222-
test(() => {
223-
const argument = { "address": "i64", "initial": true };
224-
const memory = new WebAssembly.Memory(argument);
225-
assert_Memory(memory, { "size": 1, "address": "i64" });
226-
}, "Memory with boolean value for initial (i64)");
227-
228180
test(() => {
229181
assert_throws_js(TypeError, () => new WebAssembly.Memory({ "initial": 1, "address": "none" }));
230182
}, "Unknown memory address");

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

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
1+
// META: global=window,dedicatedworker,jsshell
2+
// META: script=/wasm/jsapi/memory/assertions.js
3+
4+
test(() => {
5+
const argument = { "address": "i64", "initial": 0n };
6+
const memory = new WebAssembly.Memory(argument);
7+
const oldMemory = memory.buffer;
8+
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
9+
10+
const result = memory.grow(2n);
11+
assert_equals(result, 0n);
12+
13+
const newMemory = memory.buffer;
14+
assert_not_equals(oldMemory, newMemory);
15+
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
16+
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
17+
}, "Zero initial (i64)");
18+
19+
test(() => {
20+
const argument = { "address": "i64", "initial": 3n };
21+
const memory = new WebAssembly.Memory(argument);
22+
const oldMemory = memory.buffer;
23+
assert_ArrayBuffer(oldMemory, { "size": 3 }, "Buffer before growing");
24+
25+
const result = memory.grow(2n);
26+
assert_equals(result, 3n);
27+
28+
const newMemory = memory.buffer;
29+
assert_not_equals(oldMemory, newMemory);
30+
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
31+
assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
32+
}, "Non-zero initial (i64)");
33+
34+
test(() => {
35+
const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
36+
const memory = new WebAssembly.Memory(argument);
37+
const oldMemory = memory.buffer;
38+
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
39+
40+
const result = memory.grow(2n);
41+
assert_equals(result, 0n);
42+
43+
const newMemory = memory.buffer;
44+
assert_not_equals(oldMemory, newMemory);
45+
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
46+
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
47+
}, "Zero initial with respected maximum (i64)");
48+
49+
test(() => {
50+
const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
51+
const memory = new WebAssembly.Memory(argument);
52+
const oldMemory = memory.buffer;
53+
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
54+
55+
const result = memory.grow(1n);
56+
assert_equals(result, 0n);
57+
58+
const newMemory = memory.buffer;
59+
assert_not_equals(oldMemory, newMemory);
60+
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing once");
61+
assert_ArrayBuffer(newMemory, { "size": 1 }, "New buffer after growing once");
62+
63+
const result2 = memory.grow(1n);
64+
assert_equals(result2, 1n);
65+
66+
const newestMemory = memory.buffer;
67+
assert_not_equals(newMemory, newestMemory);
68+
assert_ArrayBuffer(oldMemory, { "detached": true }, "New buffer after growing twice");
69+
assert_ArrayBuffer(newMemory, { "detached": true }, "New buffer after growing twice");
70+
assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
71+
}, "Zero initial with respected maximum grown twice (i64)");
72+
73+
test(() => {
74+
const argument = { "address": "i64", "initial": 1n, "maximum": 2n };
75+
const memory = new WebAssembly.Memory(argument);
76+
const oldMemory = memory.buffer;
77+
assert_ArrayBuffer(oldMemory, { "size": 1 }, "Buffer before growing");
78+
79+
assert_throws_js(RangeError, () => memory.grow(2n));
80+
assert_equals(memory.buffer, oldMemory);
81+
assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
82+
}, "Zero initial growing too much (i64)");
83+
84+
const outOfRangeValuesI64 = [
85+
-1n,
86+
0x10000000000000000n,
87+
"0x10000000000000000",
88+
];
89+
90+
for (const value of outOfRangeValuesI64) {
91+
test(() => {
92+
const argument = { "address": "i64", "initial": 0n };
93+
const memory = new WebAssembly.Memory(argument);
94+
assert_throws_js(TypeError, () => memory.grow(value));
95+
}, `Out-of-range i64 argument: ${format_value(value)}`);
96+
}
97+

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

Lines changed: 0 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -47,21 +47,6 @@ test(() => {
4747
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
4848
}, "Zero initial");
4949

50-
test(() => {
51-
const argument = { "address": "i64", "initial": 0n };
52-
const memory = new WebAssembly.Memory(argument);
53-
const oldMemory = memory.buffer;
54-
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
55-
56-
const result = memory.grow(2n);
57-
assert_equals(result, 0n);
58-
59-
const newMemory = memory.buffer;
60-
assert_not_equals(oldMemory, newMemory);
61-
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
62-
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
63-
}, "Zero initial (i64)");
64-
6550
test(() => {
6651
const argument = { "initial": { valueOf() { return 0 } } };
6752
const memory = new WebAssembly.Memory(argument);
@@ -92,21 +77,6 @@ test(() => {
9277
assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
9378
}, "Non-zero initial");
9479

95-
test(() => {
96-
const argument = { "address": "i64", "initial": 3n };
97-
const memory = new WebAssembly.Memory(argument);
98-
const oldMemory = memory.buffer;
99-
assert_ArrayBuffer(oldMemory, { "size": 3 }, "Buffer before growing");
100-
101-
const result = memory.grow(2n);
102-
assert_equals(result, 3n);
103-
104-
const newMemory = memory.buffer;
105-
assert_not_equals(oldMemory, newMemory);
106-
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
107-
assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
108-
}, "Non-zero initial (i64)");
109-
11080
test(() => {
11181
const argument = { "initial": 0, "maximum": 2 };
11282
const memory = new WebAssembly.Memory(argument);
@@ -122,21 +92,6 @@ test(() => {
12292
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
12393
}, "Zero initial with respected maximum");
12494

125-
test(() => {
126-
const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
127-
const memory = new WebAssembly.Memory(argument);
128-
const oldMemory = memory.buffer;
129-
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
130-
131-
const result = memory.grow(2n);
132-
assert_equals(result, 0n);
133-
134-
const newMemory = memory.buffer;
135-
assert_not_equals(oldMemory, newMemory);
136-
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
137-
assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
138-
}, "Zero initial with respected maximum (i64)");
139-
14095
test(() => {
14196
const argument = { "initial": 0, "maximum": 2 };
14297
const memory = new WebAssembly.Memory(argument);
@@ -161,30 +116,6 @@ test(() => {
161116
assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
162117
}, "Zero initial with respected maximum grown twice");
163118

164-
test(() => {
165-
const argument = { "address": "i64", "initial": 0n, "maximum": 2n };
166-
const memory = new WebAssembly.Memory(argument);
167-
const oldMemory = memory.buffer;
168-
assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
169-
170-
const result = memory.grow(1n);
171-
assert_equals(result, 0n);
172-
173-
const newMemory = memory.buffer;
174-
assert_not_equals(oldMemory, newMemory);
175-
assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing once");
176-
assert_ArrayBuffer(newMemory, { "size": 1 }, "New buffer after growing once");
177-
178-
const result2 = memory.grow(1n);
179-
assert_equals(result2, 1n);
180-
181-
const newestMemory = memory.buffer;
182-
assert_not_equals(newMemory, newestMemory);
183-
assert_ArrayBuffer(oldMemory, { "detached": true }, "New buffer after growing twice");
184-
assert_ArrayBuffer(newMemory, { "detached": true }, "New buffer after growing twice");
185-
assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
186-
}, "Zero initial with respected maximum grown twice (i64)");
187-
188119
test(() => {
189120
const argument = { "initial": 1, "maximum": 2 };
190121
const memory = new WebAssembly.Memory(argument);
@@ -196,17 +127,6 @@ test(() => {
196127
assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
197128
}, "Zero initial growing too much");
198129

199-
test(() => {
200-
const argument = { "address": "i64", "initial": 1n, "maximum": 2n };
201-
const memory = new WebAssembly.Memory(argument);
202-
const oldMemory = memory.buffer;
203-
assert_ArrayBuffer(oldMemory, { "size": 1 }, "Buffer before growing");
204-
205-
assert_throws_js(RangeError, () => memory.grow(2n));
206-
assert_equals(memory.buffer, oldMemory);
207-
assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
208-
}, "Zero initial growing too much (i64)");
209-
210130
const outOfRangeValues = [
211131
undefined,
212132
NaN,
@@ -227,20 +147,6 @@ for (const value of outOfRangeValues) {
227147
}, `Out-of-range argument: ${format_value(value)}`);
228148
}
229149

230-
const outOfRangeValuesI64 = [
231-
-1n,
232-
0x10000000000000000n,
233-
"0x10000000000000000",
234-
];
235-
236-
for (const value of outOfRangeValuesI64) {
237-
test(() => {
238-
const argument = { "address": "i64", "initial": 0n };
239-
const memory = new WebAssembly.Memory(argument);
240-
assert_throws_js(TypeError, () => memory.grow(value));
241-
}, `Out-of-range i64 argument: ${format_value(value)}`);
242-
}
243-
244150
test(() => {
245151
const argument = { "initial": 0 };
246152
const memory = new WebAssembly.Memory(argument);

0 commit comments

Comments
 (0)