Add expected output for fn_ptr tests

Author: lucic71

tests/unit/out/refcount/fn_ptr.rs

@@ -0,0 +1,48 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn my_foo_0(p: AnyPtr) -> i32 {
+    let p: Value<AnyPtr> = Rc::new(RefCell::new(p));
+    return ((*p.borrow()).cast::<i32>().expect("ub:wrong type").read());
+}
+pub fn foo_1(fn_: FnPtr<fn(AnyPtr) -> i32>, pi: Ptr<i32>) -> i32 {
+    let fn_: Value<FnPtr<fn(AnyPtr) -> i32>> = Rc::new(RefCell::new(fn_));
+    let pi: Value<Ptr<i32>> = Rc::new(RefCell::new(pi));
+    return ({
+        let _arg0: AnyPtr = ((*pi.borrow()).clone() as Ptr<i32>).to_any();
+        (*(*fn_.borrow()))(_arg0)
+    });
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let fn_: Value<FnPtr<fn(AnyPtr) -> i32>> = Rc::new(RefCell::new(FnPtr::null()));
+    assert!((*fn_.borrow()).is_null());
+    assert!({
+        let _lhs = (*fn_.borrow()).clone();
+        _lhs != fn_ptr!(my_foo_0, fn(AnyPtr) -> i32)
+    });
+    (*fn_.borrow_mut()) = fn_ptr!(my_foo_0, fn(AnyPtr) -> i32);
+    assert!(!((*fn_.borrow()).is_null()));
+    assert!({
+        let _lhs = (*fn_.borrow()).clone();
+        _lhs == fn_ptr!(my_foo_0, fn(AnyPtr) -> i32)
+    });
+    let a: Value<i32> = Rc::new(RefCell::new(10));
+    assert!({
+        let _lhs = ({
+            let _fn: FnPtr<fn(AnyPtr) -> i32> = (*fn_.borrow()).clone();
+            let _pi: Ptr<i32> = (a.as_pointer());
+            foo_1(_fn, _pi)
+        });
+        _lhs == (*a.borrow())
+    });
+    return 0;
+}

tests/unit/out/refcount/fn_ptr_array.rs

@@ -0,0 +1,59 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn add_0(a: i32, b: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    return ((*a.borrow()) + (*b.borrow()));
+}
+pub fn sub_1(a: i32, b: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    return ((*a.borrow()) - (*b.borrow()));
+}
+pub fn mul_2(a: i32, b: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    return ((*a.borrow()) * (*b.borrow()));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let ops: Value<Box<[FnPtr<fn(i32, i32) -> i32>]>> = Rc::new(RefCell::new(Box::new([
+        fn_ptr!(add_0, fn(i32, i32) -> i32),
+        fn_ptr!(sub_1, fn(i32, i32) -> i32),
+        fn_ptr!(mul_2, fn(i32, i32) -> i32),
+    ])));
+    assert!(
+        (({
+            let _arg0: i32 = 2;
+            let _arg1: i32 = 3;
+            (*(*ops.borrow())[(0) as usize])(_arg0, _arg1)
+        }) == 5)
+    );
+    assert!(
+        (({
+            let _arg0: i32 = 7;
+            let _arg1: i32 = 4;
+            (*(*ops.borrow())[(1) as usize])(_arg0, _arg1)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _arg0: i32 = 6;
+            let _arg1: i32 = 5;
+            (*(*ops.borrow())[(2) as usize])(_arg0, _arg1)
+        }) == 30)
+    );
+    assert!(!(((*ops.borrow())[(0) as usize]).is_null()));
+    assert!(((*ops.borrow())[(0) as usize] == fn_ptr!(add_0, fn(i32, i32) -> i32)));
+    assert!(((*ops.borrow())[(0) as usize] != fn_ptr!(sub_1, fn(i32, i32) -> i32)));
+    return 0;
+}

tests/unit/out/refcount/fn_ptr_as_condition.rs

