Update output of fn_ptr_stdlib_compare

Author: lucic71

tests/unit/fn_ptr_stdlib_compare.cpp

@@ -2,17 +2,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-typedef size_t (*read_fn)(void *, size_t, size_t, FILE *);
+typedef size_t (*fread_t)(void *, size_t, size_t, FILE *);
 
-typedef size_t (*read_alternative_fn)(char *, size_t, size_t, void *);
+typedef size_t (*fread_alternative_t)(char *, size_t, size_t, void *);
+
+size_t my_alternative_fread(char *p, size_t n, size_t m, void *f) { return 22; }
 
 int main() {
-  read_fn rfn = fread;
-  assert(rfn == fread);
-  assert(rfn != nullptr);
+  fread_t fn1 = fread;
+  assert(fn1 == fread);
+  assert(fn1 != nullptr);
+
+  fread_alternative_t fn2 = (fread_alternative_t)fread;
+  assert(fn1 == (fread_t)fn2);
 
-  read_alternative_fn rfn2 = (read_alternative_fn)fread;
-  assert(rfn == (read_fn)rfn2);
+  fread_t f3 = (fread_t)my_alternative_fread;
+  assert((*f3)(nullptr, 0, 0, nullptr) == 22);
 
   return 0;
 }

tests/unit/out/refcount/fn_ptr_stdlib_compare.rs

@@ -7,24 +7,31 @@ use std::io::Seek;
 use std::io::{Read, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+pub fn my_alternative_fread_0(p: Ptr<u8>, n: u64, m: u64, f: AnyPtr) -> u64 {
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(p));
+    let n: Value<u64> = Rc::new(RefCell::new(n));
+    let m: Value<u64> = Rc::new(RefCell::new(m));
+    let f: Value<AnyPtr> = Rc::new(RefCell::new(f));
+    return 22_u64;
+}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let rfn: Value<FnPtr<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>> =
+    let fn1: Value<FnPtr<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>> =
         Rc::new(RefCell::new(fn_ptr!(
             rules::stdio_tgt_refcount::f5,
             fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64
         )));
     assert!({
-        let _lhs = (*rfn.borrow()).clone();
+        let _lhs = (*fn1.borrow()).clone();
         _lhs == fn_ptr!(
             rules::stdio_tgt_refcount::f5,
             fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64
         )
     });
-    assert!(!((*rfn.borrow()).is_null()));
-    let rfn2: Value<FnPtr<fn(Ptr<u8>, u64, u64, AnyPtr) -> u64>> = Rc::new(RefCell::new(
+    assert!(!((*fn1.borrow()).is_null()));
+    let fn2: Value<FnPtr<fn(Ptr<u8>, u64, u64, AnyPtr) -> u64>> = Rc::new(RefCell::new(
         fn_ptr!(
             rules::stdio_tgt_refcount::f5,
             fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64
@@ -41,9 +48,30 @@ fn main_0() -> i32 {
         )),
     ));
     assert!({
-        let _lhs = (*rfn.borrow()).clone();
-        _lhs == ((*rfn2.borrow()).cast::<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>(None))
+        let _lhs = (*fn1.borrow()).clone();
+        _lhs == ((*fn2.borrow()).cast::<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>(None))
             .clone()
     });
+    let f3: Value<FnPtr<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>> =
+        Rc::new(RefCell::new(
+            fn_ptr!(
+                my_alternative_fread_0,
+                fn(Ptr::<u8>, u64, u64, AnyPtr) -> u64
+            )
+            .cast::<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>(Some(
+                (|a0: AnyPtr, a1: u64, a2: u64, a3: Ptr<::std::fs::File>| -> u64 {
+                    my_alternative_fread_0(a0.cast::<u8>().unwrap(), a1, a2, a3.to_any())
+                }) as fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64,
+            )),
+        ));
+    assert!(
+        (({
+            let _arg0: AnyPtr = Default::default();
+            let _arg1: u64 = 0_u64;
+            let _arg2: u64 = 0_u64;
+            let _arg3: Ptr<::std::fs::File> = Default::default();
+            (*(*f3.borrow()))(_arg0, _arg1, _arg2, _arg3)
+        }) == 22_u64)
+    );
     return 0;
 }

tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs

@@ -7,27 +7,49 @@ use std::io::Seek;
 use std::io::{Read, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+pub unsafe fn my_alternative_fread_0(
+    mut p: *mut u8,
+    mut n: u64,
+    mut m: u64,
+    mut f: *mut ::libc::c_void,
+) -> u64 {
+    return 22_u64;
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut rfn: Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64> =
+    let mut fn1: Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64> =
         Some(rules::stdio_tgt_unsafe::f5);
-    assert!(((rfn) == (Some(rules::stdio_tgt_unsafe::f5))));
-    assert!(!((rfn).is_none()));
-    let mut rfn2: Option<unsafe fn(*mut u8, u64, u64, *mut ::libc::c_void) -> u64> =
+    assert!(((fn1) == (Some(rules::stdio_tgt_unsafe::f5))));
+    assert!(!((fn1).is_none()));
+    let mut fn2: Option<unsafe fn(*mut u8, u64, u64, *mut ::libc::c_void) -> u64> =
         std::mem::transmute::<
             Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64>,
             Option<unsafe fn(*mut u8, u64, u64, *mut ::libc::c_void) -> u64>,
         >(Some(rules::stdio_tgt_unsafe::f5));
     assert!(
-        ((rfn)
+        ((fn1)
             == (std::mem::transmute::<
                 Option<unsafe fn(*mut u8, u64, u64, *mut ::libc::c_void) -> u64>,
                 Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64>,
-            >(rfn2)))
+            >(fn2)))
+    );
+    let mut f3: Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64> =
+        std::mem::transmute::<
+            Option<unsafe fn(*mut u8, u64, u64, *mut ::libc::c_void) -> u64>,
+            Option<unsafe fn(*mut ::libc::c_void, u64, u64, *mut ::std::fs::File) -> u64>,
+        >(Some(my_alternative_fread_0));
+    assert!(
+        ((unsafe {
+            let _arg0: *mut ::libc::c_void = Default::default();
+            let _arg1: u64 = 0_u64;
+            let _arg2: u64 = 0_u64;
+            let _arg3: *mut ::std::fs::File = Default::default();
+            (f3).unwrap()(_arg0, _arg1, _arg2, _arg3)
+        }) == (22_u64))
     );
     return 0;
 }