Update tests

Author: lucic71

tests/unit/implicit_autoref.cpp

@@ -1,36 +1,29 @@
 #include <cassert>
-
-struct Counter {
-  int value = 0;
-  void bump() { ++value; }
-  int get() const { return value; }
-};
+#include <vector>
 
 struct Holder {
-  Counter c;
-  Counter &ref;
-  Holder(Counter &c) : ref(c) {}
+  std::vector<int> v;
 };
 
-void via_ref(Counter &r) { r.bump(); }
-
 int main() {
-  Counter c;
-  Counter *p = &c;
-  (*p).bump();
-  p->bump();
-
-  Counter arr[2];
-  arr[0].bump();
-  arr[1].bump();
-
-  Holder h(c);
-  h.c.bump();
-  h.ref.bump();
-
-  via_ref(c);
-
-  int sum = (*p).get() + h.c.get() + h.ref.get() + arr[0].get() + arr[1].get();
-  assert(sum == 11);
+  std::vector<int> v;
+  v.push_back(10);
+  v.push_back(20);
+
+  std::vector<int> *p = &v;
+  int a = (*p)[0];
+  (*p)[1] = 30;
+
+  Holder h;
+  h.v.push_back(40);
+  h.v.push_back(50);
+  Holder *hp = &h;
+  int b = (*hp).v[0];
+  (*hp).v[1] = 60;
+
+  assert(a == 10);
+  assert((*p)[1] == 30);
+  assert(b == 40);
+  assert((*hp).v[1] == 60);
   return 0;
 }

tests/unit/out/refcount/implicit_autoref.rs

@@ -7,88 +7,59 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 #[derive(Default)]
-pub struct Counter {
-    pub value: Value<i32>,
-}
-impl Counter {
-    pub fn bump(&self) {
-        (*self.value.borrow_mut()).prefix_inc();
-    }
-    pub fn get(&self) -> i32 {
-        return (*self.value.borrow());
-    }
-}
-impl Clone for Counter {
-    fn clone(&self) -> Self {
-        let mut this = Self {
-            value: Rc::new(RefCell::new((*self.value.borrow()))),
-        };
-        this
-    }
-}
-impl ByteRepr for Counter {}
-#[derive(Default)]
 pub struct Holder {
-    pub c: Value<Counter>,
-    pub ref_: Ptr<Counter>,
-}
-impl Holder {
-    pub fn Holder(c: Ptr<Counter>) -> Self {
-        let mut this = Self {
-            c: Rc::new(RefCell::new(<Counter>::default())),
-            ref_: (c).clone(),
-        };
-        this
-    }
+    pub v: Value<Vec<i32>>,
 }
 impl Clone for Holder {
     fn clone(&self) -> Self {
         let mut this = Self {
-            c: Rc::new(RefCell::new((*self.c.borrow()).clone())),
-            ref_: (self.ref_).clone(),
+            v: Rc::new(RefCell::new((*self.v.borrow()).clone())),
         };
         this
     }
 }
 impl ByteRepr for Holder {}