@@ -0,0 +1,59 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn double_it_0(x: Ptr<i32>) {
+    let x: Value<Ptr<i32>> = Rc::new(RefCell::new(x));
+    {
+        let __ptr = (*x.borrow()).clone();
+        let __tmp = __ptr.read() * 2;
+        __ptr.write(__tmp)
+    };
+}
+pub fn maybe_call_1(cb: FnPtr<fn(Ptr<i32>)>, x: Ptr<i32>) {
+    let cb: Value<FnPtr<fn(Ptr<i32>)>> = Rc::new(RefCell::new(cb));
+    let x: Value<Ptr<i32>> = Rc::new(RefCell::new(x));
+    if !(*cb.borrow()).is_null() {
+        ({
+            let _arg0: Ptr<i32> = (*x.borrow()).clone();
+            (*(*cb.borrow()))(_arg0)
+        });
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(5));
+    ({
+        let _cb: FnPtr<fn(Ptr<i32>)> = fn_ptr!(double_it_0, fn(Ptr::<i32>));
+        let _x: Ptr<i32> = (a.as_pointer());
+        maybe_call_1(_cb, _x)
+    });
+    assert!(((*a.borrow()) == 10));
+    let b: Value<i32> = Rc::new(RefCell::new(5));
+    ({
+        let _cb: FnPtr<fn(Ptr<i32>)> = FnPtr::null();
+        let _x: Ptr<i32> = (b.as_pointer());
+        maybe_call_1(_cb, _x)
+    });
+    assert!(((*b.borrow()) == 5));
+    let fn_: Value<FnPtr<fn(Ptr<i32>)>> = Rc::new(RefCell::new(FnPtr::null()));
+    if !!(*fn_.borrow()).is_null() {
+        (*fn_.borrow_mut()) = (fn_ptr!(double_it_0, fn(Ptr::<i32>))).clone();
+    }
+    let c: Value<i32> = Rc::new(RefCell::new(3));
+    if !(*fn_.borrow()).is_null() {
+        ({
+            let _arg0: Ptr<i32> = (c.as_pointer());
+            (*(*fn_.borrow()))(_arg0)
+        });
+    }
+    assert!(((*c.borrow()) == 6));
+    return 0;
+}

tests/unit/out/refcount/fn_ptr_cast.rs

@@ -0,0 +1,123 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn double_it_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return ((*x.borrow()) * 2);
+}
+pub fn test_roundtrip_1() {
+    let fn_: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new(fn_ptr!(double_it_0, fn(i32) -> i32)));
+    assert!(
+        (({
+            let _arg0: i32 = 5;
+            (*(*fn_.borrow()))(_arg0)
+        }) == 10)
+    );
+    let gfn: Value<FnPtr<fn()>> =
+        Rc::new(RefCell::new(((*fn_.borrow()).cast::<fn()>(None)).clone()));
+    assert!(!((*gfn.borrow()).is_null()));
+    let fn2: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        ((*gfn.borrow()).cast::<fn(i32) -> i32>(None)).clone(),
+    ));
+    assert!(
+        (({
+            let _arg0: i32 = 5;
+            (*(*fn2.borrow()))(_arg0)
+        }) == 10)
+    );
+    assert!({
+        let _lhs = (*fn2.borrow()).clone();
+        _lhs == (*fn_.borrow()).clone()
+    });
+}
+pub fn test_double_cast_2() {
+    let fn_: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new(fn_ptr!(double_it_0, fn(i32) -> i32)));
+    let fn2: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        ((*fn_.borrow())
+            .cast::<fn()>(None)
+            .cast::<fn(i32) -> i32>(None))
+        .clone(),
+    ));
+    assert!(
+        (({
+            let _arg0: i32 = 5;
+            (*(*fn2.borrow()))(_arg0)
+        }) == 10)
+    );
+    assert!({
+        let _lhs = (*fn2.borrow()).clone();
+        _lhs == (*fn_.borrow()).clone()
+    });
+}
+#[derive(Default)]
+pub struct Command {
+    pub data: Value<AnyPtr>,
+}
+impl Clone for Command {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            data: Rc::new(RefCell::new((*self.data.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for Command {}
+pub fn test_void_ptr_to_fn_3() {
+    let cmd: Value<Command> = Rc::new(RefCell::new(<Command>::default()));
+    (*(*cmd.borrow()).data.borrow_mut()) = fn_ptr!(double_it_0, fn(i32) -> i32).to_any();
+    let fn_: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        ((*(*cmd.borrow()).data.borrow())
+            .cast_fn::<fn(i32) -> i32>()
+            .expect("ub:wrong fn type"))
+        .clone(),
+    ));
+    assert!(
+        (({
+            let _arg0: i32 = 5;
+            (*(*fn_.borrow()))(_arg0)
+        }) == 10)
+    );
+}
+pub fn add_offset_4(base: Ptr<i32>, offset: i32) -> i32 {
+    let base: Value<Ptr<i32>> = Rc::new(RefCell::new(base));
+    let offset: Value<i32> = Rc::new(RefCell::new(offset));
+    return {
+        let _lhs = ((*base.borrow()).read());
+        _lhs + (*offset.borrow())
+    };
+}
+pub fn test_call_through_cast_5() {
+    let gfn: Value<FnPtr<fn(AnyPtr, i32) -> i32>> = Rc::new(RefCell::new(
+        fn_ptr!(add_offset_4, fn(Ptr::<i32>, i32) -> i32).cast::<fn(AnyPtr, i32) -> i32>(Some(
+            (|a0: AnyPtr, a1: i32| -> i32 { add_offset_4(a0.cast::<i32>().unwrap(), a1) })
+                as fn(AnyPtr, i32) -> i32,
+        )),
+    ));
+    let val: Value<i32> = Rc::new(RefCell::new(100));
+    let result: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _arg0: AnyPtr = ((val.as_pointer()) as Ptr<i32>).to_any();
+            let _arg1: i32 = 42;
+            (*(*gfn.borrow()))(_arg0, _arg1)
+        }),
+    ));
+    assert!(((*result.borrow()) == 142));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    ({ test_roundtrip_1() });
+    ({ test_double_cast_2() });
+    ({ test_void_ptr_to_fn_3() });
+    ({ test_call_through_cast_5() });
+    return 0;
+}

