Update tests

Author: lucic71

tests/ub/out/refcount/ctor_ref_member.rs

@@ -23,10 +23,10 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S::new({
+    let s: Value<S> = Rc::new(RefCell::new({
         let __tmp_0: Value<i32> = Rc::new(RefCell::new(5));
-        __tmp_0.as_pointer()
-    })));
+        S::new({ __tmp_0.as_pointer() })
+    }));
     assert!((((*s.borrow()).r.read()) == 5));
     return 0;
 }

tests/ub/out/unsafe/ctor_ref_member.rs

@@ -24,10 +24,10 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S::new({
+    let mut s: S = {
         let mut __tmp_0: i32 = 5;
-        &mut __tmp_0
-    });
+        S::new({ &mut __tmp_0 })
+    };
     assert!(((*s.r) == (5)));
     return 0;
 }

tests/unit/out/refcount/copy_move_defaulted.rs

@@ -603,10 +603,9 @@ fn main_0() -> i32 {
     let bufs: Value<Vec<Buffer>> = Rc::new(RefCell::new(Vec::new()));
     (*bufs.borrow_mut()).push(Buffer::Buffer_pmutBuffer_rv({ r.as_pointer() }));
     {
-        let __arg =
+        let __init =
             Buffer::Buffer_pmutBuffer_rv({ (bufs.as_pointer() as Ptr<Buffer>).offset(0_usize) });
-        bufs.as_pointer()
-            .with_mut(|__v: &mut Vec<Buffer>| __v.push(__arg))
+        (*bufs.borrow_mut()).push(__init)
     };
     assert!(
         (((*(*(bufs.as_pointer() as Ptr<Buffer>)

tests/unit/out/refcount/push_emplace_back.rs

@@ -190,15 +190,15 @@ pub struct Pair {
     pub second: Value<i32>,
 }
 impl Pair {
-    pub fn Pair1() -> Self {
+    pub fn new_1() -> Self {
         let __this: Value<Pair> = Rc::new(RefCell::new(Self {
             first: Rc::new(RefCell::new(-1_i32)),
             second: Rc::new(RefCell::new(-1_i32)),
         }));
         let this: Ptr<Pair> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Pair2(a: i32) -> Self {
+    pub fn new_2(a: i32) -> Self {
         let a: Value<i32> = Rc::new(RefCell::new(a));
         let __this: Value<Pair> = Rc::new(RefCell::new(Self {
             first: Rc::new(RefCell::new((*a.borrow()))),
@@ -207,7 +207,7 @@ impl Pair {
         let this: Ptr<Pair> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Pair3(a: i32, b: i32) -> Self {
+    pub fn new_3(a: i32, b: i32) -> Self {
         let a: Value<i32> = Rc::new(RefCell::new(a));
         let b: Value<i32> = Rc::new(RefCell::new(b));
         let __this: Value<Pair> = Rc::new(RefCell::new(Self {
@@ -230,7 +230,7 @@ impl Clone for Pair {
 }
 impl Default for Pair {
     fn default() -> Self {
-        { Pair::Pair1() }
+        { Pair::new_1() }
     }
 }
 impl ByteRepr for Pair {
@@ -251,26 +251,26 @@ impl ByteRepr for Pair {
 pub fn emplace_ctor_args_7(pairs: Ptr<Vec<Pair>>) {
     let pairs: Value<Ptr<Vec<Pair>>> = Rc::new(RefCell::new(pairs));
     {
-        let __init = Pair::Pair1();
+        let __init = Pair::new_1();
         (*pairs.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
-        let __init = Pair::Pair2({ 3 });
+        let __init = Pair::new_2({ 3 });
         (*pairs.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
-        let __init = Pair::Pair3({ 4 }, { 5 });
+        let __init = Pair::new_3({ 4 }, { 5 });
         (*pairs.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
 }
 pub fn emplace_deque_8(queue: Ptr<Vec<Pair>>) {
     let queue: Value<Ptr<Vec<Pair>>> = Rc::new(RefCell::new(queue));
     {
-        let __init = Pair::Pair3({ 6 }, { 7 });
+        let __init = Pair::new_3({ 6 }, { 7 });
         (*queue.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
-        let __init = Pair::Pair1();
+        let __init = Pair::new_1();
         (*queue.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
 }

tests/unit/out/unsafe/copy_move_defaulted.rs

@@ -367,8 +367,8 @@ unsafe fn main_0() -> i32 {
     let mut bufs: Vec<Buffer> = Vec::new();
     bufs.push(Buffer::Buffer_pmutBuffer_rv({ &mut r }));
     {
-        let __arg = Buffer::Buffer_pmutBuffer_rv({ &mut bufs[(0_usize)] });
-        bufs.push(__arg)
+        let __init = Buffer::Buffer_pmutBuffer_rv({ &mut bufs[(0_usize)] });
+        bufs.push(__init)
     };
     assert!(
         (((bufs[(1_usize)].n) == (3)) && ((bufs[(1_usize)].data.len()) == (3_usize)))

tests/unit/out/unsafe/push_emplace_back.rs

@@ -88,21 +88,21 @@ pub struct Pair {
     pub second: i32,
 }
 impl Pair {
-    pub unsafe fn Pair1() -> Self {
+    pub unsafe fn new_1() -> Self {
         let mut this = Self {
             first: -1_i32,
             second: -1_i32,
         };
         this
     }
-    pub unsafe fn Pair2(mut a: i32) -> Self {
+    pub unsafe fn new_2(mut a: i32) -> Self {
         let mut this = Self {
             first: a,
             second: 0,
         };
         this
     }
-    pub unsafe fn Pair3(mut a: i32, mut b: i32) -> Self {
+    pub unsafe fn new_3(mut a: i32, mut b: i32) -> Self {
         let mut this = Self {
             first: a,
             second: ((b) * (2)),
@@ -112,30 +112,30 @@ impl Pair {
 }
 impl Default for Pair {
     fn default() -> Self {
-        unsafe { Pair::Pair1() }
+        unsafe { Pair::new_1() }
     }
 }
 pub unsafe fn emplace_ctor_args_7(mut pairs: *mut Vec<Pair>) {
     {
-        let __init = Pair::Pair1();
+        let __init = Pair::new_1();
         (*pairs).push(__init)
     };
     {
-        let __init = Pair::Pair2({ 3 });
+        let __init = Pair::new_2({ 3 });
         (*pairs).push(__init)
     };
     {
-        let __init = Pair::Pair3({ 4 }, { 5 });
+        let __init = Pair::new_3({ 4 }, { 5 });
         (*pairs).push(__init)
     };
 }
 pub unsafe fn emplace_deque_8(mut queue: *mut Vec<Pair>) {
     {
-        let __init = Pair::Pair3({ 6 }, { 7 });
+        let __init = Pair::new_3({ 6 }, { 7 });
         (*queue).push(__init)
     };
     {
-        let __init = Pair::Pair1();
+        let __init = Pair::new_1();
         (*queue).push(__init)
     };
 }