Add basic va_args tests

Author: lucic71

tests/unit/out/refcount/va_arg_concat.rs

@@ -0,0 +1,34 @@
+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 sum_ints_0(first: i32, args: &[VaArg]) -> i32 {
+    let first: Value<i32> = Rc::new(RefCell::new(first));
+    let ap: Value<VaList> = Rc::new(RefCell::new(<VaList>::default()));
+    let total: Value<i32> = Rc::new(RefCell::new((*first.borrow())));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let val: Value<i32> = <Value<i32>>::default();
+    'loop_: while ((({
+        (*val.borrow_mut()) = ((*ap.borrow_mut()).arg::<i32>()).clone();
+        (*val.borrow())
+    }) as i32)
+        != 0)
+    {
+        (*total.borrow_mut()) += (*val.borrow());
+    }
+    return (*total.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    return (({
+        let _first: i32 = 1;
+        sum_ints_0(_first, &[2.into(), 3.into(), 4.into(), 0.into()])
+    }) - 10);
+}

tests/unit/out/refcount/va_arg_forward.rs

@@ -0,0 +1,42 @@
+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 inner_0(count: i32, ap: VaList) -> i32 {
+    let count: Value<i32> = Rc::new(RefCell::new(count));
+    let ap: Value<VaList> = Rc::new(RefCell::new(ap));
+    let total: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < (*count.borrow())) {
+        (*total.borrow_mut()) += ((*ap.borrow_mut()).arg::<i32>()).clone();
+        (*i.borrow_mut()).postfix_inc();
+    }
+    return (*total.borrow());
+}
+pub fn outer_1(count: i32, args: &[VaArg]) -> i32 {
+    let count: Value<i32> = Rc::new(RefCell::new(count));
+    let ap: Value<VaList> = Rc::new(RefCell::new(<VaList>::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let result: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _count: i32 = (*count.borrow());
+            let _ap: VaList = (*ap.borrow()).clone();
+            inner_0(_count, _ap)
+        }),
+    ));
+    return (*result.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    return (({
+        let _count: i32 = 3;
+        outer_1(_count, &[10.into(), 20.into(), 30.into()])
+    }) - 60);
+}

tests/unit/out/refcount/va_arg_mixed_types.rs

@@ -0,0 +1,31 @@
+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 sum_mixed_0(count: i32, args: &[VaArg]) -> f64 {
+    let count: Value<i32> = Rc::new(RefCell::new(count));
+    let ap: Value<VaList> = Rc::new(RefCell::new(<VaList>::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let total: Value<f64> = Rc::new(RefCell::new(0_f64));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < (*count.borrow())) {
+        (*total.borrow_mut()) += ((*ap.borrow_mut()).arg::<f64>()).clone();
+        (*i.borrow_mut()).postfix_inc();
+    }
+    return (*total.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    return ((({
+        let _count: i32 = 3;
+        sum_mixed_0(_count, &[1.5E+0.into(), 2.5E+0.into(), 3.0E+0.into()])
+    }) as i32)
+        - 7);
+}

tests/unit/out/unsafe/va_arg_concat.rs

@@ -0,0 +1,35 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub unsafe fn sum_ints_0(mut first: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = <VaList>::default();
+    let mut total: i32 = first;
+    ap = VaList::new(args);
+    let mut val: i32 = <i32>::default();
+    'loop_: while ((({
+        val = ap.arg::<i32>();
+        val
+    }) as i32)
+        != (0))
+    {
+        total += val;
+    }
+    return total;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    return ((unsafe {
+        let _first: i32 = 1;
+        sum_ints_0(_first, &[2.into(), 3.into(), 4.into(), 0.into()])
+    }) - (10));
+}

tests/unit/out/unsafe/va_arg_forward.rs

@@ -0,0 +1,39 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub unsafe fn inner_0(mut count: i32, mut ap: VaList) -> i32 {
+    let mut total: i32 = 0;
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (count)) {
+        total += ap.arg::<i32>();
+        i.postfix_inc();
+    }
+    return total;
+}
+pub unsafe fn outer_1(mut count: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = <VaList>::default();
+    ap = VaList::new(args);
+    let mut result: i32 = (unsafe {
+        let _count: i32 = count;
+        let _ap: VaList = ap;
+        inner_0(_count, _ap)
+    });
+    return result;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    return ((unsafe {
+        let _count: i32 = 3;
+        outer_1(_count, &[10.into(), 20.into(), 30.into()])
+    }) - (60));
+}

tests/unit/out/unsafe/va_arg_mixed_types.rs

@@ -0,0 +1,32 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub unsafe fn sum_mixed_0(mut count: i32, args: &[VaArg]) -> f64 {
+    let mut ap: VaList = <VaList>::default();
+    ap = VaList::new(args);
+    let mut total: f64 = 0_f64;
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (count)) {
+        total += ap.arg::<f64>();
+        i.postfix_inc();
+    }
+    return total;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    return (((unsafe {
+        let _count: i32 = 3;
+        sum_mixed_0(_count, &[1.5E+0.into(), 2.5E+0.into(), 3.0E+0.into()])
+    }) as i32)
+        - (7));
+}

tests/unit/va_arg_concat.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+
+int sum_ints(int first, ...) {
+  va_list ap;
+  int total = first;
+
+  va_start(ap, first);
+  int val;
+  while ((val = va_arg(ap, int)) != 0) {
+    total += val;
+  }
+  va_end(ap);
+
+  return total;
+}
+
+int main() {
+  return sum_ints(1, 2, 3, 4, 0) - 10;
+}

tests/unit/va_arg_forward.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+
+int inner(int count, va_list ap) {
+  int total = 0;
+  for (int i = 0; i < count; i++) {
+    total += va_arg(ap, int);
+  }
+  return total;
+}
+
+int outer(int count, ...) {
+  va_list ap;
+  va_start(ap, count);
+  int result = inner(count, ap);
+  va_end(ap);
+  return result;
+}
+
+int main() {
+  return outer(3, 10, 20, 30) - 60;
+}

tests/unit/va_arg_mixed_types.c

@@ -0,0 +1,16 @@
+#include <stdarg.h>
+
+double sum_mixed(int count, ...) {
+  va_list ap;
+  va_start(ap, count);
+  double total = 0;
+  for (int i = 0; i < count; i++) {
+    total += va_arg(ap, double);
+  }
+  va_end(ap);
+  return total;
+}
+
+int main() {
+  return (int)sum_mixed(3, 1.5, 2.5, 3.0) - 7;
+}