Update tests

Author: lucic71

tests/unit/default_function_arguments.cpp

@@ -4,6 +4,11 @@ int foo(int a, int b = 10) { return a + b; }
 
 bool baz(int *a, int *b = nullptr) { return a == b; }
 
+struct Bar {
+  int v;
+  Bar(int v = 1) : v(v) {}
+};
+
 int main() {
   assert(foo(1) == 11);
   assert(foo(1, 2) == 3);
@@ -12,5 +17,13 @@ int main() {
   assert(baz(&a) == false);
   assert(baz(&a, &a) == true);
 
+  Bar b;
+  assert(b.v == 1);
+  assert(Bar(2).v == 2);
+
+  Bar arr[3] = {};
+  assert(arr[0].v == 1);
+  assert(arr[2].v == 1);
+
   return 0;
 }

tests/unit/out/refcount/default_function_arguments.rs

@@ -19,6 +19,47 @@ pub fn baz_1(a: Ptr<i32>, b: Option<Ptr<i32>>) -> bool {
         _lhs == (*b.borrow()).clone()
     };
 }
+#[derive()]
+pub struct Bar {
+    pub v: Value<i32>,
+}
+impl Bar {
+    pub fn Bar(v: Option<i32>) -> Self {
+        let v: Value<i32> = Rc::new(RefCell::new(v.unwrap_or(1)));
+        let __this: Value<Bar> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*v.borrow()))),
+        }));
+        let this: Ptr<Bar> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for Bar {
+    fn clone(&self) -> Self {
+        let __this: Value<Bar> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<Bar> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Default for Bar {
+    fn default() -> Self {
+        { Bar::Bar(None) }
+    }
+}
+impl ByteRepr for Bar {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -35,5 +76,15 @@ fn main_0() -> i32 {
         }) as i32)
             == (true as i32))
     );
+    let b: Value<Bar> = Rc::new(RefCell::new(Bar::Bar({ Some() })));
+    assert!(((*(*b.borrow()).v.borrow()) == 1));
+    assert!(((*Bar::Bar({ Some(2) },).v.borrow()) == 2));
+    let arr: Value<Box<[Bar]>> = Rc::new(RefCell::new(Box::new([
+        Bar::Bar({ Some() }),
+        Bar::Bar({ Some() }),
+        Bar::Bar({ Some() }),
+    ])));
+    assert!(((*(*arr.borrow())[(0) as usize].v.borrow()) == 1));
+    assert!(((*(*arr.borrow())[(2) as usize].v.borrow()) == 1));
     return 0;
 }

tests/unit/out/unsafe/default_function_arguments.rs

@@ -14,6 +14,23 @@ pub unsafe fn baz_1(mut a: *mut i32, mut b: Option<*mut i32>) -> bool {
     let mut b: *mut i32 = b.unwrap_or(std::ptr::null_mut());
     return ((a) == (b));
 }
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Bar {
+    pub v: i32,
+}
+impl Bar {
+    pub unsafe fn Bar(mut v: Option<i32>) -> Self {
+        let mut v: i32 = v.unwrap_or(1);
+        let mut this = Self { v: v };
+        this
+    }
+}
+impl Default for Bar {
+    fn default() -> Self {
+        unsafe { Bar::Bar(None) }
+    }
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -32,5 +49,15 @@ unsafe fn main_0() -> i32 {
         }) as i32)
             == (true as i32))
     );
+    let mut b: Bar = Bar::Bar({ Some() });
+    assert!(((b.v) == (1)));
+    assert!(((Bar::Bar({ Some(2) },).v) == (2)));
+    let mut arr: [Bar; 3] = [
+        Bar::Bar({ Some() }),
+        Bar::Bar({ Some() }),
+        Bar::Bar({ Some() }),
+    ];
+    assert!(((arr[(0) as usize].v) == (1)));
+    assert!(((arr[(2) as usize].v) == (1)));
     return 0;
 }