Diffusion Ant (mir/inline-method) Code

ant/tests/test_wasm_webassembly_api.mjs
3fa05edd2fe3mir/inline-method

test_wasm_webassembly_api.mjs
View Options

			import { readFileSync } from 'ant:fs';

			function assert(condition, message) {
			if (!condition) throw new Error(message);
			}

			function fixture(path) {
			return readFileSync(import.meta.dirname + '/../' + path);
			}

			const api = globalThis.WebAssembly;

			assert(api && typeof api === 'object', 'globalThis.WebAssembly should exist');

			for (const name of ['Global', 'Instance', 'Memory', 'Module', 'Table', 'Tag', 'Exception', 'CompileError', 'LinkError', 'RuntimeError']) {
			assert(typeof api[name] === 'function', `WebAssembly.${name} should exist`);
			}

			const incrementer = fixture('wpt/wasm/webapi/resources/incrementer.wasm');
			const tableExportFixture = new Uint8Array([
			0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 1, 127, 96, 0, 1, 127, 3, 3, 2, 0, 1, 4, 4, 1, 112, 0, 2, 7, 24, 3, 5, 115, 101, 118, 101, 110, 0, 0,
			4, 110, 105, 110, 101, 0, 1, 5, 116, 97, 98, 108, 101, 1, 0, 9, 8, 1, 0, 65, 0, 11, 2, 0, 1, 10, 11, 2, 4, 0, 65, 7, 11, 4, 0, 65, 9, 11, 0, 21, 4,
			110, 97, 109, 101, 1, 14, 2, 0, 5, 115, 101, 118, 101, 110, 1, 4, 110, 105, 110, 101
			]);
			const throwingImportFixture = new Uint8Array([
			0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 2, 12, 1, 3, 101, 110, 118, 4, 102, 97, 105, 108, 0, 0, 3, 2, 1, 0, 7, 7, 1, 3, 114, 117, 110, 0, 1,
			10, 6, 1, 4, 0, 16, 0, 11
			]);

			assert(WebAssembly.validate(incrementer) === true, 'incrementer.wasm should validate');

			const module = new WebAssembly.Module(incrementer);
			const descriptors = WebAssembly.Module.exports(module);
			assert(Array.isArray(descriptors), 'WebAssembly.Module.exports() should return an array');
			assert(
			descriptors.some(entry => entry && entry.name === 'increment' && entry.kind === 'function'),
			'incrementer.wasm should export increment()'
			);

			const instance = new WebAssembly.Instance(module);
			assert(typeof instance.exports.increment === 'function', 'instance.exports.increment should exist');
			assert(instance.exports.increment(41) === 42, 'increment(41) should return 42');

			const tableModule = new WebAssembly.Module(tableExportFixture);
			const tableInstance = new WebAssembly.Instance(tableModule);
			assert(tableInstance.exports.table.length === 2, 'exported table should expose its length');
			const firstTableEntry = tableInstance.exports.table.get(0);
			const secondTableEntry = tableInstance.exports.table.get(1);
			assert(typeof firstTableEntry === 'function', 'table.get(0) should return a callable function');
			assert(typeof secondTableEntry === 'function', 'table.get(1) should return a callable function');
			assert(firstTableEntry() === 7, 'table.get(0) should invoke the first table function');
			assert(secondTableEntry() === 9, 'table.get(1) should invoke the second table function');
			tableInstance.exports.table.set(0, tableInstance.exports.nine);
			assert(tableInstance.exports.table.get(0)() === 9, 'table.set() should accept wasm-exported functions');

			const throwingModule = new WebAssembly.Module(throwingImportFixture);

			let sawPrimitiveThrow = false;
			try {
			new WebAssembly.Instance(throwingModule, {
			env: {
			fail() {
			throw Infinity;
			}
			}
			}).exports.run();
			} catch (error) {
			sawPrimitiveThrow = true;
			assert(error === Infinity, 'import throws should preserve primitive thrown values');
			}
			assert(sawPrimitiveThrow, 'primitive import throws should escape the wasm call');

			const thrownError = new Error('import boom');
			let sawErrorThrow = false;
			try {
			new WebAssembly.Instance(throwingModule, {
			env: {
			fail() {
			throw thrownError;
			}
			}
			}).exports.run();
			} catch (error) {
			sawErrorThrow = true;
			assert(error === thrownError, 'import throws should preserve original Error objects');
			}
			assert(sawErrorThrow, 'Error import throws should escape the wasm call');

			const thrownStatus = {
			name: 'ExitStatus',
			message: 'Program terminated with exit(1)',
			status: 1
			};
			let sawErrorlikeThrow = false;
			try {
			new WebAssembly.Instance(throwingModule, {
			env: {
			fail() {
			throw thrownStatus;
			}
			}
			}).exports.run();
			} catch (error) {
			sawErrorlikeThrow = true;
			assert(error === thrownStatus, 'import throws should preserve original error-like objects');
			assert(error.stack === undefined, 'error-like import throws should not grow a synthetic stack');
			}
			assert(sawErrorlikeThrow, 'error-like import throws should escape the wasm call');

			const compiled = await WebAssembly.compile(incrementer);
			assert(compiled instanceof WebAssembly.Module, 'WebAssembly.compile() should resolve a module');

			const instantiated = await WebAssembly.instantiate(incrementer);
			assert(instantiated.module instanceof WebAssembly.Module, 'instantiate(bytes) should return a module');
			assert(instantiated.instance instanceof WebAssembly.Instance, 'instantiate(bytes) should return an instance');
			assert(instantiated.instance.exports.increment(9) === 10, 'instantiate(bytes) should wire exports');

			const global = new WebAssembly.Global({ value: 'i32', mutable: true }, 7);
			assert(global.value === 7, 'WebAssembly.Global should expose its initial value');
			global.value = 11;
			assert(global.value === 11, 'WebAssembly.Global should accept writes');
			assert(global.valueOf() === 11, 'WebAssembly.Global.prototype.valueOf() should read the value');

			const invalid = new Uint8Array([0x00, 0x61, 0x62, 0x63]);
			assert(WebAssembly.validate(invalid) === false, 'invalid wasm bytes should fail validation');

			let sawCompileError = false;
			try {
			new WebAssembly.Module(invalid);
			} catch (error) {
			sawCompileError = true;
			assert(error instanceof WebAssembly.CompileError \|\| error?.name === 'CompileError', 'invalid module should throw CompileError');
			}
			assert(sawCompileError, 'invalid module construction should fail');

			console.log('wasm:webassembly-api:ok');

Owner Packages

No Owners