1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// META: global=window,dedicatedworker,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_js(TypeError, () => new WebAssembly.Global());
}, "No arguments");
test(() => {
const argument = { "value": "i32" };
assert_throws_js(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_js(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_js(TypeError, () => new WebAssembly.Global(argument));
}
}, "Invalid type argument");
test(() => {
const argument = { "value": "i64" };
const global = new WebAssembly.Global(argument);
assert_throws_js(TypeError, () => global.value);
assert_throws_js(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}`);
}
}
test(() => {
const argument = { "value": "i32" };
const global = new WebAssembly.Global(argument, 0, {});
assert_Global(global, 0);
}, "Stray argument");
|
