Update tests

Author: lucic71

tests/unit/out/refcount/lambda_basic.rs

@@ -50,6 +50,25 @@ fn main_0() -> i32 {
         }),
     ));
     assert!((({ (*constants.borrow()).call(1,) }) == 8));
+    let n: Value<i32> = Rc::new(RefCell::new(((*k.borrow()) + (*m.borrow()))));
+    let derived: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        FnPtr::<fn(i32) -> i32>::new(|x: i32| -> i32 {
+            {
+                let x: Value<i32> = Rc::new(RefCell::new(x));
+                return ((*x.borrow()) + (3 + 4));
+            }
+        }),
+    ));
+    assert!((({ (*derived.borrow()).call(1,) }) == 8));
+    let implicit: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        FnPtr::<fn(i32) -> i32>::new(|x: i32| -> i32 {
+            {
+                let x: Value<i32> = Rc::new(RefCell::new(x));
+                return ((*x.borrow()) + 3);
+            }
+        }),
+    ));
+    assert!((({ (*implicit.borrow()).call(1,) }) == 4));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/lambda_capture_value.rs

@@ -14,6 +14,9 @@ pub struct S {
     #[offset(4)]
     pub y: i32,
 }
+pub fn read_0(v: Ptr<i32>) -> i32 {
+    return (v.read());
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -66,6 +69,47 @@ fn main_0() -> i32 {
         }
     )));
     assert!((({ (*shifted.borrow()).call(5,) }) == 16));
+    let k: Value<i32> = Rc::new(RefCell::new(3));
+    let by_copy: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let k: Value<i32> = Rc::new(RefCell::new((*k.borrow())));
+        },
+        |x: i32| -> i32 {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            return ((*x.borrow()) + 3);
+        }
+    )));
+    assert!((({ (*by_copy.borrow()).call(1,) }) == 4));
+    let by_copy_used: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let k: Value<i32> = Rc::new(RefCell::new((*k.borrow())));
+        },
+        |x: i32| -> i32 {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            return ((*x.borrow()) + ({ read_0(k.as_pointer()) }));
+        }
+    )));
+    assert!((({ (*by_copy_used.borrow()).call(1,) }) == 4));
+    let implicit_used: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let k: Value<i32> = Rc::new(RefCell::new((*k.borrow())));
+        },
+        |x: i32| -> i32 {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            return ((*x.borrow()) + ({ read_0(k.as_pointer()) }));
+        }
+    )));
+    assert!((({ (*implicit_used.borrow()).call(1,) }) == 4));
+    let by_ref: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let k: Ptr<i32> = k.as_pointer();
+        },
+        |x: i32| -> i32 {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            return ((*x.borrow()) + 3);
+        }
+    )));
+    assert!((({ (*by_ref.borrow()).call(1,) }) == 4));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/lambda_basic.rs

@@ -40,6 +40,19 @@ unsafe fn main_0() -> i32 {
         }
     });
     assert!(((unsafe { constants.call(1,) }) == (8)));
+    let n: i32 = ((k) + (m));
+    let mut derived: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|x: i32| -> i32 {
+        unsafe {
+            return ((x) + ((3) + (4)));
+        }
+    });
+    assert!(((unsafe { derived.call(1,) }) == (8)));
+    let mut implicit: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|x: i32| -> i32 {
+        unsafe {
+            return ((x) + (3));
+        }
+    });
+    assert!(((unsafe { implicit.call(1,) }) == (4)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/lambda_capture_value.rs

@@ -12,6 +12,9 @@ pub struct S {
     pub x: i32,
     pub y: i32,
 }
+pub unsafe fn read_0(v: *const i32) -> i32 {
+    return (*v);
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -64,6 +67,43 @@ unsafe fn main_0() -> i32 {
         }
     );
     assert!(((unsafe { shifted.call(5,) }) == (16)));
+    let k: i32 = 3;
+    let mut by_copy: FnPtr<fn(i32) -> i32> = lambda_unsafe!(
+        {
+            let k: i32 = k;
+        },
+        |x: i32| -> i32 {
+            return ((x) + (3));
+        }
+    );
+    assert!(((unsafe { by_copy.call(1,) }) == (4)));
+    let mut by_copy_used: FnPtr<fn(i32) -> i32> = lambda_unsafe!(
+        {
+            let k: i32 = k;
+        },
+        |x: i32| -> i32 {
+            return ((x) + (unsafe { read_0(&k) }));
+        }
+    );
+    assert!(((unsafe { by_copy_used.call(1,) }) == (4)));
+    let mut implicit_used: FnPtr<fn(i32) -> i32> = lambda_unsafe!(
+        {
+            let k: i32 = k;
+        },
+        |x: i32| -> i32 {
+            return ((x) + (unsafe { read_0(&k) }));
+        }
+    );
+    assert!(((unsafe { implicit_used.call(1,) }) == (4)));
+    let mut by_ref: FnPtr<fn(i32) -> i32> = lambda_unsafe!(
+        {
+            let k: *const i32 = &k;
+        },
+        |x: i32| -> i32 {
+            return ((x) + (3));
+        }
+    );
+    assert!(((unsafe { by_ref.call(1,) }) == (4)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}