Diffusion Ant (mir/inline-method) Code

ant/tests/test_ffi_wrappers.cjs
3fa05edd2fe3mir/inline-method

test_ffi_wrappers.cjs
View Options

			import { alloc, callback, dlopen, pointer, suffix, FFIType } from 'ant:ffi';

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

			function expectThrow(fn, message) {
			let threw = false;
			try {
			fn();
			} catch (_) {
			threw = true;
			}
			assert(threw, message);
			}

			let libcName = `libc.${suffix}`;
			if (process.platform === 'darwin') libcName = 'libSystem.dylib';
			if (process.platform === 'linux') libcName = 'libc.so.6';
			if (process.platform === 'win32') libcName = 'msvcrt.dll';

			const libc = dlopen(libcName);
			const abs = libc.define('abs', {
			args: [FFIType.int],
			returns: FFIType.int
			});

			assert(typeof abs === 'function', 'define() should return a callable FFIFunction');
			assert(abs.address() > 0, 'FFIFunction.address() should expose a native address');
			assert(abs(-7) === 7, 'FFIFunction should be callable directly');
			assert(libc.call('abs', -9) === 9, 'FFILibrary.call() should dispatch through defined wrappers');

			const strlen = libc.define('strlen', {
			args: [FFIType.string],
			returns: FFIType.int
			});
			assert(strlen('planet') === 6, 'string arguments should support borrowed JS strings for call-only use');

			const strchr = libc.define('strchr', {
			args: [FFIType.string, FFIType.int],
			returns: FFIType.pointer
			});

			const haystack = pointer('planet');
			const tail = strchr(haystack, 'n'.charCodeAt(0));
			assert(tail && typeof tail.read === 'function', 'pointer returns should materialize FFIPointer objects');
			assert(tail.read(FFIType.string) === 'net', 'FFIPointer.read(string) should decode C strings');
			assert(strchr(haystack, 'z'.charCodeAt(0)) === null, 'null pointer returns should become null');

			const owned = pointer('hello ffi');
			assert(owned.read(FFIType.string) === 'hello ffi', 'pointer(string) should allocate an owned C string');
			owned.free();
			expectThrow(() => owned.read(FFIType.string), 'reading a freed pointer should throw');

			const slot = alloc(8);
			const namePtr = pointer('ant');
			slot.write(FFIType.pointer, namePtr);
			const roundTrip = slot.read(FFIType.pointer);
			assert(roundTrip.read(FFIType.string) === 'ant', 'pointer slots should round-trip FFIPointer values');

			const values = alloc(16);
			values.offset(0).write(FFIType.int, 4);
			values.offset(4).write(FFIType.int, 1);
			values.offset(8).write(FFIType.int, 3);
			values.offset(12).write(FFIType.int, 2);

			const qsort = libc.define('qsort', {
			args: [FFIType.pointer, FFIType.int, FFIType.int, FFIType.pointer],
			returns: FFIType.void
			});

			const compareInts = callback(
			{
			args: [FFIType.pointer, FFIType.pointer],
			returns: FFIType.int
			},
			(left, right) => left.read(FFIType.int) - right.read(FFIType.int)
			);

			qsort(values, 4, 4, compareInts);
			assert(values.offset(0).read(FFIType.int) === 1, 'qsort should sort the first element');
			assert(values.offset(4).read(FFIType.int) === 2, 'qsort should sort the second element');
			assert(values.offset(8).read(FFIType.int) === 3, 'qsort should sort the third element');
			assert(values.offset(12).read(FFIType.int) === 4, 'qsort should sort the fourth element');

			compareInts.close();
			expectThrow(() => libc.define('abs', { args: [FFIType.spread, FFIType.int], returns: FFIType.int }), 'invalid spread placement should throw');

			const closable = dlopen(libcName);
			const closableAbs = closable.define('abs', {
			args: [FFIType.int],
			returns: FFIType.int
			});
			closable.close();
			expectThrow(() => closableAbs(-1), 'FFIFunctions should fail once their library is closed');

			slot.free();
			namePtr.free();
			values.free();
			libc.close();
			haystack.free();

			console.log('ffi-wrappers:ok');

Owner Packages

No Owners