Add non-primitive pointers in va_arg test

Author: lucic71

tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs

@@ -0,0 +1,131 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct node {
+    pub data: Value<i32>,
+    pub next: Value<Ptr<node>>,
+}
+impl ByteRepr for node {}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum opt {
+    #[default]
+    OPT_STRING_OUT = 0,
+    OPT_FILE = 1,
+    OPT_NODE = 2,
+    OPT_NODE_OUT = 3,
+}
+impl From<i32> for opt {
+    fn from(n: i32) -> opt {
+        match n {
+            0 => opt::OPT_STRING_OUT,
+            1 => opt::OPT_FILE,
+            2 => opt::OPT_NODE,
+            3 => opt::OPT_NODE_OUT,
+            _ => panic!("invalid opt value: {}", n),
+        }
+    }
+}
+pub fn dispatch_0(option: i32, args: &[VaArg]) -> i32 {
+    let option: Value<i32> = Rc::new(RefCell::new(option));
+    let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let result: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*option.borrow());
+        match __match_cond {
+            v if v == (opt::OPT_STRING_OUT as i32) => {
+                let out: Value<Ptr<Ptr<u8>>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<Ptr<u8>>>()).clone(),
+                ));
+                (*out.borrow()).write(Ptr::from_string_literal("hello"));
+                (*result.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == (opt::OPT_FILE as i32) => {
+                let f: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<::std::fs::File>>()).clone(),
+                ));
+                (*result.borrow_mut()) = ((!((*f.borrow()).is_null())) as i32).clone();
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE as i32) => {
+                let n: Value<Ptr<node>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<node>>()).clone(),
+                ));
+                (*result.borrow_mut()) = (*(*(*n.borrow()).upgrade().deref()).data.borrow());
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE_OUT as i32) => {
+                let out: Value<Ptr<Ptr<node>>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<Ptr<node>>>()).clone(),
+                ));
+                (*out.borrow()).write(Ptr::<node>::null());
+                (*result.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return (*result.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::<u8>::null()));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_STRING_OUT as i32);
+            dispatch_0(_option, &[(s.as_pointer()).into()])
+        }) == 1) as i32)
+            != 0)
+    );
+    assert!((((!((*s.borrow()).is_null())) as i32) != 0));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(_option, &[libcc2rs::cout().into()])
+        }) == 1) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(
+                _option,
+                &[(AnyPtr::default())
+                    .cast::<::std::fs::File>()
+                    .expect("ub:wrong type")
+                    .into()],
+            )
+        }) == 0) as i32)
+            != 0)
+    );
+    let head: Value<node> = Rc::new(RefCell::new(node {
+        data: Rc::new(RefCell::new(42)),
+        next: Rc::new(RefCell::new(Ptr::<node>::null())),
+    }));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_NODE as i32);
+            dispatch_0(_option, &[(head.as_pointer()).into()])
+        }) == 42) as i32)
+            != 0)
+    );
+    let outp: Value<Ptr<node>> = Rc::new(RefCell::new((head.as_pointer())));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_NODE_OUT as i32);
+            dispatch_0(_option, &[(outp.as_pointer()).into()])
+        }) == 2) as i32)
+            != 0)
+    );
+    assert!(((((*outp.borrow()).is_null()) as i32) != 0));
+    return 0;
+}

tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs

