Update tests

Author: lucic71

tests/unit/out/refcount/overload_mangling.rs

@@ -136,6 +136,39 @@ fn main_0() -> i32 {
     assert!(
         (({ SImpl::apply_12(&s.as_pointer(), FnPtr::<fn(i32) -> i32>::new(twice_2), 3,) }) == 106)
     );
+    let c: Value<i32> = Rc::new(RefCell::new(3));
+    assert!(
+        (({
+            let _p: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new((
+                Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+                Rc::new(RefCell::new(2_i64.try_into().expect("failed conversion"))),
+            )));
+            SImpl::combine_13(
+                &s.as_pointer(),
+                _p.as_pointer(),
+                FnPtr::<fn(i32) -> i32>::new(twice_2),
+                (c.as_pointer()),
+                4_u64,
+            )
+        }) == 112)
+    );
+    let z: Value<i32> = Rc::new(RefCell::new(1));
+    assert!(
+        (({
+            let _p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+                Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+                Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+            )));
+            SImpl::combine_14(
+                &s.as_pointer(),
+                _p.as_pointer(),
+                FnPtr::<fn(Ptr<i32>, i32)>::new(add_1),
+                (z.as_pointer()),
+                5_u64,
+            )
+        }) == 107)
+    );
+    assert!(((*z.borrow()) == 6));
     let a: Value<Access_S_> = Rc::new(RefCell::new(<Access_S_>::default()));
     let cs: Value<Ptr<S>> = Rc::new(RefCell::new((s.as_pointer())));
     let cr: Ptr<S> = s.as_pointer();
@@ -186,6 +219,20 @@ pub trait SImpl {
     fn apply_10(&self, f: FnPtr<fn(Ptr<i32>)>, x: i32) -> i32;
     fn apply_11(&self, f: FnPtr<fn(Ptr<i32>, i32)>, x: i32) -> i32;
     fn apply_12(&self, f: FnPtr<fn(i32) -> i32>, x: i32) -> i32;
+    fn combine_13(
+        &self,
+        p: Ptr<(Value<i32>, Value<i64>)>,
+        f: FnPtr<fn(i32) -> i32>,
+        q: Ptr<i32>,
+        n: u64,
+    ) -> i32;
+    fn combine_14(
+        &self,
+        p: Ptr<(Value<i32>, Value<i32>)>,
+        f: FnPtr<fn(Ptr<i32>, i32)>,
+        q: Ptr<i32>,
+        n: u64,
+    ) -> i32;
     fn width_1_char(&self, x: i32) -> i32;
     fn width_1_int(&self, x: i32) -> i32;
     fn scale_2_2(&self, x: i32) -> i32;
@@ -243,6 +290,50 @@ impl SImpl for Ptr<S> {
             _lhs + ({ (*f.borrow()).call((*x.borrow())) })
         };
     }
