Add call to fread through function pointer

Author: lucic71

tests/unit/fn_ptr_stdlib_compare.cpp

@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 typedef size_t (*fread_t)(void *, size_t, size_t, FILE *);
 
@@ -19,5 +20,19 @@ int main() {
   fread_t f3 = (fread_t)my_alternative_fread;
   assert((*f3)(nullptr, 0, 0, nullptr) == 22);
 
+  FILE *stream = fopen("/dev/zero", "rb");
+  assert(stream != nullptr);
+  char buf[16];
+  memset(buf, 'X', sizeof(buf));
+  size_t n = (*fn1)(buf, 1, 10, stream);
+  assert(n == 10);
+  for (int i = 0; i < 10; ++i) {
+    assert(buf[i] == 0);
+  }
+  for (int i = 10; i < 16; ++i) {
+    assert(buf[i] == 'X');
+  }
+  fclose(stream);
+
   return 0;
 }

tests/unit/out/refcount/fn_ptr_stdlib_compare.rs

@@ -66,5 +66,57 @@ fn main_0() -> i32 {
             (*(*f3.borrow()))(_arg0, _arg1, _arg2, _arg3)
         }) == 22_u64)
     );
+    let stream: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
+        match Ptr::from_string_literal("rb").to_rust_string() {
+            v if v == "rb" => std::fs::OpenOptions::new()
+                .read(true)
+                .open(Ptr::from_string_literal("/dev/zero").to_rust_string())
+                .ok()
+                .map_or(Ptr::null(), |f| Ptr::alloc(f)),
+            v if v == "wb" => std::fs::OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(Ptr::from_string_literal("/dev/zero").to_rust_string())
+                .ok()
+                .map_or(Ptr::null(), |f| Ptr::alloc(f)),
+            _ => panic!("unsupported mode"),
+        },
+    ));
+    assert!(!((*stream.borrow()).is_null()));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    {
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memset(
+            (('X' as u8) as i32) as u8,
+            ::std::mem::size_of::<[u8; 16]>() as u64 as usize,
+        );
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    };
+    let n: Value<u64> = Rc::new(RefCell::new(
+        ({
+            let _arg0: AnyPtr = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any();
+            let _arg1: u64 = 1_u64;
+            let _arg2: u64 = 10_u64;
+            let _arg3: Ptr<::std::fs::File> = (*stream.borrow()).clone();
+            (*(*fn1.borrow()))(_arg0, _arg1, _arg2, _arg3)
+        }),
+    ));
+    assert!(((*n.borrow()) == 10_u64));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < 10) {
+        assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == 0));
+        (*i.borrow_mut()).prefix_inc();
+    }
+    let i: Value<i32> = Rc::new(RefCell::new(10));
+    'loop_: while ((*i.borrow()) < 16) {
+        assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == (('X' as u8) as i32)));
+        (*i.borrow_mut()).prefix_inc();
+    }
+    {
+        (*stream.borrow()).delete();
+        0
+    };
     return 0;
 }

tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs

@@ -50,5 +50,63 @@ unsafe fn main_0() -> i32 {
             (f3).unwrap()(_arg0, _arg1, _arg2, _arg3)
         }) == (22_u64))
     );
+    let mut stream: *mut ::std::fs::File =
+        match std::ffi::CStr::from_ptr(b"rb\0".as_ptr() as *const i8)
+            .to_str()
+            .expect("invalid c-string")
+        {
+            v if v == "rb" => std::fs::OpenOptions::new()
+                .read(true)
+                .open(
+                    std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
+                        .to_str()
+                        .expect("invalid c-string"),
+                )
+                .ok()
+                .map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
+            v if v == "wb" => std::fs::OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(
+                    std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
+                        .to_str()
+                        .expect("invalid c-string"),
+                )
+                .ok()
+                .map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
+            _ => panic!("unsupported mode"),
+        };
+    assert!(!((stream).is_null()));
+    let mut buf: [u8; 16] = [0_u8; 16];
+    {
+        let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
+        for offset in 0..::std::mem::size_of::<[u8; 16]>() as u64 {
+            *byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
+        }
+        (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+    };
+    let mut n: u64 = (unsafe {
+        let _arg0: *mut ::libc::c_void = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void);
+        let _arg1: u64 = 1_u64;
+        let _arg2: u64 = 10_u64;
+        let _arg3: *mut ::std::fs::File = stream;
+        (fn1).unwrap()(_arg0, _arg1, _arg2, _arg3)
+    });
+    assert!(((n) == (10_u64)));
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (10)) {
+        assert!(((buf[(i) as usize] as i32) == (0)));
+        i.prefix_inc();
+    }
+    let mut i: i32 = 10;
+    'loop_: while ((i) < (16)) {
+        assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
+        i.prefix_inc();
+    }
+    {
+        Box::from_raw(stream);
+        0
+    };
     return 0;
 }