@@ -0,0 +1,121 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+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 node {
+    pub data: i32,
+    pub next: *mut node,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum opt {
+    #[default]
+    OPT_STRING_OUT = 0,
+    OPT_FILE = 1,
+    OPT_NODE = 2,
+    OPT_NODE_OUT = 3,
+}
+impl From<i32> for opt {
+    fn from(n: i32) -> opt {
+        match n {
+            0 => opt::OPT_STRING_OUT,
+            1 => opt::OPT_FILE,
+            2 => opt::OPT_NODE,
+            3 => opt::OPT_NODE_OUT,
+            _ => panic!("invalid opt value: {}", n),
+        }
+    }
+}
+pub unsafe fn dispatch_0(mut option: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = VaList::default();
+    ap = VaList::new(args);
+    let mut result: i32 = 0;
+    'switch: {
+        let __match_cond = option;
+        match __match_cond {
+            v if v == (opt::OPT_STRING_OUT as i32) => {
+                let mut out: *mut *const u8 = ap.arg::<*mut *const u8>();
+                (*out) = b"hello\0".as_ptr().cast_mut().cast_const();
+                result = 1;
+                break 'switch;
+            }
+            v if v == (opt::OPT_FILE as i32) => {
+                let mut f: *mut ::std::fs::File = ap.arg::<*mut ::std::fs::File>();
+                result = ((!((f).is_null())) as i32).clone();
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE as i32) => {
+                let mut n: *mut node = ap.arg::<*mut node>();
+                result = (*n).data;
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE_OUT as i32) => {
+                let mut out: *mut *mut node = ap.arg::<*mut *mut node>();
+                (*out) = std::ptr::null_mut();
+                result = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return result;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut s: *const u8 = std::ptr::null();
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_STRING_OUT as i32);
+            dispatch_0(_option, &[(&mut s as *mut *const u8).into()])
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!((((!((s).is_null())) as i32) != 0));
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(_option, &[libcc2rs::cout_unsafe().into()])
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(
+                _option,
+                &[((0 as *mut ::libc::c_void) as *mut ::std::fs::File).into()],
+            )
+        }) == (0)) as i32)
+            != 0)
+    );
+    let mut head: node = node {
+        data: 42,
+        next: std::ptr::null_mut(),
+    };
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_NODE as i32);
+            dispatch_0(_option, &[(&mut head as *mut node).into()])
+        }) == (42)) as i32)
+            != 0)
+    );
+    let mut outp: *mut node = (&mut head as *mut node);
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_NODE_OUT as i32);
+            dispatch_0(_option, &[(&mut outp as *mut *mut node).into()])
+        }) == (2)) as i32)
+            != 0)
+    );
+    assert!(((((outp).is_null()) as i32) != 0));
+    return 0;
+}

tests/unit/va_arg_non_primitive_ptrs.c

@@ -0,0 +1,65 @@
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+struct node {
+  int data;
+  struct node *next;
+};
+
+enum opt {
+  OPT_STRING_OUT,
+  OPT_FILE,
+  OPT_NODE,
+  OPT_NODE_OUT,
+};
+
+int dispatch(int option, ...) {
+  va_list ap;
+  va_start(ap, option);
+  int result = 0;
+  switch (option) {
+  case OPT_STRING_OUT: {
+    const char **out = va_arg(ap, const char **);
+    *out = "hello";
+    result = 1;
+    break;
+  }
+  case OPT_FILE: {
+    FILE *f = va_arg(ap, FILE *);
+    result = (f != NULL);
+    break;
+  }
+  case OPT_NODE: {
+    struct node *n = va_arg(ap, struct node *);
+    result = n->data;
+    break;
+  }
+  case OPT_NODE_OUT: {
+    struct node **out = va_arg(ap, struct node **);
+    *out = NULL;
+    result = 2;
+    break;
+  }
+  }
+  va_end(ap);
+  return result;
+}
+
+int main() {
+  const char *s = NULL;
+  assert(dispatch(OPT_STRING_OUT, &s) == 1);
+  assert(s != NULL);
+
+  assert(dispatch(OPT_FILE, stdout) == 1);
+  assert(dispatch(OPT_FILE, (FILE *)NULL) == 0);
+
+  struct node head = {42, NULL};
+  assert(dispatch(OPT_NODE, &head) == 42);
+
+  struct node *outp = &head;
+  assert(dispatch(OPT_NODE_OUT, &outp) == 2);
+  assert(outp == NULL);
+
+  return 0;
+}