Source code
Revision control
Copy as Markdown
Other Tools
const instanceTestFactory = [
[
"Empty module without imports argument",
function() {
return {
buffer: emptyModuleBinary,
args: [],
exports: {},
verify: () => {},
};
}
],
[
"Empty module with undefined imports argument",
function() {
return {
buffer: emptyModuleBinary,
args: [undefined],
exports: {},
verify: () => {},
};
}
],
[
"Empty module with empty imports argument",
function() {
return {
buffer: emptyModuleBinary,
args: [{}],
exports: {},
verify: () => {},
};
}
],
[
"getter order for imports object",
function() {
const builder = new WasmModuleBuilder();
builder.addImportedGlobal("module", "global1", kWasmI32);
builder.addImportedGlobal("module2", "global3", kWasmI32);
builder.addImportedMemory("module", "memory", 0, 128);
builder.addImportedGlobal("module", "global2", kWasmI32);
const buffer = builder.toBuffer();
const order = [];
const imports = {
get module() {
order.push("module getter");
return {
get global1() {
order.push("global1 getter");
return 0;
},
get global2() {
order.push("global2 getter");
return 0;
},
get memory() {
order.push("memory getter");
return new WebAssembly.Memory({ "initial": 64, maximum: 128 });
},
}
},
get module2() {
order.push("module2 getter");
return {
get global3() {
order.push("global3 getter");
return 0;
},
}
},
};
const expected = [
"module getter",
"global1 getter",
"module2 getter",
"global3 getter",
"module getter",
"memory getter",
"module getter",
"global2 getter",
];
return {
buffer,
args: [imports],
exports: {},
verify: () => assert_array_equals(order, expected),
};
}
],
[
"imports",
function() {
const builder = new WasmModuleBuilder();
builder.addImport("module", "fn", kSig_v_v);
builder.addImportedGlobal("module", "global", kWasmI32);
builder.addImportedMemory("module", "memory", 0, 128);
builder.addImportedTable("module", "table", 0, 128);
const buffer = builder.toBuffer();
const imports = {
"module": {
"fn": function() {},
"global": 0,
"memory": new WebAssembly.Memory({ "initial": 64, maximum: 128 }),
"table": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }),
},
get "module2"() {
assert_unreached("Should not get modules that are not imported");
},
};
return {
buffer,
args: [imports],
exports: {},
verify: () => {},
};
}
],
[
"imports with empty module names",
function() {
const builder = new WasmModuleBuilder();
builder.addImport("", "fn", kSig_v_v);
builder.addImportedGlobal("", "global", kWasmI32);
builder.addImportedMemory("", "memory", 0, 128);
builder.addImportedTable("", "table", 0, 128);
const buffer = builder.toBuffer();
const imports = {
"": {
"fn": function() {},
"global": 0,
"memory": new WebAssembly.Memory({ "initial": 64, maximum: 128 }),
"table": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }),
},
};
return {
buffer,
args: [imports],
exports: {},
verify: () => {},
};
}
],
[
"imports with empty names",
function() {
const builder = new WasmModuleBuilder();
builder.addImport("a", "", kSig_v_v);
builder.addImportedGlobal("b", "", kWasmI32);
builder.addImportedMemory("c", "", 0, 128);
builder.addImportedTable("d", "", 0, 128);
const buffer = builder.toBuffer();
const imports = {
"a": { "": function() {} },
"b": { "": 0 },
"c": { "": new WebAssembly.Memory({ "initial": 64, maximum: 128 }) },
"d": { "": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }) },
};
return {
buffer,
args: [imports],
exports: {},
verify: () => {},
};
}
],
[
"exports with empty name: function",
function() {
const builder = new WasmModuleBuilder();
builder
.addFunction("", kSig_v_d)
.addBody([])
.exportFunc();
const buffer = builder.toBuffer();
const exports = {
"": { "kind": "function", "name": "0", "length": 1 },
};
return {
buffer,
args: [],
exports,
verify: () => {},
};
}
],
[
"exports with empty name: table",
function() {
const builder = new WasmModuleBuilder();
builder.setTableBounds(1);
builder.addExportOfKind("", kExternalTable, 0);
const buffer = builder.toBuffer();
const exports = {
"": { "kind": "table", "length": 1 },
};
return {
buffer,
args: [],
exports,
verify: () => {},
};
}
],
[
"exports with empty name: global",
function() {
const builder = new WasmModuleBuilder();
builder.addGlobal(kWasmI32, true)
.exportAs("")
.init = wasmI32Const(7);
const buffer = builder.toBuffer();
const exports = {
"": { "kind": "global", "value": 7 },
};
return {
buffer,
args: [],
exports,
verify: () => {},
};
}
],
[
"No imports",
function() {
const builder = new WasmModuleBuilder();
builder
.addFunction("fn", kSig_v_d)
.addBody([])
.exportFunc();
builder
.addFunction("fn2", kSig_v_v)
.addBody([])
.exportFunc();
builder.setTableBounds(1);
builder.addExportOfKind("table", kExternalTable, 0);
builder.addGlobal(kWasmI32, true)
.exportAs("global")
.init = wasmI32Const(7);
builder.addGlobal(kWasmF64, true)
.exportAs("global2")
.init = wasmF64Const(1.2);
builder.addMemory(4, 8, true);
const buffer = builder.toBuffer();
const exports = {
"fn": { "kind": "function", "name": "0", "length": 1 },
"fn2": { "kind": "function", "name": "1", "length": 0 },
"table": { "kind": "table", "length": 1 },
"global": { "kind": "global", "value": 7 },
"global2": { "kind": "global", "value": 1.2 },
"memory": { "kind": "memory", "size": 4 },
};
return {
buffer,
args: [],
exports,
verify: () => {},
};
}
],
[
"exports and imports",
function() {
const value = 102;
const builder = new WasmModuleBuilder();
const index = builder.addImportedGlobal("module", "global", kWasmI32);
builder
.addFunction("fn", kSig_i_v)
.addBody([
kExprGlobalGet,
index,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
const imports = {
"module": {
"global": value,
},
};
const exports = {
"fn": { "kind": "function", "name": "0", "length": 0 },
};
return {
buffer,
args: [imports],
exports,
verify: instance => assert_equals(instance.exports.fn(), value)
};
}
],
[
"i64 exports and imports",
function() {
const value = 102n;
const builder = new WasmModuleBuilder();
const index = builder.addImportedGlobal("module", "global", kWasmI64);
builder
.addFunction("fn", kSig_l_v)
.addBody([
kExprGlobalGet,
index,
kExprReturn,
])
.exportFunc();
const index2 = builder.addImportedGlobal("module", "global2", kWasmI64);
builder.addExportOfKind("global", kExternalGlobal, index2);
const buffer = builder.toBuffer();
const imports = {
"module": {
"global": value,
"global2": 2n ** 63n,
},
};
const exports = {
"fn": { "kind": "function", "name": "0", "length": 0 },
"global": { "kind": "global", "value": -(2n ** 63n) },
};
return {
buffer,
args: [imports],
exports,
verify: instance => assert_equals(instance.exports.fn(), value)
};
}
],
[
"import with i32-returning function",
function() {
const builder = new WasmModuleBuilder();
const fnIndex = builder.addImport("module", "fn", kSig_i_v);
const fn2 = builder
.addFunction("fn2", kSig_v_v)
.addBody([
kExprCallFunction,
fnIndex,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
let called = false;
const imports = {
"module": {
"fn": function() {
called = true;
return 6n;
},
},
};
return {
buffer,
args: [imports],
exports: {
"fn2": { "kind": "function", "name": String(fn2.index), "length": 0 },
},
verify: instance => {
assert_throws_js(TypeError, () => instance.exports.fn2());
assert_true(called, "Should have called into JS");
}
};
}
],
[
"import with function that takes and returns i32",
function() {
const builder = new WasmModuleBuilder();
const fnIndex = builder.addImport("module", "fn", kSig_i_i);
const fn2 = builder
.addFunction("fn2", kSig_i_v)
.addBody([
kExprI32Const, 0x66,
kExprCallFunction,
fnIndex,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
let called = false;
const imports = {
"module": {
"fn": function(n) {
called = true;
assert_equals(n, -26);
return { valueOf() { return 6; } };
},
},
};
return {
buffer,
args: [imports],
exports: {
"fn2": { "kind": "function", "name": String(fn2.index), "length": 0 },
},
verify: instance => {
assert_equals(instance.exports.fn2(), 6);
assert_true(called, "Should have called into JS");
}
};
}
],
[
"import with i64-returning function",
function() {
const builder = new WasmModuleBuilder();
const fnIndex = builder.addImport("module", "fn", kSig_l_v);
const fn2 = builder
.addFunction("fn2", kSig_v_v)
.addBody([
kExprCallFunction,
fnIndex,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
let called = false;
const imports = {
"module": {
"fn": function() {
called = true;
return 6;
},
},
};
return {
buffer,
args: [imports],
exports: {
"fn2": { "kind": "function", "name": String(fn2.index), "length": 0 },
},
verify: instance => {
assert_throws_js(TypeError, () => instance.exports.fn2());
assert_true(called, "Should have called into JS");
}
};
}
],
[
"import with function that takes and returns i64",
function() {
const builder = new WasmModuleBuilder();
const fnIndex = builder.addImport("module", "fn", kSig_l_l);
const fn2 = builder
.addFunction("fn2", kSig_l_v)
.addBody([
kExprI64Const, 0x66,
kExprCallFunction,
fnIndex,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
let called = false;
const imports = {
"module": {
"fn": function(n) {
called = true;
assert_equals(n, -26n);
return { valueOf() { return 6n; } };
},
},
};
return {
buffer,
args: [imports],
exports: {
"fn2": { "kind": "function", "name": String(fn2.index), "length": 0 },
},
verify: instance => {
assert_equals(instance.exports.fn2(), 6n);
assert_true(called, "Should have called into JS");
}
};
}
],
[
"import with i32-taking function",
function() {
const builder = new WasmModuleBuilder();
const fn = builder
.addFunction("fn", kSig_v_i)
.addBody([
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
return {
buffer,
args: [],
exports: {
"fn": { "kind": "function", "name": String(fn.index), "length": 1 },
},
verify: instance => assert_throws_js(TypeError, () => instance.exports.fn(6n))
};
}
],
[
"import with i64-taking function",
function() {
const builder = new WasmModuleBuilder();
const fn = builder
.addFunction("fn", kSig_v_l)
.addBody([
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
return {
buffer,
args: [],
exports: {
"fn": { "kind": "function", "name": String(fn.index), "length": 1 },
},
verify: instance => assert_throws_js(TypeError, () => instance.exports.fn(6))
};
}
],
[
"export i64-returning function",
function() {
const builder = new WasmModuleBuilder();
const fn = builder
.addFunction("fn", kSig_l_v)
.addBody([
kExprI64Const, 0x66,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
return {
buffer,
args: [],
exports: {
"fn": { "kind": "function", "name": String(fn.index), "length": 0 },
},
verify: instance => assert_equals(instance.exports.fn(), -26n)
};
}
],
[
"i32 mutable WebAssembly.Global import",
function() {
const initial = 102;
const value = new WebAssembly.Global({ "value": "i32", "mutable": true }, initial);
const builder = new WasmModuleBuilder();
const index = builder.addImportedGlobal("module", "global", kWasmI32, true);
const fn = builder
.addFunction("fn", kSig_i_v)
.addBody([
kExprGlobalGet,
index,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
const imports = {
"module": {
"global": value,
},
};
const exports = {
"fn": { "kind": "function", "name": String(fn.index), "length": 0 },
};
return {
buffer,
args: [imports],
exports,
verify: instance => {
assert_equals(instance.exports.fn(), initial);
const after = 201;
value.value = after;
assert_equals(instance.exports.fn(), after);
}
};
}
],
[
"i64 mutable WebAssembly.Global import",
function() {
const initial = 102n;
const value = new WebAssembly.Global({ "value": "i64", "mutable": true }, initial);
const builder = new WasmModuleBuilder();
const index = builder.addImportedGlobal("module", "global", kWasmI64, true);
const fn = builder
.addFunction("fn", kSig_l_v)
.addBody([
kExprGlobalGet,
index,
kExprReturn,
])
.exportFunc();
const buffer = builder.toBuffer();
const imports = {
"module": {
"global": value,
},
};
const exports = {
"fn": { "kind": "function", "name": String(fn.index), "length": 0 },
};
return {
buffer,
args: [imports],
exports,
verify: instance => {
assert_equals(instance.exports.fn(), initial);
const after = 201n;
value.value = after;
assert_equals(instance.exports.fn(), after);
}
};
}
],
[
"Multiple i64 arguments",
function() {
const builder = new WasmModuleBuilder();
const fn = builder
.addFunction("fn", kSig_l_ll)
.addBody([
kExprLocalGet, 1,
])
.exportFunc();
const buffer = builder.toBuffer();
const exports = {
"fn": { "kind": "function", "name": String(fn.index), "length": 2 },
};
return {
buffer,
args: [],
exports,
verify: instance => {
const fn = instance.exports.fn;
assert_equals(fn(1n, 0n), 0n);
assert_equals(fn(1n, 123n), 123n);
assert_equals(fn(1n, -123n), -123n);
assert_equals(fn(1n, "5"), 5n);
assert_throws_js(TypeError, () => fn(1n, 5));
}
};
}
],
[
"stray argument",
function() {
return {
buffer: emptyModuleBinary,
args: [{}, {}],
exports: {},
verify: () => {}
};
}
],
];
globalThis.instanceTestFactory = instanceTestFactory;