Add mempy struct struct test

Author: lucic71

tests/unit/memcpy_struct_struct.cpp

@@ -0,0 +1,26 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+struct Entry {
+  uint8_t bits;
+  uint16_t value;
+};
+
+int main(void) {
+  struct Entry table[8] = {
+      {1, 0x1111}, {2, 0x2222}, {3, 0x3333}, {4, 0x4444},
+      {0, 0},      {0, 0},      {0, 0},      {0, 0},
+  };
+  size_t table_size = 4;
+
+  memcpy(&table[table_size], &table[0], table_size * sizeof(table[0]));
+
+  assert(table[4].bits == 1 && table[4].value == 0x1111);
+  assert(table[5].bits == 2 && table[5].value == 0x2222);
+  assert(table[6].bits == 3 && table[6].value == 0x3333);
+  assert(table[7].bits == 4 && table[7].value == 0x4444);
+
+  return 0;
+}

tests/unit/out/refcount/memcpy_struct_struct.rs

@@ -0,0 +1,93 @@
+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 Entry {
+    pub bits: Value<u8>,
+    pub value: Value<u16>,
+}
+impl Clone for Entry {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            bits: Rc::new(RefCell::new((*self.bits.borrow()))),
+            value: Rc::new(RefCell::new((*self.value.borrow()))),
+        };
+        this
+    }
+}
+impl ByteRepr for Entry {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let table: Value<Box<[Entry]>> = Rc::new(RefCell::new(Box::new([
+        Entry {
+            bits: Rc::new(RefCell::new(1_u8)),
+            value: Rc::new(RefCell::new(4369_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(2_u8)),
+            value: Rc::new(RefCell::new(8738_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(3_u8)),
+            value: Rc::new(RefCell::new(13107_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(4_u8)),
+            value: Rc::new(RefCell::new(17476_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(0_u8)),
+            value: Rc::new(RefCell::new(0_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(0_u8)),
+            value: Rc::new(RefCell::new(0_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(0_u8)),
+            value: Rc::new(RefCell::new(0_u16)),
+        },
+        Entry {
+            bits: Rc::new(RefCell::new(0_u8)),
+            value: Rc::new(RefCell::new(0_u16)),
+        },
+    ])));
+    let table_size: Value<u64> = Rc::new(RefCell::new(4_u64));
+    {
+        (((table.as_pointer() as Ptr<Entry>).offset((*table_size.borrow()) as isize))
+            as Ptr<Entry>)
+            .to_any()
+            .memcpy(
+                &(((table.as_pointer() as Ptr<Entry>).offset(0 as isize)) as Ptr<Entry>).to_any(),
+                (*table_size.borrow()).wrapping_mul(::std::mem::size_of::<Entry>() as u64 as u64)
+                    as usize,
+            );
+        (((table.as_pointer() as Ptr<Entry>).offset((*table_size.borrow()) as isize)) as Ptr<Entry>)
+            .to_any()
+            .clone()
+    };
+    assert!(
+        (((*(*table.borrow())[(4) as usize].bits.borrow()) as i32) == 1)
+            && (((*(*table.borrow())[(4) as usize].value.borrow()) as i32) == 4369)
+    );
+    assert!(
+        (((*(*table.borrow())[(5) as usize].bits.borrow()) as i32) == 2)
+            && (((*(*table.borrow())[(5) as usize].value.borrow()) as i32) == 8738)
+    );
+    assert!(
+        (((*(*table.borrow())[(6) as usize].bits.borrow()) as i32) == 3)
+            && (((*(*table.borrow())[(6) as usize].value.borrow()) as i32) == 13107)
+    );
+    assert!(
+        (((*(*table.borrow())[(7) as usize].bits.borrow()) as i32) == 4)
+            && (((*(*table.borrow())[(7) as usize].value.borrow()) as i32) == 17476)
+    );
+    return 0;
+}

tests/unit/out/unsafe/memcpy_struct_struct.rs

@@ -0,0 +1,84 @@
+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 Entry {
+    pub bits: u8,
+    pub value: u16,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut table: [Entry; 8] = [
+        Entry {
+            bits: 1_u8,
+            value: 4369_u16,
+        },
+        Entry {
+            bits: 2_u8,
+            value: 8738_u16,
+        },
+        Entry {
+            bits: 3_u8,
+            value: 13107_u16,
+        },
+        Entry {
+            bits: 4_u8,
+            value: 17476_u16,
+        },
+        Entry {
+            bits: 0_u8,
+            value: 0_u16,
+        },
+        Entry {
+            bits: 0_u8,
+            value: 0_u16,
+        },
+        Entry {
+            bits: 0_u8,
+            value: 0_u16,
+        },
+        Entry {
+            bits: 0_u8,
+            value: 0_u16,
+        },
+    ];
+    let mut table_size: u64 = 4_u64;
+    {
+        if (table_size).wrapping_mul(::std::mem::size_of::<Entry>() as u64 as u64) != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                ((&mut table[(0) as usize] as *mut Entry) as *const Entry as *const ::libc::c_void),
+                ((&mut table[(table_size) as usize] as *mut Entry) as *mut Entry
+                    as *mut ::libc::c_void),
+                (table_size).wrapping_mul(::std::mem::size_of::<Entry>() as u64 as u64) as usize,
+            )
+        }
+        ((&mut table[(table_size) as usize] as *mut Entry) as *mut Entry as *mut ::libc::c_void)
+    };
+    assert!(
+        ((table[(4) as usize].bits as i32) == (1))
+            && ((table[(4) as usize].value as i32) == (4369))
+    );
+    assert!(
+        ((table[(5) as usize].bits as i32) == (2))
+            && ((table[(5) as usize].value as i32) == (8738))
+    );
+    assert!(
+        ((table[(6) as usize].bits as i32) == (3))
+            && ((table[(6) as usize].value as i32) == (13107))
+    );
+    assert!(
+        ((table[(7) as usize].bits as i32) == (4))
+            && ((table[(7) as usize].value as i32) == (17476))
+    );
+    return 0;
+}