Add memcpy_struct_bytes test

Author: lucic71

tests/unit/memcpy_struct_bytes.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+struct point {
+  int32_t x;
+  int32_t y;
+};
+
+int main(void) {
+  struct point src = {3, 7};
+
+  unsigned char buf[sizeof(struct point)];
+  memcpy(buf, &src, sizeof(buf));
+
+  struct point dst;
+  memcpy(&dst, buf, sizeof(dst));
+
+  assert(dst.x == 3);
+  assert(dst.y == 7);
+
+  return 0;
+}

tests/unit/out/refcount/memcpy_struct_bytes.rs

@@ -0,0 +1,55 @@
+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};
+#[derive(Default)]
+pub struct point {
+    pub x: Value<i32>,
+    pub y: Value<i32>,
+}
+impl ByteRepr for point {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.y.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            y: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let src: Value<point> = Rc::new(RefCell::new(point {
+        x: Rc::new(RefCell::new(3)),
+        y: Rc::new(RefCell::new(7)),
+    }));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..8).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    {
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memcpy(
+            &((src.as_pointer()) as Ptr<point>).to_any(),
+            ::std::mem::size_of::<[u8; 8]>() as usize,
+        );
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    };
+    let dst: Value<point> = <Value<point>>::default();
+    {
+        ((dst.as_pointer()) as Ptr<point>).to_any().memcpy(
+            &((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+            ::std::mem::size_of::<point>() as usize,
+        );
+        ((dst.as_pointer()) as Ptr<point>).to_any().clone()
+    };
+    assert!(((((*(*dst.borrow()).x.borrow()) == 3) as i32) != 0));
+    assert!(((((*(*dst.borrow()).y.borrow()) == 7) as i32) != 0));
+    return 0;
+}

tests/unit/out/unsafe/memcpy_struct_bytes.rs

@@ -0,0 +1,47 @@
+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;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct point {
+    pub x: i32,
+    pub y: i32,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut src: point = point { x: 3, y: 7 };
+    let mut buf: [u8; 8] = [0_u8; 8];
+    {
+        if ::std::mem::size_of::<[u8; 8]>() != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                ((&mut src as *mut point) as *const point as *const ::libc::c_void),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+                ::std::mem::size_of::<[u8; 8]>() as usize,
+            )
+        }
+        (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+    };
+    let mut dst: point = <point>::default();
+    {
+        if ::std::mem::size_of::<point>() != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+                ((&mut dst as *mut point) as *mut point as *mut ::libc::c_void),
+                ::std::mem::size_of::<point>() as usize,
+            )
+        }
+        ((&mut dst as *mut point) as *mut point as *mut ::libc::c_void)
+    };
+    assert!(((((dst.x) == (3)) as i32) != 0));
+    assert!(((((dst.y) == (7)) as i32) != 0));
+    return 0;
+}