Merge pull request #2786 from Skgland/ffi-f64-tests

add ffi tests & fix ffi
2025-08-10 13:14:15 -07:00
parent 9fb7d15f0a e1a52a4dde
commit c0fb3fd429
18 changed files with 1153 additions and 518 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -591,6 +591,12 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

+[[package]]
+name = "current_platform"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a74858bcfe44b22016cb49337d7b6f04618c58e5dbfdef61b06b8c434324a0bc"
+
 [[package]]
 name = "dashu"
 version = "0.4.2"
@@ -2689,6 +2695,7 @@ dependencies = [
 "crossterm",
 "crrl",
 "ctrlc",
+ "current_platform",
 "dashu",
 "derive_more",
 "dirs-next",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -119,6 +119,7 @@ js-sys = "0.3"
 ouroboros = "0.18"

 [dev-dependencies]
+current_platform = "0.2.0"
 maplit = "1.0.2"
 serial_test = "3.1.1"

--- a/src/ffi.rs
+++ b/src/ffi.rs
--- a/src/lib/ffi.pl
+++ b/src/lib/ffi.pl
@@ -11,8 +11,8 @@ The main predicate is `use_foreign_module/2`. It takes a library name (which dep
 operating system could be a `.so`, `.dylib` or `.dll` file). and a list of functions. Each
 function is defined by its name, a list of the type of the arguments, and the return argument.

-Types available are: `sint8`, `uint8`, `sint16`, `uint16`, `sint32`, `uint32`, `sint64`,
-`uint64`, `f32`, `f64`, `cstr`, `void`, `bool`, `ptr` and custom structs, which can be defined
+Types available are: `sint8`/`i8`, `uint8`/`u8`, `sint16`/`i16`, `uint16`/`u16`, `sint32`/`i32`, `uint32`/`u32`, `sint64`/`i64`,
+`uint64`/`u64`, `f32`, `f64`, `cstr`, `void`, `bool`, `ptr` and custom structs, which can be defined
 with `foreign_struct/2`.

 After that, each function on the lists maps to a predicate created in the ffi module which
@@ -27,6 +27,12 @@ ffi:FUNCTION_NAME(+InputArg1, ..., +InputArgN, -ReturnArg). % for all return typ
 ffi:FUNCTION_NAME(+InputArg1, ..., +InputArgN). % for void and bool
 ```

+## Notes regarding cstr
+
+- When using `cstr` as an argument type the string will be deallocated once the function returns.
+- When using `cstr` as a return type the string will be copied and won't be deallocated.
+
+
 ## Example

 For example, let's see how to define a function from the [raylib](https://www.raylib.com/) library.
--- a/src/machine/config.rs
+++ b/src/machine/config.rs
@@ -78,7 +78,7 @@ impl OutputStreamConfig {

 #[derive(Debug)]
 enum InputStreamConfigInner {
-    String(String),
+    String(Cow<'static, str>),
    Stdin,
    Channel(Receiver<Vec<u8>>),
 }
@@ -97,7 +97,7 @@ pub struct InputStreamConfig {

 impl InputStreamConfig {
    /// Gets input from string.
-    pub fn string(s: impl Into<String>) -> Self {
+    pub fn string(s: impl Into<Cow<'static, str>>) -> Self {
        Self {
            inner: InputStreamConfigInner::String(s.into()),
        }
@@ -123,7 +123,10 @@ impl InputStreamConfig {

    fn into_stream(self, arena: &mut Arena, add_history: bool) -> Stream {
        match self.inner {
-            InputStreamConfigInner::String(s) => Stream::from_owned_string(s, arena),
+            InputStreamConfigInner::String(s) => match s {
+                Cow::Owned(s) => Stream::from_owned_string(s, arena),
+                Cow::Borrowed(s) => Stream::from_static_string(s, arena),
+            },
            InputStreamConfigInner::Stdin => Stream::stdin(arena, add_history),
            InputStreamConfigInner::Channel(channel) => Stream::input_channel(channel, arena),
        }
@@ -156,7 +159,7 @@ impl StreamConfig {
    /// Binds the output and error streams to memory buffers and has an empty input.
    pub fn in_memory() -> Self {
        StreamConfig {
-            user_input: InputStreamConfig::string(""),
+            user_input: InputStreamConfig::string(String::new()),
            user_output: OutputStreamConfig::memory(),
            user_error: OutputStreamConfig::memory(),
        }
--- a/src/machine/machine_errors.rs
+++ b/src/machine/machine_errors.rs
@@ -3,7 +3,7 @@ use crate::atom_table::*;
 use crate::parser::ast::*;

 #[cfg(feature = "ffi")]
-use crate::ffi::FFIError;
+use crate::ffi::FfiError;
 use crate::forms::*;
 use crate::functor_macro::*;
 use crate::machine::heap::*;
@@ -613,14 +613,20 @@ impl MachineState {
    }

    #[cfg(feature = "ffi")]
-    pub(super) fn ffi_error(&self, err: FFIError) -> MachineError {
+    pub(super) fn ffi_error(&self, err: FfiError) -> MachineError {
        let error_atom = match err {
-            FFIError::ValueCast => atom!("value_cast"),
-            FFIError::ValueDontFit => atom!("value_dont_fit"),
-            FFIError::InvalidFFIType => atom!("invalid_ffi_type"),
-            FFIError::InvalidStructName => atom!("invalid_struct_name"),
-            FFIError::FunctionNotFound => atom!("function_not_found"),
-            FFIError::StructNotFound => atom!("struct_not_found"),
+            FfiError::ValueCast => atom!("value_cast"),
+            FfiError::ValueOutOfRange => atom!("value_out_of_range"),
+            FfiError::InvalidFfiType => atom!("invalid_ffi_type"),
+            FfiError::InvalidArgumentType => atom!("invalid_argument_type"),
+            FfiError::InvalidArgument => atom!("invalid_argument"),
+            FfiError::InvalidStruct => atom!("invalid_struct"),
+            FfiError::FunctionNotFound => atom!("function_not_found"),
+            FfiError::StructNotFound => atom!("struct_not_found"),
+            FfiError::ArgCountMismatch => atom!("mismatched_argument_count"),
+            FfiError::AllocationFailed => atom!("allocation_failed"),
+            FfiError::LayoutError => atom!("layout_error"),
+            FfiError::UnsupportedAbi => atom!("unsupported_abi"),
        };
        let stub = functor!(atom!("ffi_error"), [atom_as_cell(error_atom)]);

--- a/src/machine/system_calls.rs
+++ b/src/machine/system_calls.rs
@@ -5004,65 +5004,80 @@ impl Machine {
    #[cfg(feature = "ffi")]
    #[inline(always)]
    pub(crate) fn foreign_call(&mut self) -> CallResult {
+        fn stub_gen() -> Vec<FunctorElement> {
+            functor_stub(atom!("foreign_call"), 3)
+        }
+
+        fn map_arg(
+            machine_st: &mut MachineState,
+            source: HeapCellValue,
+        ) -> Result<crate::ffi::Value, FfiError> {
+            if let Ok(number) = Number::try_from((source, &machine_st.arena.f64_tbl)) {
+                Ok(Value::Number(number))
+            } else if let Some(string) = machine_st.value_to_str_like(source) {
+                Ok(Value::CString(CString::new(&*string.as_str()).unwrap()))
+            } else if let Ok(args) = machine_st.try_from_list(source, stub_gen) {
+                // structs are lists represented as lists
+                // the head is a string with the struct type name
+                // the tail are the struct field values
+
+                let mut iter = args.into_iter();
+                if let Some(struct_name) = machine_st.value_to_str_like(iter.next().unwrap()) {
+                    Ok(Value::Struct(
+                        struct_name.as_str().to_string(),
+                        iter.map(|x| map_arg(machine_st, x))
+                            .collect::<Result<_, _>>()?,
+                    ))
+                } else {
+                    // empty list is an invalid struct repr
+                    Err(FfiError::InvalidStruct)
+                }
+            } else {
+                Err(FfiError::InvalidArgument)
+            }
+        }
+
        let function_name = self.deref_register(1);
        let args_reg = self.deref_register(2);
        let return_value = self.deref_register(3);
        if let Some(function_name) = self.machine_st.value_to_str_like(function_name) {
-            let stub_gen = || functor_stub(atom!("foreign_call"), 3);
-            fn map_arg(machine_st: &mut MachineState, source: HeapCellValue) -> crate::ffi::Value {
-                match Number::try_from((source, &machine_st.arena.f64_tbl)) {
-                    Ok(Number::Fixnum(n)) => Value::Int(n.get_num()),
-                    Ok(Number::Float(n)) => Value::Float(n.into_inner()),
-                    _ => {
-                        let stub_gen = || functor_stub(atom!("foreign_call"), 3);
-                        if let Some(string) = machine_st.value_to_str_like(source) {
-                            Value::CString(CString::new(&*string.as_str()).unwrap())
-                        } else {
-                            match machine_st.try_from_list(source, stub_gen) {
-                                Ok(args) => {
-                                    let mut iter = args.into_iter();
-                                    if let Some(struct_name) =
-                                        machine_st.value_to_str_like(iter.next().unwrap())
-                                    {
-                                        Value::Struct(
-                                            struct_name.as_str().to_string(),
-                                            iter.map(|x| map_arg(machine_st, x)).collect(),
-                                        )
-                                    } else {
-                                        unreachable!()
-                                    }
-                                }
-                                _ => {
-                                    unreachable!()
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
            match self.machine_st.try_from_list(args_reg, stub_gen) {
                Ok(args) => {
-                    let args: Vec<_> = args
+                    let args = match args
                        .into_iter()
                        .map(|x| map_arg(&mut self.machine_st, x))
-                        .collect();
-                    match self
-                        .foreign_function_table
-                        .exec(&function_name.as_str(), args)
+                        .collect::<Result<Vec<_>, _>>()
                    {
+                        Ok(args) => args,
+                        Err(err) => {
+                            let err = self.machine_st.ffi_error(err);
+                            return Err(self.machine_st.error_form(err, stub_gen()));
+                        }
+                    };
+
+                    match self.foreign_function_table.exec(
+                        &function_name.as_str(),
+                        args,
+                        &mut self.machine_st.arena,
+                    ) {
                        Ok(result) => {
                            match result {
-                                Value::Int(n) => self.machine_st.unify_fixnum(
-                                    Fixnum::build_with_checked(n).unwrap_or_else(|_| {
-                                        todo!("handle integer values that don't fit in fixnum")
-                                    }),
-                                    return_value,
-                                ),
-                                Value::Float(n) => {
+                                Value::Number(n) => match n {
+                                    Number::Float(OrderedFloat(n)) => {
                                        let n = float_alloc!(n, self.machine_st.arena);
                                        self.machine_st.unify_f64(n, return_value)
                                    }
+                                    Number::Integer(typed_arena_ptr) => {
+                                        self.machine_st.unify_big_int(typed_arena_ptr, return_value)
+                                    }
+                                    Number::Rational(typed_arena_ptr) => {
+                                        self.machine_st
+                                            .unify_rational(typed_arena_ptr, return_value);
+                                    }
+                                    Number::Fixnum(fixnum) => {
+                                        self.machine_st.unify_fixnum(fixnum, return_value)
+                                    }
+                                },
                                Value::Struct(name, args) => {
                                    let struct_value = resource_error_call_result!(
                                        self.machine_st,
@@ -5083,10 +5098,8 @@ impl Machine {
                            return Ok(());
                        }
                        Err(e) => {
-                            let stub = functor_stub(atom!("current_input"), 1);
                            let err = self.machine_st.ffi_error(e);
-
-                            return Err(self.machine_st.error_form(err, stub));
+                            return Err(self.machine_st.error_form(err, stub_gen()));
                        }
                    }
                }
@@ -5102,34 +5115,26 @@ impl Machine {
    fn build_struct(&mut self, name: &str, mut args: Vec<Value>) -> Result<HeapCellValue, usize> {
        args.insert(0, Value::CString(CString::new(name).unwrap()));

-        let mut expanded_args = Vec::with_capacity(args.len());
-
-        for val in args {
-            expanded_args.push(match val {
-                Value::Int(n) => {
-                    if let Ok(fixnum) = Fixnum::build_with_checked(n) {
-                        fixnum_as_cell!(fixnum)
-                    } else {
-                        integer_as_cell!(Number::Integer(arena_alloc!(
-                            Integer::from(n),
-                            &mut self.machine_st.arena
-                        )))
+        let cells: Vec<_> = args
+            .into_iter()
+            .map(|val| {
+                Ok(match val {
+                    Value::Number(n) => match n {
+                        Number::Float(OrderedFloat(f)) => {
+                            HeapCellValue::from(float_alloc!(f, self.machine_st.arena))
                        }
-                }
-                Value::Float(n) => HeapCellValue::from(float_alloc!(n, self.machine_st.arena)),
+                        _ => integer_as_cell!(n),
+                    },
                    Value::CString(cstr) => atom_as_cell!(AtomTable::build_with(
                        &self.machine_st.atom_tbl,
                        &cstr.into_string().unwrap()
                    )),
                    Value::Struct(name, struct_args) => self.build_struct(&name, struct_args)?,
-            });
-        }
+                })
+            })
+            .collect::<Result<_, usize>>()?;

-        sized_iter_to_heap_list(
-            &mut self.machine_st.heap,
-            expanded_args.len(),
-            expanded_args.into_iter(),
-        )
+        sized_iter_to_heap_list(&mut self.machine_st.heap, cells.len(), cells.into_iter())
    }

    #[cfg(feature = "ffi")]
@@ -5150,7 +5155,11 @@ impl Machine {
                Err(e) => return Err(e),
            };
            self.foreign_function_table
-                .define_struct(&struct_name.as_str(), fields);
+                .define_struct(&struct_name.as_str(), fields)
+                .map_err(|err| {
+                    let ffi_error = self.machine_st.ffi_error(err);
+                    self.machine_st.error_form(ffi_error, stub_gen())
+                })?;
            return Ok(());
        }
        self.machine_st.fail = true;
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -583,10 +583,13 @@ mod private {
        }
    }

+    impl<T: FitsInFixnumSeal> MightNotFitInFixnumSeal for T {}
    impl MightNotFitInFixnumSeal for i64 {}
+    impl MightNotFitInFixnumSeal for u64 {}
    impl MightNotFitInFixnumSeal for &Integer {}
    impl MightNotFitInFixnumSeal for Integer {}
    impl MightNotFitInFixnumSeal for usize {}
+    impl MightNotFitInFixnumSeal for isize {}
 }

 #[allow(private_bounds)]
--- a/tests-pl/ffi_cstr.pl
+++ b/tests-pl/ffi_cstr.pl
@@ -0,0 +1,21 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+init :-
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,
+    use_foreign_module(LIB, [
+        'ffi_cstr_len'([cstr], u64),
+        'ffi_example_cstr'([], cstr),
+        'ffi_null_cstr'([], cstr)
+    ]).
+
+test :-
+    ffi:'ffi_cstr_len'("Scryer Prolog", Len),
+    ffi:'ffi_example_cstr'(Str),
+    ffi:'ffi_null_cstr'(Null),
+    ffi:'ffi_cstr_len'(0, MaxU64),
+    write((Len-Str-Null-MaxU64)).
+
+:- initialization((init,test)).
--- a/tests-pl/ffi_f64_minus_zero.pl
+++ b/tests-pl/ffi_f64_minus_zero.pl
@@ -0,0 +1,18 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+test :- 
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,
+    use_foreign_module(LIB, ['ffi_f64_minus_zero'([], f64), 'signum'([f64], f64)]),
+    ffi:'ffi_f64_minus_zero'(N),
+    A is max(0.0, N),
+    B is max(N, 0.0),
+    ffi:'signum'(A, SA),
+    ffi:'signum'(B, SB),
+    write((SA, SB)),
+    -1.0 is SA, % incorrect, based on https://www.swi-prolog.org/pldoc/man?function=max/2 -0.0 is less than 0.0 so A and B should be 0.0 for which signum should be 1
+    1.0 is SB.
+
+:- initialization(test).
--- a/tests-pl/ffi_f64_nan.pl
+++ b/tests-pl/ffi_f64_nan.pl
@@ -0,0 +1,12 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+test :- 
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,
+    use_foreign_module(LIB, ['ffi_f64_nan'([], f64)]),
+    ffi:'ffi_f64_nan'(N),
+    _ is round(N).
+
+:- initialization(test).
--- a/tests-pl/ffi_invalid_type.pl
+++ b/tests-pl/ffi_invalid_type.pl
@@ -0,0 +1,13 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+test :- 
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,
+    use_foreign_module(LIB, [
+        %% should be void instead of c_void
+        'ffi_invalid_type'([], c_void)
+    ]).
+
+:- initialization(test).
--- a/tests-pl/ffi_return_values.pl
+++ b/tests-pl/ffi_return_values.pl
@@ -0,0 +1,36 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+test :- 
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,   
+    use_foreign_module(LIB, [
+        'ffi_return_values_true'([], bool), 
+        'ffi_return_values_false'([], bool), 
+        'ffi_return_values_i8'([], sint8),
+        'ffi_return_values_u8'([], uint8),
+        'ffi_return_values_i16'([], sint16),
+        'ffi_return_values_u16'([], uint16),
+        'ffi_return_values_i32'([], sint32),
+        'ffi_return_values_u32'([], uint32),
+        'ffi_return_values_i64'([], sint64),
+        'ffi_return_values_u64'([], uint64),
+        'ffi_return_values_f32'([], f32),
+        'ffi_return_values_f64'([], f64)
+    ]),
+    ffi:'ffi_return_values_true',
+    (\+ ffi:'ffi_return_values_false'),
+    ffi:'ffi_return_values_i8'(I8),
+    ffi:'ffi_return_values_u8'(U8),
+    ffi:'ffi_return_values_i16'(I16),
+    ffi:'ffi_return_values_u16'(U16),
+    ffi:'ffi_return_values_i32'(I32),
+    ffi:'ffi_return_values_u32'(U32),
+    ffi:'ffi_return_values_i64'(I64),
+    ffi:'ffi_return_values_u64'(U64),
+    ffi:'ffi_return_values_f32'(F32),
+    ffi:'ffi_return_values_f64'(F64),
+    write((i8-I8, u8-U8, i16-I16, u16-U16, i32-I32, u32-U32, i64-I64, u64-U64, f32-F32, f64-F64)).
+
+:- initialization(test).
--- a/tests-pl/ffi_struct.pl
+++ b/tests-pl/ffi_struct.pl
@@ -0,0 +1,15 @@
+:- use_module(library(os)).
+:- use_module(library(ffi)).
+
+test :- 
+    read(Body),
+    term_variables(Body, [LIB]),
+    Body,
+    foreign_struct(pg, [uint8, uint16, uint32, uint64, uint8, f32, f64]),
+    use_foreign_module(LIB, ['construct'([uint8, uint16, uint32, uint64, uint8, f32, f64], pg), 'modify'([pg], pg)]),
+    ffi:'construct'(8, 12, 46, 40, 127, 1.368, -4.587, PG),
+    write(("PG"-PG)), nl,
+    ffi:'modify'(PG, [pg, A, B, C, D, A2, E, F]),
+    write(("PG2"-[pg, A, B, C, D, A2, E, F])), nl.
+
+:- initialization(test).
--- a/tests/scryer/ffi.rs
+++ b/tests/scryer/ffi.rs
@@ -0,0 +1,285 @@
+use std::{
+    env::consts::{DLL_PREFIX, DLL_SUFFIX},
+    io::Write,
+    path::{Path, PathBuf},
+    process::Stdio,
+};
+
+use crate::helper::load_module_test_with_input;
+
+use current_platform::CURRENT_PLATFORM;
+
+const TMP_DIR: &str = env!("CARGO_TARGET_TMPDIR");
+
+// each test is building its own library so that they can easier run in parallel,
+// i.e. don't need to wait for a large dynamic library to compile,
+// also rusts test infra currently has no functionallity for a setup/befor step
+fn build_dynamic_library(name: &str, src: &str) -> PathBuf {
+    let tmp_dir: &Path = TMP_DIR.as_ref();
+
+    let mut child = std::process::Command::new("rustc")
+        .stdin(Stdio::piped())
+        .args(["--edition", "2024"])
+        .arg(format!("--target={CURRENT_PLATFORM}"))
+        .arg("--crate-type=dylib")
+        .arg(format!("--crate-name={name}"))
+        .arg("--out-dir")
+        .arg(tmp_dir)
+        .arg("-")
+        .spawn()
+        .unwrap();
+
+    child
+        .stdin
+        .take()
+        .unwrap()
+        .write_all(src.as_bytes())
+        .unwrap();
+
+    assert!(child.wait().unwrap().success());
+
+    tmp_dir.join(format!("{DLL_PREFIX}{name}{DLL_SUFFIX}"))
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_f64_nan() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_f64_nan",
+        r##"
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_f64_nan() -> f64 {
+                    f64::NAN
+                }
+            "##,
+    );
+
+    load_module_test_with_input(
+        "tests-pl/ffi_f64_nan.pl",
+        format!("LIB={dynlib_path:?}."),
+        "   error(evaluation_error(undefined),round/1).\n",
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_f64_minus_zero() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_f64_minus_zero",
+        r##"
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_f64_minus_zero() -> f64 {
+                    -0.0
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn signum(f: f64) -> f64 {
+                    f.signum()
+                }
+            "##,
+    );
+
+    // note: ouput is currently wrong correct would be 1.0,1.0
+    load_module_test_with_input(
+        "tests-pl/ffi_f64_minus_zero.pl",
+        format!("LIB={dynlib_path:?}."),
+        "-1.0,1.0",
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_return_values() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_return_values",
+        r##"
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_true() -> bool {
+                    true
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_false() -> bool {
+                    false
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_i8() -> i8 {
+                    -42
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_u8() -> u8 {
+                    73
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_i16() -> i16 {
+                    -0xBEE
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_u16() -> u16 {
+                    0xC0DE
+                }
+
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_i32() -> i32 {
+                    -0xBEEFBEE
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_u32() -> u32 {
+                    0xC0DEB000
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_i64() -> i64 {
+                    -0xBEEFBEE5C0DEB00
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_u64() -> u64 {
+                    0xFEDCBA9876543210
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_f32() -> f32 {
+                    std::f32::consts::PI
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_return_values_f64() -> f64 {
+                    std::f64::consts::TAU
+                }
+            "##,
+    );
+
+    let expected = format!(
+        "i8- {},u8-{},i16- {},u16-{},i32- {},u32-{},i64- {},u64-{},f32-{},f64-{}",
+        -42,
+        73,
+        -0xBEE,
+        0xC0DE,
+        -0xBEEFBEE,
+        0xC0DEB000u32,
+        -0xBEEFBEE5C0DEB00i64,
+        0xFEDCBA9876543210u64,
+        std::f32::consts::PI as f64,
+        std::f64::consts::TAU
+    );
+
+    load_module_test_with_input(
+        "tests-pl/ffi_return_values.pl",
+        format!("LIB={dynlib_path:?}."),
+        expected.as_str(),
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_invalid_type() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_invalid_type",
+        r##"
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_invalid_type() -> () {
+                }
+            "##,
+    );
+
+    load_module_test_with_input(
+        "tests-pl/ffi_invalid_type.pl",
+        format!("LIB={dynlib_path:?}."),
+        "% Warning: initialization/1 failed for: user:test\n",
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_struct() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_struct",
+        r##"
+                #[repr(C)]
+                struct PaddingGalore {
+                    a: u8,
+                    b: u16,
+                    c: u32,
+                    d: u64,
+                    a2: u8,
+                    e: f32,
+                    f: f64,
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn construct(a: u8, b: u16, c: u32, d: u64, a2: u8, e: f32, f: f64) -> PaddingGalore {
+                    PaddingGalore {
+                        a,
+                        a2,
+                        b,
+                        c,
+                        d,
+                        e,
+                        f,
+                    }
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn modify(data: PaddingGalore) -> PaddingGalore {
+                    PaddingGalore {
+                        a: data.a2,
+                        a2: data.a,
+                        b: !data.b,
+                        c: !data.c,
+                        d: !data.d,
+                        e: -data.e,
+                        f: -data.f,
+                    }
+                }
+            "##,
+    );
+
+    load_module_test_with_input(
+        "tests-pl/ffi_struct.pl",
+        format!("LIB={dynlib_path:?}."),
+        "[P,G]-[pg,8,12,46,40,127,1.3680000305175781,-4.587]\n[P,G,2]-[pg,127,65523,4294967249,18446744073709551575,8,-1.3680000305175781,4.587]\n",
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore = "ffi")]
+fn ffi_cstr() {
+    let dynlib_path = build_dynamic_library(
+        "ffi_cstr",
+        r##"
+                use std::ffi::CStr;
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_cstr_len(c_str: Option<std::ptr::NonNull<core::ffi::c_char>>) -> u64 {
+                    if let Some(c_str) = c_str {
+                        unsafe { CStr::from_ptr(c_str.as_ptr()) }.count_bytes() as u64
+                    } else {
+                        u64::MAX
+                    }
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_example_cstr() -> *const core::ffi::c_char {
+                    c"Rust Lang".as_ptr()
+                }
+
+                #[unsafe(no_mangle)]
+                extern "C" fn ffi_null_cstr() -> *const core::ffi::c_char {
+                    std::ptr::null()
+                }
+            "##,
+    );
+
+    load_module_test_with_input(
+        "tests-pl/ffi_cstr.pl",
+        format!("LIB={dynlib_path:?}."),
+        format!(r#"13-[R,u,s,t, ,L,a,n,g]-0-{}"#, u64::MAX).as_str(),
+    );
+}
--- a/tests/scryer/helper.rs
+++ b/tests/scryer/helper.rs
@@ -1,5 +1,9 @@
 use scryer_prolog::MachineBuilder;

+use std::borrow::Cow;
+
+use scryer_prolog::{InputStreamConfig, StreamConfig};
+
 pub(crate) trait Expectable {
    #[track_caller]
    fn assert_eq(self, other: &[u8]);
@@ -47,3 +51,16 @@ pub(crate) fn load_module_test_with_tokio_runtime<T: Expectable>(file: &str, exp
        expected.assert_eq(wam.test_load_file(file).as_slice())
    });
 }
+
+pub(crate) fn load_module_test_with_input<T: Expectable>(
+    file: &str,
+    input: impl Into<Cow<'static, str>>,
+    expected: T,
+) {
+    use scryer_prolog::MachineBuilder;
+
+    let mut wam = MachineBuilder::default()
+        .with_streams(StreamConfig::in_memory().with_user_input(InputStreamConfig::string(input)))
+        .build();
+    expected.assert_eq(wam.test_load_file(file).as_slice());
+}
--- a/tests/scryer/issues.rs
+++ b/tests/scryer/issues.rs
@@ -56,6 +56,7 @@ fn issue2725_dcg_without_module() {
 #[cfg(feature = "http")]
 #[cfg(not(target_arch = "wasm32"))]
 #[cfg_attr(miri, ignore = "it takes too long to run")]
+#[cfg_attr(not(miri), ignore = "flaky due to network requests")]
 fn http_open_hanging() {
    load_module_test_with_tokio_runtime(
        "tests-pl/issue-http_open-hanging.pl",
--- a/tests/scryer/main.rs
+++ b/tests/scryer/main.rs
@@ -2,6 +2,8 @@ mod helper;
 mod issues;
 mod src_tests;

+mod ffi;
+
 /// To add new cli test copy an existing .toml file in `tests/scryer/cli/issues/` or `tests/scryer/cli/issues/src_tests/`,
 /// adjust as necessary the `-f` and `--no-add-history` args should be kept but additional args may be added.
 /// For input on stdin add a .stdin file with the same filename.