mirror of https://github.com/tc39/test262.git
81 lines
2.9 KiB
JavaScript
81 lines
2.9 KiB
JavaScript
import * as assert from '../assert.js';
|
|
import Builder from '../Builder.js';
|
|
|
|
const numRandomIterations = 128;
|
|
|
|
// Generate wasm export functions of arity [0, max), using each valid
|
|
// WebAssembly type as parameters. Make sure this number is high enough to force
|
|
// non-register calls.
|
|
const maxArities = 64;
|
|
|
|
// Calls a "check" function for each parameter received.
|
|
const paramExporter = (params, returnedParam, imports) => {
|
|
const ret = params.length ? params[returnedParam] : "void";
|
|
let builder = (new Builder())
|
|
.Type().End()
|
|
.Import()
|
|
.Function("imp", "checki32", { params: ["i32"] })
|
|
.Function("imp", "checkf32", { params: ["f32"] })
|
|
.Function("imp", "checkf64", { params: ["f64"] })
|
|
.End()
|
|
.Function().End()
|
|
.Export()
|
|
.Function("func")
|
|
.End()
|
|
.Code()
|
|
.Function("func", { params: params, ret: ret });
|
|
for (let i = 0; i < params.length; ++i) {
|
|
builder = builder.GetLocal(i);
|
|
switch (params[i]) {
|
|
case "i32": builder = builder.Call(0); break;
|
|
case "f32": builder = builder.Call(1); break;
|
|
case "f64": builder = builder.Call(2); break;
|
|
default: throw new Error(`Unexpected type`);
|
|
}
|
|
}
|
|
if (ret !== "void")
|
|
builder = builder.GetLocal(returnedParam);
|
|
builder = builder.Return().End().End();
|
|
const bin = builder.WebAssembly().get();
|
|
const module = new WebAssembly.Module(bin);
|
|
return new WebAssembly.Instance(module, { imp: imports });
|
|
};
|
|
|
|
var buffer = new ArrayBuffer(8);
|
|
var viewi16 = new Int16Array(buffer);
|
|
var viewi32 = new Int32Array(buffer);
|
|
var viewf32 = new Float32Array(buffer);
|
|
var viewf64 = new Float64Array(buffer);
|
|
const random16 = () => (Math.random() * (1 + 0xffff)) | 0;
|
|
const setBuffer = () => {
|
|
for (let i = 0; i < 4; ++i)
|
|
viewi16[i] = random16();
|
|
};
|
|
const types = [
|
|
{ type: "i32", generate: () => { setBuffer(); return viewi32[0]; } },
|
|
// i64 isn't supported.
|
|
{ type: "f32", generate: () => { setBuffer(); return viewf32[0]; } },
|
|
{ type: "f64", generate: () => { setBuffer(); return viewf64[0]; } },
|
|
];
|
|
|
|
for (let iteration = 0; iteration < numRandomIterations; ++iteration) {
|
|
const arity = (Math.random() * (maxArities + 1)) | 0;
|
|
let params = [];
|
|
let args = [];
|
|
for (let a = 0; a < arity; ++a) {
|
|
const type =( Math.random() * types.length) | 0;
|
|
params.push(types[type].type);
|
|
args.push(types[type].generate());
|
|
}
|
|
let numChecked = 0;
|
|
const imports = {
|
|
checki32: v => assert.eq(v, args[numChecked++]),
|
|
checkf32: v => assert.eq(v, args[numChecked++]),
|
|
checkf64: v => assert.eq(v, args[numChecked++]),
|
|
};
|
|
const returnedParam = (Math.random() * params.length) | 0;
|
|
const instance = paramExporter(params, returnedParam, imports);
|
|
const result = instance.exports.func(...args);
|
|
assert.eq(result, args.length ? args[returnedParam] : undefined);
|
|
}
|