Update tests

Author: lucic71

tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs

@@ -44,3 +44,4 @@ pub fn touch_0(c: Ptr<container>) {
     (*(*(*c.borrow()).upgrade().deref()).p.borrow()).clone();
 }
 pub struct opaque;
+impl ByteRepr for opaque {}

tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs

@@ -31,3 +31,4 @@ pub unsafe fn touch_0(mut c: *mut container) {
     &((*c).p);
 }
 pub struct opaque;
+impl ByteRepr for opaque {}

tests/unit/out/refcount/opaque_forward_decl.rs

@@ -38,3 +38,4 @@ fn main_0() -> i32 {
     return ((*(*c.borrow()).x.borrow()) - 42);
 }
 pub struct opaque;
+impl ByteRepr for opaque {}

tests/unit/out/refcount/union_pointer_int_roundtrip.rs

@@ -0,0 +1,92 @@
+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 arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([10, 20, 30, 40])));
+    pub struct anon_0 {
+        __bytes: Value<Box<[u8]>>,
+    }
+    impl anon_0 {
+        pub fn p(&self) -> Ptr<Ptr<i32>> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+        pub fn bits(&self) -> Ptr<u64> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+    }
+    impl Clone for anon_0 {
+        fn clone(&self) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(self.__bytes.borrow().clone())),
+            }
+        }
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from([0u8; 8]))),
+            }
+        }
+    }
+    impl ByteRepr for anon_0 {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            buf.copy_from_slice(&self.__bytes.borrow());
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from(buf))),
+            }
+        }
+    };
+    let u: Value<anon_0> = <Value<anon_0>>::default();
+    (*u.borrow_mut())
+        .p()
+        .write(((arr.as_pointer() as Ptr<i32>).offset(1)));
+    let rhs_0 = ((((*u.borrow()).bits().read()) as u64)
+        .wrapping_add(((2_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    (*u.borrow_mut()).bits().write(rhs_0);
+    let q: Value<Ptr<i32>> = Rc::new(RefCell::new(((*u.borrow()).p().read()).clone()));
+    assert!((((((*q.borrow()).read()) == 40) as i32) != 0));
+    assert!(
+        ((({
+            let _lhs = (*q.borrow()).clone();
+            _lhs == ((arr.as_pointer() as Ptr<i32>).offset(3))
+        }) as i32)
+            != 0)
+    );
+    let rhs_0 = ((((*u.borrow()).bits().read()) as u64)
+        .wrapping_sub(((3_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    (*u.borrow_mut()).bits().write(rhs_0);
+    assert!(
+        ((({
+            let _lhs = ((*u.borrow()).p().read()).clone();
+            _lhs == ((arr.as_pointer() as Ptr<i32>).offset(0))
+        }) as i32)
+            != 0)
+    );
+    assert!(((((((*u.borrow()).p().read()).read()) == 10) as i32) != 0));
+    (*u.borrow_mut())
+        .p()
+        .write((arr.as_pointer() as Ptr<i32>).offset((4) as isize));
+    assert!(
+        ((({
+            let _lhs = ((*u.borrow()).p().read()).clone();
+            _lhs == (arr.as_pointer() as Ptr<i32>).offset((4) as isize)
+        }) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/opaque_forward_decl.rs

@@ -26,3 +26,4 @@ unsafe fn main_0() -> i32 {
     return ((c.x) - (42));
 }
 pub struct opaque;
+impl ByteRepr for opaque {}

tests/unit/out/unsafe/union_pointer_int_roundtrip.rs

@@ -0,0 +1,43 @@
+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 arr: [i32; 4] = [10, 20, 30, 40];
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub union anon_0 {
+        pub p: *mut i32,
+        pub bits: u64,
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            unsafe { std::mem::zeroed() }
+        }
+    };
+    let mut u: anon_0 = <anon_0>::default();
+    u.p = (&mut arr[(1) as usize] as *mut i32);
+    u.bits = ((u.bits as u64)
+        .wrapping_add(((2_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    let mut q: *mut i32 = u.p;
+    assert!(((((*q) == (40)) as i32) != 0));
+    assert!(((((q) == (&mut arr[(3) as usize] as *mut i32)) as i32) != 0));
+    u.bits = ((u.bits as u64)
+        .wrapping_sub(((3_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    assert!(((((u.p) == (&mut arr[(0) as usize] as *mut i32)) as i32) != 0));
+    assert!(((((*u.p) == (10)) as i32) != 0));
+    u.p = arr.as_mut_ptr().offset((4) as isize);
+    assert!(((((u.p) == (arr.as_mut_ptr().offset((4) as isize))) as i32) != 0));
+    return 0;
+}

tests/unit/union_pointer_int_roundtrip.c

@@ -0,0 +1,27 @@
+#include <assert.h>
+#include <stdint.h>
+
+int main(void) {
+  int arr[4] = {10, 20, 30, 40};
+
+  union {
+    int *p;
+    uintptr_t bits;
+  } u;
+
+  u.p = &arr[1];
+  u.bits += 2 * sizeof(int);
+  int *q = u.p;
+
+  assert(*q == 40);
+  assert(q == &arr[3]);
+
+  u.bits -= 3 * sizeof(int);
+  assert(u.p == &arr[0]);
+  assert(*u.p == 10);
+
+  u.p = arr + 4;
+  assert(u.p == arr + 4);
+
+  return 0;
+}

tests/unit/union_pointer_pun_address.c

@@ -1,4 +1,3 @@
-// panic: refcount
 #include <assert.h>
 
 struct node_a {

tests/unit/union_pointer_pun_writethrough.c

@@ -1,4 +1,3 @@
-// panic: refcount
 #include <assert.h>
 
 int main(void) {

tests/unit/union_tagged_many_arms.c

@@ -1,4 +1,3 @@
-// panic: refcount
 #include <assert.h>
 #include <stdint.h>