Update tests

Author: lucic71

tests/ub/out/refcount/self_referencing_initializer.rs

@@ -23,9 +23,6 @@ fn main_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()) });
+    return (x + p.b);
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/unsafe/self_referencing_initializer.rs

@@ -26,9 +26,6 @@ unsafe fn main_0() -> i32 {
         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));
+    return ((x) + (p.b));
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/self_referencing_initializer.rs

@@ -57,37 +57,38 @@ fn main_0() -> i32 {
     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]>>(),
+    let arr: Value<Box<[list_head]>> = Rc::new(RefCell::new(
+        (0..2)
+            .map(|_| <list_head>::default())
+            .collect::<Box<[list_head]>>(),
     ));
     *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(),
+        list_head {
+            next: ((arr.as_pointer() as Ptr<list_head>).offset(1)),
+        },
+        list_head {
+            next: ((arr.as_pointer() as Ptr<list_head>).offset(0)),
+        },
     ]);
     assert!(
-        ((*arr.borrow())[(0) as usize]
-            == (((arr.as_pointer() as Ptr<AnyPtr>).offset(1)) as Ptr<AnyPtr>).to_any())
+        ({ { (*arr.borrow())[(0) as usize].next.clone() } } == {
+            ((arr.as_pointer() as Ptr<list_head>).offset(1))
+        })
     );
     assert!(
-        ((*arr.borrow())[(1) as usize]
-            == (((arr.as_pointer() as Ptr<AnyPtr>).offset(0)) as Ptr<AnyPtr>).to_any())
+        ({ { (*arr.borrow())[(1) as usize].next.clone() } } == {
+            ((arr.as_pointer() as Ptr<list_head>).offset(0))
+        })
     );
-    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());
+    let mut size: usize = ::std::mem::size_of::<usize>();
+    assert!((size == ::std::mem::size_of::<usize>()));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/self_referencing_initializer.rs

@@ -51,35 +51,26 @@ unsafe fn main_0() -> 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];
+    let mut arr: [list_head; 2] = [<list_head>::default(); 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),
+        list_head {
+            next: (&mut arr[(1) as usize] as *mut list_head),
+        },
+        list_head {
+            next: (&mut arr[(0) as usize] as *mut list_head),
+        },
     ];
-    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)));
+    assert!(((arr[(0) as usize].next) == (&mut arr[(1) as usize] as *mut list_head)));
+    assert!(((arr[(1) as usize].next) == (&mut arr[(0) as usize] as *mut list_head)));
     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));
+    let mut size: usize = ::std::mem::size_of::<usize>();
+    assert!(((size) == (::std::mem::size_of::<usize>())));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/self_referencing_initializer.cpp

@@ -1,5 +1,5 @@
 #include <cassert>
-#include <cstdlib>
+#include <cstddef>
 
 struct list_head {
   list_head *next;
@@ -32,11 +32,8 @@ int main() {
   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);
+  size_t size = sizeof(size);
+  assert(size == sizeof(size_t));
 
   return 0;
 }