-pub fn via_ref_0(r: Ptr<Counter>) {
-    ({ (*r.upgrade().deref()).bump() });
-}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let c: Value<Counter> = Rc::new(RefCell::new(<Counter>::default()));
-    let p: Value<Ptr<Counter>> = Rc::new(RefCell::new((c.as_pointer())));
-    ({ (*(*p.borrow()).upgrade().deref()).bump() });
-    ({ (*(*p.borrow()).upgrade().deref()).bump() });
-    let arr: Value<Box<[Counter]>> = Rc::new(RefCell::new(
-        (0..2)
-            .map(|_| <Counter>::default())
-            .collect::<Box<[Counter]>>(),
+    let v: Value<Vec<i32>> = Rc::new(RefCell::new(Vec::new()));
+    (*v.borrow_mut()).push(10);
+    (*v.borrow_mut()).push(20);
+    let p: Value<Ptr<Vec<i32>>> = Rc::new(RefCell::new((v.as_pointer())));
+    let a: Value<i32> = Rc::new(RefCell::new(
+        ((((*p.borrow()).to_strong().as_pointer()) as Ptr<i32>)
+            .offset(0_u64 as isize)
+            .read()),
     ));
-    ({ (*arr.borrow())[(0) as usize].bump() });
-    ({ (*arr.borrow())[(1) as usize].bump() });
-    let h: Value<Holder> = Rc::new(RefCell::new(Holder::Holder(c.as_pointer())));
-    ({ (*(*h.borrow()).c.borrow()).bump() });
-    ({ (*(*h.borrow()).ref_.upgrade().deref()).bump() });
-    ({
-        let _r: Ptr<Counter> = c.as_pointer();
-        via_ref_0(_r)
-    });
-    let sum: Value<i32> = Rc::new(RefCell::new({
-        let _lhs = {
-            let _lhs = {
-                let _lhs = {
-                    let _lhs = ({ (*(*p.borrow()).upgrade().deref()).get() });
-                    _lhs + ({ (*(*h.borrow()).c.borrow()).get() })
-                };
-                _lhs + ({ (*(*h.borrow()).ref_.upgrade().deref()).get() })
-            };
-            _lhs + ({ (*arr.borrow())[(0) as usize].get() })
-        };
-        _lhs + ({ (*arr.borrow())[(1) as usize].get() })
-    }));
-    println!("{}", (*sum.borrow()));
+    (((*p.borrow()).to_strong().as_pointer()) as Ptr<i32>)
+        .offset(1_u64 as isize)
+        .write(30);
+    let h: Value<Holder> = Rc::new(RefCell::new(<Holder>::default()));
+    (*(*h.borrow()).v.borrow_mut()).push(40);
+    (*(*h.borrow()).v.borrow_mut()).push(50);
+    let hp: Value<Ptr<Holder>> = Rc::new(RefCell::new((h.as_pointer())));
+    let b: Value<i32> = Rc::new(RefCell::new(
+        (((*(*hp.borrow()).upgrade().deref()).v.as_pointer() as Ptr<i32>)
+            .offset(0_u64 as isize)
+            .read()),
+    ));
+    ((*(*hp.borrow()).upgrade().deref()).v.as_pointer() as Ptr<i32>)
+        .offset(1_u64 as isize)
+        .write(60);
+    assert!(((*a.borrow()) == 10));
+    assert!(
+        (((((*p.borrow()).to_strong().as_pointer()) as Ptr<i32>)
+            .offset(1_u64 as isize)
+            .read())
+            == 30)
+    );
+    assert!(((*b.borrow()) == 40));
+    assert!(
+        ((((*(*hp.borrow()).upgrade().deref()).v.as_pointer() as Ptr<i32>)
+            .offset(1_u64 as isize)
+            .read())
+            == 60)
+    );
     return 0;
 }

tests/unit/out/unsafe/implicit_autoref.rs

@@ -7,60 +7,31 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, Default)]
-pub struct Counter {
-    pub value: i32,
-}
-impl Counter {
-    pub unsafe fn bump(&mut self) {
-        self.value.prefix_inc();
-    }
-    pub unsafe fn get(&self) -> i32 {
-        return self.value;
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone, Default)]
+#[derive(Clone, Default)]
 pub struct Holder {
-    pub c: Counter,
-    pub ref_: *mut Counter,
-}
-impl Holder {
-    pub unsafe fn Holder(c: *mut Counter) -> Self {
-        let mut this = Self {
-            c: <Counter>::default(),
-            ref_: c,
-        };
-        this
-    }
-}
-pub unsafe fn via_ref_0(r: *mut Counter) {
-    (unsafe { (*r).bump() });
+    pub v: Vec<i32>,
 }
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut c: Counter = <Counter>::default();
-    let mut p: *mut Counter = (&mut c as *mut Counter);
-    (unsafe { (*p).bump() });
-    (unsafe { (*p).bump() });
-    let mut arr: [Counter; 2] = [<Counter>::default(); 2];
-    (unsafe { arr[(0) as usize].bump() });
-    (unsafe { arr[(1) as usize].bump() });
-    let mut h: Holder = Holder::Holder(&mut c as *mut Counter);
-    (unsafe { h.c.bump() });
-    (unsafe { (*h.ref_).bump() });
-    (unsafe {
-        let _r: *mut Counter = &mut c as *mut Counter;
-        via_ref_0(_r)
-    });
-    let mut sum: i32 = (((((unsafe { (*p).get() }) + (unsafe { h.c.get() }))
-        + (unsafe { (*h.ref_).get() }))
-        + (unsafe { arr[(0) as usize].get() }))
-        + (unsafe { arr[(1) as usize].get() }));
-    printf(b"%d\n\0".as_ptr() as *const i8, sum);
+    let mut v: Vec<i32> = Vec::new();
+    v.push(10);
+    v.push(20);
+    let mut p: *mut Vec<i32> = (&mut v as *mut Vec<i32>);
+    let mut a: i32 = (&mut (*p))[(0_u64) as usize];
+    (&mut (*p))[(1_u64) as usize] = 30;
+    let mut h: Holder = <Holder>::default();
+    h.v.push(40);
+    h.v.push(50);
+    let mut hp: *mut Holder = (&mut h as *mut Holder);
+    let mut b: i32 = (&mut (*hp)).v[(0_u64) as usize];
+    (&mut (*hp)).v[(1_u64) as usize] = 60;
+    assert!(((a) == (10)));
+    assert!((((&mut (*p))[(1_u64) as usize]) == (30)));
+    assert!(((b) == (40)));
+    assert!((((&mut (*hp)).v[(1_u64) as usize]) == (60)));
     return 0;
 }