Update tests

Author: lucic71

tests/unit/nttp_distinct_specializations.cpp

@@ -0,0 +1,30 @@
+#include <cassert>
+
+template <int N> struct S {
+  int v;
+  int get() const { return v * N; }
+};
+
+template <> struct S<2> {
+  int v;
+  int w;
+  int get() const { return v - w; }
+};
+
+template <int N> int scale(int x) { return x * N; }
+
+template <> int scale<2>(int x) { return x - 2; }
+
+int main() {
+  S<1> s1{5};
+  S<2> s2{5, 1};
+  S<3> s3{5};
+  assert(s1.get() == 5);
+  assert(s2.get() == 4);
+  assert(s3.get() == 15);
+
+  assert(scale<1>(7) == 7);
+  assert(scale<2>(7) == 5);
+  assert(scale<3>(7) == 21);
+  return 0;
+}

tests/unit/out/refcount/nttp_distinct_specializations.rs

@@ -0,0 +1,78 @@
+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(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(8)]
+pub struct S_2_ {
+    #[offset(0)]
+    pub v: i32,
+    #[offset(4)]
+    pub w: i32,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(4)]
+pub struct S_1_ {
+    #[offset(0)]
+    pub v: i32,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(4)]
+pub struct S_3_ {
+    #[offset(0)]
+    pub v: i32,
+}
+pub fn scale_0(mut x: i32) -> i32 {
+    return (x * 1);
+}
+pub fn scale_1(mut x: i32) -> i32 {
+    return (x * 3);
+}
+pub fn scale_2(mut x: i32) -> i32 {
+    return (x - 2);
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let s1: Value<S_1_> = Rc::new(RefCell::new(S_1_ { v: 5 }));
+    let s2: Value<S_2_> = Rc::new(RefCell::new(S_2_ { v: 5, w: 1 }));
+    let s3: Value<S_3_> = Rc::new(RefCell::new(S_3_ { v: 5 }));
+    assert!((({ S_1_Impl::get(&s1.as_pointer(),) }) == 5));
+    assert!((({ S_2_Impl::get(&s2.as_pointer(),) }) == 4));
+    assert!((({ S_3_Impl::get(&s3.as_pointer(),) }) == 15));
+    assert!((({ scale_0(7,) }) == 7));
+    assert!((({ scale_2(7,) }) == 5));
+    assert!((({ scale_1(7,) }) == 21));
+    return 0;
+}
+pub trait S_1_Impl {
+    fn get(&self) -> i32;
+}
+impl S_1_Impl for Ptr<S_1_> {
+    fn get(&self) -> i32 {
+        return ((*self).with(|__s| __s.v) * 1);
+    }
+}
+pub trait S_2_Impl {
+    fn get(&self) -> i32;
+}
+impl S_2_Impl for Ptr<S_2_> {
+    fn get(&self) -> i32 {
+        return ((*self).with(|__s| __s.v) - (*self).with(|__s| __s.w));
+    }
+}
+pub trait S_3_Impl {
+    fn get(&self) -> i32;
+}
+impl S_3_Impl for Ptr<S_3_> {
+    fn get(&self) -> i32 {
+        return ((*self).with(|__s| __s.v) * 3);
+    }
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/pair_get.rs

@@ -0,0 +1,30 @@
+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};
+pub fn second_of_0(p: Ptr<(Value<f64>, Value<i32>)>) -> i32 {
+    return ((*p.upgrade().deref()).1.read());
+}
+pub fn first_of_1(p: Ptr<(Value<f64>, Value<i32>)>) -> f64 {
+    return ((*p.upgrade().deref()).0.read());
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let p: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(1.5_f64.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+    )));
+    assert!((((*p.borrow()).0.read()) == 1.5_f64));
+    assert!((((*p.borrow()).1.read()) == 2));
+    assert!((({ first_of_1(p.as_pointer(),) }) == 1.5_f64));
+    assert!((({ second_of_0(p.as_pointer(),) }) == 2));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/nttp_distinct_specializations.rs

@@ -0,0 +1,67 @@
+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, VaArg, FnPtrArg, Default)]
+pub struct S_2_ {
+    pub v: i32,
+    pub w: i32,
+}
+impl S_2_ {
+    pub unsafe fn get(&self) -> i32 {
+        return ((self.v) - (self.w));
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+pub struct S_1_ {
+    pub v: i32,
+}
+impl S_1_ {
+    pub unsafe fn get(&self) -> i32 {
+        return ((self.v) * (1));
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+pub struct S_3_ {
+    pub v: i32,
+}
+impl S_3_ {
+    pub unsafe fn get(&self) -> i32 {
+        return ((self.v) * (3));
+    }
+}
+pub unsafe fn scale_0(mut x: i32) -> i32 {
+    return ((x) * (1));
+}
+pub unsafe fn scale_1(mut x: i32) -> i32 {
+    return ((x) * (3));
+}
+pub unsafe fn scale_2(mut x: i32) -> i32 {
+    return ((x) - (2));
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut s1: S_1_ = S_1_ { v: 5 };
+    let mut s2: S_2_ = S_2_ { v: 5, w: 1 };
+    let mut s3: S_3_ = S_3_ { v: 5 };
+    assert!(((unsafe { S_1_::get(&s1,) }) == (5)));
+    assert!(((unsafe { S_2_::get(&s2,) }) == (4)));
+    assert!(((unsafe { S_3_::get(&s3,) }) == (15)));
+    assert!(((unsafe { scale_0(7,) }) == (7)));
+    assert!(((unsafe { scale_2(7,) }) == (5)));
+    assert!(((unsafe { scale_1(7,) }) == (21)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/pair_get.rs

@@ -0,0 +1,29 @@
+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;
+pub unsafe fn second_of_0(p: *const (f64, i32)) -> i32 {
+    return (*(*p).1);
+}
+pub unsafe fn first_of_1(p: *const (f64, i32)) -> f64 {
+    return (*(*p).0);
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut p: (f64, i32) = (1.5_f64.into(), 2.into());
+    assert!(((*p.0) == (1.5_f64)));
+    assert!(((*p.1) == (2)));
+    assert!(((unsafe { first_of_1(&p,) }) == (1.5_f64)));
+    assert!(((unsafe { second_of_0(&p,) }) == (2)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/pair_get.cpp

@@ -0,0 +1,17 @@
+#include <cassert>
+#include <utility>
+
+static int second_of(const std::pair<double, int> &p) { return std::get<1>(p); }
+
+static double first_of(const std::pair<double, int> &p) {
+  return std::get<0>(p);
+}
+
+int main() {
+  std::pair<double, int> p(1.5, 2);
+  assert(std::get<0>(p) == 1.5);
+  assert(std::get<1>(p) == 2);
+  assert(first_of(p) == 1.5);
+  assert(second_of(p) == 2);
+  return 0;
+}