Add simple io test

Author: lucic71

tests/unit/fd_io.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(void) {
+  const char *path = "/tmp/cpp2rust_fd_io_test.tmp";
+  int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+  assert(fd >= 0);
+  assert(write(fd, "hello world", 11) == 11);
+  assert(close(fd) == 0);
+  fd = open(path, O_RDONLY);
+  assert(fd >= 0);
+  char buf[16];
+  memset(buf, 0, sizeof(buf));
+  assert(read(fd, buf, sizeof(buf)) == 11);
+  assert(strcmp(buf, "hello world") == 0);
+  assert(read(fd, buf, sizeof(buf)) == 0);
+  assert(close(fd) == 0);
+  assert(unlink(path) == 0);
+  return 0;
+}

tests/unit/out/refcount/fd_io.rs

@@ -0,0 +1,140 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let path: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(
+        b"/tmp/cpp2rust_fd_io_test.tmp",
+    )));
+    let fd: Value<i32> = Rc::new(RefCell::new({
+        let __mode = match &[(420).into()].first() {
+            Some(__m) => nix::sys::stat::Mode::from_bits_truncate(i32::get(__m) as ::libc::mode_t),
+            None => nix::sys::stat::Mode::empty(),
+        };
+        match nix::fcntl::open(
+            (*path.borrow()).to_rust_string().as_str(),
+            nix::fcntl::OFlag::from_bits_retain(((1 | 64) | 512)),
+            __mode,
+        ) {
+            Ok(__ofd) => FdRegistry::register(__ofd),
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        }
+    }));
+    assert!(((((*fd.borrow()) >= 0) as i32) != 0));
+    assert!(
+        (((match FdRegistry::with_fd((*fd.borrow()), |__fd| {
+            Ptr::from_string_literal(b"hello world")
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice(11_usize, |__buf| nix::unistd::write(__fd, __buf))
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 11_isize) as i32)
+            != 0)
+    );
+    assert!((((FdRegistry::close((*fd.borrow())) == 0) as i32) != 0));
+    (*fd.borrow_mut()) = {
+        let __mode = match &[].first() {
+            Some(__m) => nix::sys::stat::Mode::from_bits_truncate(i32::get(__m) as ::libc::mode_t),
+            None => nix::sys::stat::Mode::empty(),
+        };
+        match nix::fcntl::open(
+            (*path.borrow()).to_rust_string().as_str(),
+            nix::fcntl::OFlag::from_bits_retain(0),
+            __mode,
+        ) {
+            Ok(__ofd) => FdRegistry::register(__ofd),
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        }
+    };
+    assert!(((((*fd.borrow()) >= 0) as i32) != 0));
+    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((0) as u8, ::std::mem::size_of::<[u8; 16]>() as usize);
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    };
+    assert!(
+        (((match FdRegistry::with_fd((*fd.borrow()), |__fd| {
+            ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice_mut(::std::mem::size_of::<[u8; 16]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 11_isize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __it1 = (buf.as_pointer() as Ptr<u8>).to_c_string_iterator();
+            let mut __it2 = Ptr::from_string_literal(b"hello world").to_c_string_iterator();
+            loop {
+                let __c1 = __it1.next();
+                let __c2 = __it2.next();
+                if __c1 != __c2 {
+                    break (__c1.unwrap_or(0) as i32) - (__c2.unwrap_or(0) as i32);
+                }
+                if __c1.is_none() {
+                    break 0;
+                }
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((match FdRegistry::with_fd((*fd.borrow()), |__fd| {
+            ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice_mut(::std::mem::size_of::<[u8; 16]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 0_isize) as i32)
+            != 0)
+    );
+    assert!((((FdRegistry::close((*fd.borrow())) == 0) as i32) != 0));
+    assert!(
+        (((match nix::unistd::unlink((*path.borrow()).to_rust_string().as_str()) {
+            Ok(()) => 0,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/fd_io.rs

@@ -0,0 +1,65 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_fd_io_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fd: i32 =
+        (unsafe { libc::open(path as *const i8, (((1) | (64)) | (512)) as i32, (420)) });
+    assert!(((((fd) >= (0)) as i32) != 0));
+    assert!(
+        ((((libc::write(
+            fd,
+            (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void),
+            11_usize
+        )) == (11_isize)) as i32)
+            != 0)
+    );
+    assert!(((((libc::close(fd)) == (0)) as i32) != 0));
+    fd = (unsafe { libc::open(path as *const i8, 0 as i32) });
+    assert!(((((fd) >= (0)) as i32) != 0));
+    let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16];
+    {
+        let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+        for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() {
+            *byte_0.offset(offset as isize) = 0 as u8;
+        }
+        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
+    };
+    assert!(
+        ((((libc::read(
+            fd,
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+            ::std::mem::size_of::<[libc::c_char; 16]>()
+        )) == (11_isize)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((libc::strcmp(
+            (buf.as_mut_ptr()).cast_const(),
+            (c"hello world".as_ptr().cast_mut()).cast_const()
+        )) == (0)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((libc::read(
+            fd,
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+            ::std::mem::size_of::<[libc::c_char; 16]>()
+        )) == (0_isize)) as i32)
+            != 0)
+    );
+    assert!(((((libc::close(fd)) == (0)) as i32) != 0));
+    assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
+    return 0;
+}