tests/unit/out/refcount/fn_ptr_conditional.rs

@@ -0,0 +1,94 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn inc_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return ((*x.borrow()) + 1);
+}
+pub fn dec_1(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return ((*x.borrow()) - 1);
+}
+pub fn identity_2(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return (*x.borrow());
+}
+pub fn pick_3(mode: i32) -> FnPtr<fn(i32) -> i32> {
+    let mode: Value<i32> = Rc::new(RefCell::new(mode));
+    return if ((*mode.borrow()) > 0) {
+        fn_ptr!(inc_0, fn(i32) -> i32)
+    } else {
+        if ((*mode.borrow()) < 0) {
+            fn_ptr!(dec_1, fn(i32) -> i32)
+        } else {
+            fn_ptr!(identity_2, fn(i32) -> i32)
+        }
+    };
+}
+pub fn apply_4(fn_: FnPtr<fn(i32) -> i32>, x: i32) -> i32 {
+    let fn_: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(fn_));
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let actual: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new(if !(*fn_.borrow()).is_null() {
+            (*fn_.borrow()).clone()
+        } else {
+            fn_ptr!(identity_2, fn(i32) -> i32)
+        }));
+    return ({
+        let _arg0: i32 = (*x.borrow());
+        (*(*actual.borrow()))(_arg0)
+    });
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (({
+            let _arg0: i32 = 10;
+            (*({
+                let _mode: i32 = 1;
+                pick_3(_mode)
+            }))(_arg0)
+        }) == 11)
+    );
+    assert!(
+        (({
+            let _arg0: i32 = 10;
+            (*({
+                let _mode: i32 = -1_i32;
+                pick_3(_mode)
+            }))(_arg0)
+        }) == 9)
+    );
+    assert!(
+        (({
+            let _arg0: i32 = 10;
+            (*({
+                let _mode: i32 = 0;
+                pick_3(_mode)
+            }))(_arg0)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _fn: FnPtr<fn(i32) -> i32> = fn_ptr!(inc_0, fn(i32) -> i32);
+            let _x: i32 = 5;
+            apply_4(_fn, _x)
+        }) == 6)
+    );
+    assert!(
+        (({
+            let _fn: FnPtr<fn(i32) -> i32> = FnPtr::null();
+            let _x: i32 = 5;
+            apply_4(_fn, _x)
+        }) == 5)
+    );
+    return 0;
+}