Update tests

Author: lucic71

tests/unit/constexpr_function.cpp

@@ -13,6 +13,21 @@ constexpr int scaled(int x) {
 
 constexpr double half(double x) { return x / 2.0; }
 
+struct Flag {
+  int v;
+  constexpr explicit operator bool() const { return v != 0; }
+};
+
+constexpr int use(Flag f) {
+  assert(f);
+  return f.v;
+}
+
+constexpr int checked(int x) {
+  assert(x > 0);
+  return x + 1;
+}
+
 struct P {
   int v;
   constexpr int get() const { return v; }
@@ -25,6 +40,14 @@ int main() {
   assert(scaled(3) == 3);
   assert(scaled(-3) == 6);
   assert(half(5.0) == 2.5);
+  assert(checked(1) == 2);
+  constexpr int c = checked(4);
+  assert(c == 5);
+  assert(use(Flag{2}) == 2);
+  constexpr int u = use(Flag{3});
+  assert(u == 3);
+  int *ptr = arr;
+  assert(ptr);
   P p{9};
   assert(p.get() == 9);
   constexpr int k = scaled(4);

tests/unit/operator_other_member.cpp

@@ -30,7 +30,9 @@ int main() {
     assert(false);
   }
   S z{0};
+  assert(s);
   assert(!z);
+  assert(s && !z);
   Static st;
   assert(st(6, 7) == 42);
   return 0;

tests/unit/out/refcount/constexpr_function.rs

@@ -26,6 +26,42 @@ pub fn half_3(x: f64) -> f64 {
     return ((*x.borrow()) / 2.0E+0);
 }
 #[derive(Default)]
+pub struct Flag {
+    pub v: Value<i32>,
+}
+impl Clone for Flag {
+    fn clone(&self) -> Self {
+        let __this: Value<Flag> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<Flag> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Flag {
+    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 use_4(f: Flag) -> i32 {
+    let f: Value<Flag> = Rc::new(RefCell::new(f));
+    assert!(({ FlagImpl::operator__Bool(&f.as_pointer(),) }));
+    return (*(*f.borrow()).v.borrow());
+}
+pub fn checked_5(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    assert!(((*x.borrow()) > 0));
+    return ((*x.borrow()) + 1);
+}
+#[derive(Default)]
 pub struct P {
     pub v: Value<i32>,
 }
@@ -62,6 +98,26 @@ fn main_0() -> i32 {
     assert!((({ scaled_2(3,) }) == 3));
     assert!((({ scaled_2(-3_i32,) }) == 6));
     assert!((({ half_3(5.0E+0,) }) == 2.5E+0));
+    assert!((({ checked_5(1,) }) == 2));
+    let c: Value<i32> = Rc::new(RefCell::new(({ checked_5(4) })));
+    assert!(((*c.borrow()) == 5));
+    assert!(
+        (({
+            use_4(Flag {
+                v: Rc::new(RefCell::new(2)),
+            })
+        }) == 2)
+    );
+    let u: Value<i32> = Rc::new(RefCell::new(
+        ({
+            use_4(Flag {
+                v: Rc::new(RefCell::new(3)),
+            })
+        }),
+    ));
+    assert!(((*u.borrow()) == 3));
+    let ptr: Value<Ptr<i32>> = Rc::new(RefCell::new((arr.as_pointer() as Ptr<i32>)));
+    assert!(!(*ptr.borrow()).is_null());
     let p: Value<P> = Rc::new(RefCell::new(P {
         v: Rc::new(RefCell::new(9)),
     }));
@@ -70,6 +126,14 @@ fn main_0() -> i32 {
     assert!(((*k.borrow()) == 4));
     return 0;
 }
+pub trait FlagImpl {
+    fn operator__Bool(&self) -> bool;
+}
+impl FlagImpl for Ptr<Flag> {
+    fn operator__Bool(&self) -> bool {
+        return ((*(*(*self).upgrade().deref()).v.borrow()) != 0);
+    }
+}
 pub trait PImpl {
     fn get(&self) -> i32;
 }

tests/unit/out/refcount/operator_other_member.rs

@@ -72,7 +72,12 @@ fn main_0() -> i32 {
     let z: Value<S> = Rc::new(RefCell::new(S {
         v: Rc::new(RefCell::new(0)),
     }));
+    assert!(({ SImpl::operator__Bool(&s.as_pointer(),) }));
     assert!(!({ SImpl::operator__Bool(&z.as_pointer(),) }));
+    assert!(
+        ({ SImpl::operator__Bool(&s.as_pointer(),) })
+            && (!({ SImpl::operator__Bool(&z.as_pointer(),) }))
+    );
     let st: Value<Static> = Rc::new(RefCell::new(<Static>::default()));
     assert!((({ Static::operator_call(6, 7,) }) == 42));
     return 0;

tests/unit/out/unsafe/constexpr_function.rs

@@ -23,6 +23,24 @@ pub unsafe fn half_3(mut x: f64) -> f64 {
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
+pub struct Flag {
+    pub v: i32,
+}
+impl Flag {
+    pub unsafe fn operator__Bool(&self) -> bool {
+        return ((self.v) != (0));
+    }
+}
+pub unsafe fn use_4(mut f: Flag) -> i32 {
+    assert!((unsafe { Flag::operator__Bool(&f,) }));
+    return f.v;
+}
+pub unsafe fn checked_5(mut x: i32) -> i32 {
+    assert!(((x) > (0)));
+    return ((x) + (1));
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
 pub struct P {
     pub v: i32,
 }
@@ -44,6 +62,14 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { scaled_2(3,) }) == (3)));
     assert!(((unsafe { scaled_2(-3_i32,) }) == (6)));
     assert!(((unsafe { half_3(5.0E+0,) }) == (2.5E+0)));
+    assert!(((unsafe { checked_5(1,) }) == (2)));
+    let c: i32 = (unsafe { checked_5(4) });
+    assert!(((c) == (5)));
+    assert!(((unsafe { use_4(Flag { v: 2 },) }) == (2)));
+    let u: i32 = (unsafe { use_4(Flag { v: 3 }) });
+    assert!(((u) == (3)));
+    let mut ptr: *mut i32 = arr.as_mut_ptr();
+    assert!(!(ptr).is_null());
     let mut p: P = P { v: 9 };
     assert!(((unsafe { P::get(&p,) }) == (9)));
     let k: i32 = (unsafe { scaled_2(4) });

tests/unit/out/unsafe/operator_other_member.rs

@@ -63,7 +63,9 @@ unsafe fn main_0() -> i32 {
         assert!(false);
     }
     let mut z: S = S { v: 0 };
+    assert!((unsafe { S::operator__Bool(&s,) }));
     assert!(!(unsafe { S::operator__Bool(&z,) }));
+    assert!((unsafe { S::operator__Bool(&s,) }) && (!(unsafe { S::operator__Bool(&z,) })));
     let mut st: Static = <Static>::default();
     assert!(((unsafe { Static::operator_call(6, 7,) }) == (42)));
     return 0;