+    fn combine_13(
+        &self,
+        p: Ptr<(Value<i32>, Value<i64>)>,
+        f: FnPtr<fn(i32) -> i32>,
+        q: Ptr<i32>,
+        n: u64,
+    ) -> i32 {
+        let f: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(f));
+        let q: Value<Ptr<i32>> = Rc::new(RefCell::new(q));
+        let n: Value<u64> = Rc::new(RefCell::new(n));
+        return {
+            let _lhs = {
+                let _lhs = {
+                    let _lhs = (*(*(*self).upgrade().deref()).base.borrow());
+                    _lhs + ((*(*p.upgrade().deref()).1.borrow()) as i32)
+                };
+                _lhs + ({ (*f.borrow()).call(((*q.borrow()).read())) })
+            };
+            _lhs + ((*n.borrow()) as i32)
+        };
+    }
+    fn combine_14(
+        &self,
+        p: Ptr<(Value<i32>, Value<i32>)>,
+        f: FnPtr<fn(Ptr<i32>, i32)>,
+        q: Ptr<i32>,
+        n: u64,
+    ) -> i32 {
+        let f: Value<FnPtr<fn(Ptr<i32>, i32)>> = Rc::new(RefCell::new(f));
+        let q: Value<Ptr<i32>> = Rc::new(RefCell::new(q));
+        let n: Value<u64> = Rc::new(RefCell::new(n));
+        ({
+            let _arg0: Ptr<i32> = (*q.borrow()).clone();
+            let _arg1: i32 = ((*n.borrow()) as i32);
+            (*f.borrow()).call(_arg0, _arg1)
+        });
+        return {
+            let _lhs = {
+                let _lhs = (*(*(*self).upgrade().deref()).base.borrow());
+                _lhs + (*(*p.upgrade().deref()).0.borrow())
+            };
+            _lhs + ((*q.borrow()).read())
+        };
+    }
     fn width_1_char(&self, x: i32) -> i32 {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         return ((*(*(*self).upgrade().deref()).base.borrow())

tests/unit/out/unsafe/overload_mangling.rs

@@ -67,6 +67,29 @@ impl S {
     pub unsafe fn apply_12(&self, mut f: Option<unsafe fn(i32) -> i32>, mut x: i32) -> i32 {
         return ((self.base) + (unsafe { (f).unwrap()(x) }));
     }
+    pub unsafe fn combine_13(
+        &self,
+        p: *const (i32, i64),
+        mut f: Option<unsafe fn(i32) -> i32>,
+        mut q: *const i32,
+        mut n: u64,
+    ) -> i32 {
+        return ((((self.base) + ((*p).1 as i32)) + (unsafe { (f).unwrap()((*q)) })) + (n as i32));
+    }
+    pub unsafe fn combine_14(
+        &self,
+        p: *const (i32, i32),
+        mut f: Option<unsafe fn(*mut i32, i32)>,
+        mut q: *mut i32,
+        mut n: u64,
+    ) -> i32 {
+        (unsafe {
+            let _arg0: *mut i32 = q;
+            let _arg1: i32 = (n as i32);
+            (f).unwrap()(_arg0, _arg1)
+        });
+        return (((self.base) + ((*p).0)) + (*q));
+    }
     pub unsafe fn width_1_char(&self, mut x: i32) -> i32 {
         return ((self.base) + ((x) * (::std::mem::size_of::<libc::c_char>() as i32)));
     }
@@ -120,6 +143,21 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { S::apply_10(&s, Some(inc_0), 1,) }) == (102)));
     assert!(((unsafe { S::apply_11(&s, Some(add_1), 1,) }) == (111)));
     assert!(((unsafe { S::apply_12(&s, Some(twice_2), 3,) }) == (106)));
+    let c: i32 = 3;
+    assert!(
+        ((unsafe {
+            let mut _p: (i32, i64) = (1.into(), 2_i64.into());
+            S::combine_13(&s, &mut _p, Some(twice_2), (&c as *const i32), 4_u64)
+        }) == (112))
+    );
+    let mut z: i32 = 1;
+    assert!(
+        ((unsafe {
+            let mut _p: (i32, i32) = (1.into(), 2.into());
+            S::combine_14(&s, &mut _p, Some(add_1), (&mut z as *mut i32), 5_u64)
+        }) == (107))
+    );
+    assert!(((z) == (6)));
     let mut a: Access_S_ = <Access_S_>::default();
     let mut cs: *const S = (&mut s as *mut S).cast_const();
     let cr: *const S = &s;

tests/unit/overload_mangling.cpp

@@ -36,6 +36,15 @@ struct S {
     return base + x;
   }
   int apply(int (*f)(int), int x) const { return base + f(x); }
+  int combine(const std::pair<int, long> &p, int (*f)(int), const int *q,
+              unsigned long n) const {
+    return base + (int)p.second + f(*q) + (int)n;
+  }
+  int combine(const std::pair<int, int> &p, void (*f)(int *, int), int *q,
+              unsigned long n) const {
+    f(q, (int)n);
+    return base + p.first + *q;
+  }
 };
 
 struct Box {
@@ -60,6 +69,11 @@ int main() {
   assert(s.apply(inc, 1) == 102);
   assert(s.apply(add, 1) == 111);
   assert(s.apply(twice, 3) == 106);
+  const int c = 3;
+  assert(s.combine(std::pair<int, long>(1, 2L), twice, &c, 4UL) == 112);
+  int z = 1;
+  assert(s.combine(std::pair<int, int>(1, 2), add, &z, 5UL) == 107);
+  assert(z == 6);
   Access<S> a;
   const S *cs = &s;
   const S &cr = s;