Update tests

Author: lucic71

tests/ub/out/refcount/self_referencing_initializer.rs

@@ -0,0 +1,31 @@
+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(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(8)]
+pub struct pair {
+    #[offset(0)]
+    pub a: i32,
+    #[offset(4)]
+    pub b: i32,
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let mut x: i32 = 0_i32;
+    x = (x + 1);
+    let mut p: pair = <pair>::default();
+    p = pair { a: 1, b: (p.a + 1) };
+    let r: Ptr<i32> = (r).clone();
+    let __tmp_0: Value<i32> = Rc::new(RefCell::new(((cr.read()) + 1)));
+    let cr: Ptr<i32> = __tmp_0.as_pointer();
+    return ({ ({ (x + p.b) } + { (r.read()) }) } + { (cr.read()) });
+}
+pub fn __cpp2rust_init_globals() {}

tests/ub/out/unsafe/self_referencing_initializer.rs

@@ -0,0 +1,34 @@
+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, VaArg, FnPtrArg, Default)]
+pub struct pair {
+    pub a: i32,
+    pub b: i32,
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut x: i32 = 0_i32;
+    x = ((x) + (1));
+    let mut p: pair = <pair>::default();
+    p = pair {
+        a: 1,
+        b: ((p.a) + (1)),
+    };
+    let r: *mut i32 = r;
+    let mut __tmp_0: i32 = ((*cr) + (1));
+    let cr: *const i32 = &mut __tmp_0;
+    return ((((x) + (p.b)) + (*r)) + (*cr));
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/ub/self_referencing_initializer.cpp

@@ -0,0 +1,12 @@
+// nondet-result
+
+struct pair {
+  int a;
+  int b;
+};
+
+int main() {
+  int x = x + 1;
+  pair p = {1, p.a + 1};
+  return x + p.b;
+}

tests/unit/out/refcount/self_referencing_initializer.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(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(8)]
+pub struct list_head {
+    #[offset(0)]
+    #[byte_size(8)]
+    pub next: Ptr<list_head>,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(16)]
+pub struct node {
+    #[offset(0)]
+    pub value: i32,
+    #[offset(8)]
+    #[byte_size(8)]
+    pub value_ptr: Ptr<i32>,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[byte_size(16)]
+pub struct node_with_defaults {
+    #[offset(0)]
+    #[byte_size(8)]
+    pub next: Ptr<node_with_defaults>,
+    #[offset(8)]
+    pub value: i32,
+}
+impl Default for node_with_defaults {
+    fn default() -> Self {
+        node_with_defaults {
+            next: Ptr::<node_with_defaults>::null(),
+            value: 3,
+        }
+    }
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let list: Value<list_head> = <Value<list_head>>::default();
+    *list.borrow_mut() = list_head {
+        next: (list.as_pointer()),
+    };
+    assert!(({ { (*list.borrow()).next.clone() } } == { (list.as_pointer()) }));
+    let n: Value<node> = <Value<node>>::default();
+    *n.borrow_mut() = node {
+        value: 42,
+        value_ptr: (field_ptr!(n.as_pointer(), value)),
+    };
+    assert!(({ { (*n.borrow()).value_ptr.clone() } } == { (field_ptr!(n.as_pointer(), value)) }));
+    { (*n.borrow()).value_ptr.clone() }.write(7);
+    assert!(({ (*n.borrow()).value } == 7));
+    let arr: Value<Box<[AnyPtr]>> = Rc::new(RefCell::new(
+        (0..2).map(|_| AnyPtr::default()).collect::<Box<[AnyPtr]>>(),
+    ));
+    *arr.borrow_mut() = Box::new([
+        (((arr.as_pointer() as Ptr<AnyPtr>).offset(1)) as Ptr<AnyPtr>).to_any(),
+        (((arr.as_pointer() as Ptr<AnyPtr>).offset(0)) as Ptr<AnyPtr>).to_any(),
+    ]);
+    assert!(
+        ((*arr.borrow())[(0) as usize]
+            == (((arr.as_pointer() as Ptr<AnyPtr>).offset(1)) as Ptr<AnyPtr>).to_any())
+    );
+    assert!(
+        ((*arr.borrow())[(1) as usize]
+            == (((arr.as_pointer() as Ptr<AnyPtr>).offset(0)) as Ptr<AnyPtr>).to_any())
+    );
+    let p: Value<AnyPtr> = Rc::new(RefCell::new(AnyPtr::default()));
+    *p.borrow_mut() = ((p.as_pointer()) as Ptr<AnyPtr>).to_any();
+    assert!(((*p.borrow()) == ((p.as_pointer()) as Ptr<AnyPtr>).to_any()));
+    let d: Value<node_with_defaults> = <Value<node_with_defaults>>::default();
+    *d.borrow_mut() = node_with_defaults {
+        next: (d.as_pointer()),
+        value: 3,
+    };
+    assert!(({ { (*d.borrow()).next.clone() } } == { (d.as_pointer()) }));
+    assert!(({ (*d.borrow()).value } == 3));
+    let mut heap: Ptr<list_head> =
+        libcc2rs::malloc_refcount(8usize).reinterpret_cast::<list_head>();
+    assert!(!((heap).is_null()));
+    field!(heap, next).write({ (heap).clone() });
+    assert!(({ heap.with(|__s| __s.next.clone()) } == { (heap).clone() }));
+    libcc2rs::free_refcount((heap).to_any());
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/self_referencing_initializer.rs

@@ -0,0 +1,85 @@
+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, VaArg, FnPtrArg, Default)]
+pub struct list_head {
+    pub next: *mut list_head,
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+pub struct node {
+    pub value: i32,
+    pub value_ptr: *mut i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg)]
+pub struct node_with_defaults {
+    pub next: *mut node_with_defaults,
+    pub value: i32,
+}
+impl Default for node_with_defaults {
+    fn default() -> Self {
+        node_with_defaults {
+            next: std::ptr::null_mut(),
+            value: 3,
+        }
+    }
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut list: list_head = <list_head>::default();
+    list = list_head {
+        next: (&mut list as *mut list_head),
+    };
+    assert!(((list.next) == (&mut list as *mut list_head)));
+    let mut n: node = <node>::default();
+    n = node {
+        value: 42,
+        value_ptr: (&mut n.value as *mut i32),
+    };
+    assert!(((n.value_ptr) == (&mut n.value as *mut i32)));
+    (*n.value_ptr) = 7;
+    assert!(((n.value) == (7)));
+    let mut arr: [*mut ::libc::c_void; 2] = [std::ptr::null_mut(); 2];
+    arr = [
+        ((&mut arr[(1) as usize] as *mut *mut ::libc::c_void) as *mut ::libc::c_void),
+        ((&mut arr[(0) as usize] as *mut *mut ::libc::c_void) as *mut ::libc::c_void),
+    ];
+    assert!(
+        ((arr[(0) as usize])
+            == ((&mut arr[(1) as usize] as *mut *mut ::libc::c_void) as *mut ::libc::c_void))
+    );
+    assert!(
+        ((arr[(1) as usize])
+            == ((&mut arr[(0) as usize] as *mut *mut ::libc::c_void) as *mut ::libc::c_void))
+    );
+    let mut p: *mut ::libc::c_void = std::ptr::null_mut();
+    p = ((&mut p as *mut *mut ::libc::c_void) as *mut ::libc::c_void);
+    assert!(((p) == ((&mut p as *mut *mut ::libc::c_void) as *mut ::libc::c_void)));
+    let mut d: node_with_defaults = <node_with_defaults>::default();
+    d = node_with_defaults {
+        next: (&mut d as *mut node_with_defaults),
+        value: 3,
+    };
+    assert!(((d.next) == (&mut d as *mut node_with_defaults)));
+    assert!(((d.value) == (3)));
+    let mut heap: *mut list_head =
+        (libcc2rs::malloc_unsafe(::std::mem::size_of::<list_head>()) as *mut list_head);
+    assert!(!((heap).is_null()));
+    (*heap).next = heap;
+    assert!((((*heap).next) == (heap)));
+    libcc2rs::free_unsafe((heap as *mut ::libc::c_void));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/self_referencing_initializer.cpp

@@ -0,0 +1,42 @@
+#include <cassert>
+#include <cstdlib>
+
+struct list_head {
+  list_head *next;
+};
+
+struct node {
+  int value;
+  int *value_ptr;
+};
+
+struct node_with_defaults {
+  node_with_defaults *next = nullptr;
+  int value = 3;
+};
+
+int main() {
+  list_head list = {&list};
+  assert(list.next == &list);
+
+  node n = {42, &n.value};
+  assert(n.value_ptr == &n.value);
+  *n.value_ptr = 7;
+  assert(n.value == 7);
+
+  list_head arr[2] = {{&arr[1]}, {&arr[0]}};
+  assert(arr[0].next == &arr[1]);
+  assert(arr[1].next == &arr[0]);
+
+  node_with_defaults d{&d};
+  assert(d.next == &d);
+  assert(d.value == 3);
+
+  list_head *heap = static_cast<list_head *>(malloc(sizeof(*heap)));
+  assert(heap != nullptr);
+  heap->next = heap;
+  assert(heap->next == heap);
+  free(heap);
+
+  return 0;
+}