Update tests

Author: lucic71

tests/multi-file/template_method_late_instantiation/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16)
+project(template_method_late_instantiation LANGUAGES CXX)
+add_executable(app a.cpp b.cpp)

tests/multi-file/template_method_late_instantiation/a.cpp

@@ -0,0 +1,10 @@
+#include <assert.h>
+
+#include "s.h"
+
+int main() {
+  S<int> p;
+  p.set(3);
+  assert(f(&p) == 3);
+  return 0;
+}

tests/multi-file/template_method_late_instantiation/b.cpp

@@ -0,0 +1,3 @@
+#include "s.h"
+
+int f(S<int> *p) { return p->get(); }

tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs

@@ -0,0 +1,60 @@
+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 S_int_ {
+    pub x: Value<i32>,
+}
+impl Clone for S_int_ {
+    fn clone(&self) -> Self {
+        let __this: Value<S_int_> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new((*self.x.borrow()))),
+        }));
+        let this: Ptr<S_int_> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for S_int_ {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let p: Value<S_int_> = Rc::new(RefCell::new(<S_int_>::default()));
+    ({ S_int_Impl::set(&p.as_pointer(), 3) });
+    assert!((({ f_0((p.as_pointer()),) }) == 3));
+    return 0;
+}
+pub fn f_0(p: Ptr<S_int_>) -> i32 {
+    let p: Value<Ptr<S_int_>> = Rc::new(RefCell::new(p));
+    return ({ S_int_Impl::get(&(*p.borrow())) });
+}
+impl S_int_Impl for Ptr<S_int_> {
+    fn set(&self, v: i32) {
+        let v: Value<i32> = Rc::new(RefCell::new(v));
+        (*(*(*self).upgrade().deref()).x.borrow_mut()) = (*v.borrow());
+    }
+    fn get(&self) -> i32 {
+        return (*(*(*self).upgrade().deref()).x.borrow());
+    }
+}
+pub trait S_int_Impl {
+    fn set(&self, v: i32);
+    fn get(&self) -> i32;
+}

tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs

@@ -0,0 +1,37 @@
+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 S_int_ {
+    pub x: i32,
+}
+impl S_int_ {
+    pub unsafe fn set(&mut self, mut v: i32) {
+        self.x = v;
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut p: S_int_ = <S_int_>::default();
+    (unsafe { S_int_::set(&mut p, 3) });
+    assert!(((unsafe { f_0((&mut p as *mut S_int_),) }) == (3)));
+    return 0;
+}
+impl S_int_ {
+    pub unsafe fn get(&mut self) -> i32 {
+        return self.x;
+    }
+}
+pub unsafe fn f_0(mut p: *mut S_int_) -> i32 {
+    return (unsafe { S_int_::get(&mut (*p)) });
+}

tests/multi-file/template_method_late_instantiation/s.h

@@ -0,0 +1,11 @@
+#pragma once
+
+template <typename T>
+struct S {
+  T x = 0;
+
+  void set(T v) { x = v; }
+  T get() { return x; }
+};
+
+int f(S<int> *p);

tests/unit/out/refcount/10_struct.rs

@@ -41,9 +41,6 @@ pub struct Graph {
     pub V: Value<u32>,
     pub adj: Value<Ptr<Ptr<GraphNode>>>,
 }
-pub trait GraphImpl {
-    fn push(&self, src: u32, dst: u32);
-}
 impl Clone for Graph {
     fn clone(&self) -> Self {
         let __this: Value<Graph> = Rc::new(RefCell::new(Self {
@@ -109,3 +106,6 @@ impl GraphImpl for Ptr<Graph> {
             .write(__rhs);
     }
 }
+pub trait GraphImpl {
+    fn push(&self, src: u32, dst: u32);
+}

tests/unit/out/refcount/class.rs

@@ -11,14 +11,6 @@ pub struct Pair {
     pub first: Value<i32>,
     pub second: Value<i32>,
 }
-pub trait PairImpl {
-    fn NOP(&self);
-    fn GetFirst(&self) -> i32;
-    fn GetSecond(&self) -> i32;
-    fn Set(&self, field: Ptr<i32>, new_val: i32) -> i32;
-    fn SetFirst(&self, new_first: i32) -> i32;
-    fn SetSecond(&self, new_second: i32) -> i32;
-}
 impl Clone for Pair {
     fn clone(&self) -> Self {
         let __this: Value<Pair> = Rc::new(RefCell::new(Self {
@@ -49,9 +41,6 @@ pub struct Route {
     pub path: Value<Pair>,
     pub cost: Value<f64>,
 }
-pub trait RouteImpl {
-    fn SetCost(&self, new_cost: f64) -> f64;
-}
 impl Clone for Route {
     fn clone(&self) -> Self {
         let __this: Value<Route> = Rc::new(RefCell::new(Self {
@@ -169,3 +158,14 @@ impl RouteImpl for Ptr<Route> {
         return (*old_cost.borrow());
     }
 }
+pub trait PairImpl {
+    fn NOP(&self);
+    fn GetFirst(&self) -> i32;
+    fn GetSecond(&self) -> i32;
+    fn Set(&self, field: Ptr<i32>, new_val: i32) -> i32;
+    fn SetFirst(&self, new_first: i32) -> i32;
+    fn SetSecond(&self, new_second: i32) -> i32;
+}
+pub trait RouteImpl {
+    fn SetCost(&self, new_cost: f64) -> f64;
+}

tests/unit/out/refcount/class_template_lazy_member.rs

@@ -36,9 +36,6 @@ impl ByteRepr for Point {
 pub struct Box_int_ {
     pub val: Value<i32>,
 }
-pub trait Box_int_Impl {
-    fn twice(&self) -> i32;
-}
 impl Clone for Box_int_ {
     fn clone(&self) -> Self {
         let __this: Value<Box_int_> = Rc::new(RefCell::new(Self {
@@ -65,9 +62,6 @@ impl ByteRepr for Box_int_ {
 pub struct Box_Point_ {
     pub val: Value<Point>,
 }
-pub trait Box_Point_Impl {
-    fn get(&self) -> Point;
-}
 impl Clone for Box_Point_ {
     fn clone(&self) -> Self {
         let __this: Value<Box_Point_> = Rc::new(RefCell::new(Self {
@@ -117,3 +111,9 @@ impl Box_int_Impl for Ptr<Box_int_> {
             + (*(*(*self).upgrade().deref()).val.borrow()));
     }
 }
+pub trait Box_Point_Impl {
+    fn get(&self) -> Point;
+}
+pub trait Box_int_Impl {
+    fn twice(&self) -> i32;
+}

tests/unit/out/refcount/class_templates.rs

@@ -10,13 +10,6 @@ use std::rc::{Rc, Weak};
 pub struct MyContainer_int_ {
     vec_: Value<Vec<i32>>,
 }
-pub trait MyContainer_int_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<i32>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<i32>);
-}
 impl Clone for MyContainer_int_ {
     fn clone(&self) -> Self {
         let __this: Value<MyContainer_int_> = Rc::new(RefCell::new(Self {
@@ -43,13 +36,6 @@ impl ByteRepr for MyContainer_int_ {
 pub struct MyContainer_char_ {
     vec_: Value<Vec<u8>>,
 }
-pub trait MyContainer_char_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<u8>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<u8>);
-}
 impl Clone for MyContainer_char_ {
     fn clone(&self) -> Self {
         let __this: Value<MyContainer_char_> = Rc::new(RefCell::new(Self {
@@ -76,13 +62,6 @@ impl ByteRepr for MyContainer_char_ {
 pub struct MyContainer_float_ {
     vec_: Value<Vec<f32>>,
 }
-pub trait MyContainer_float_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<f32>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<f32>);
-}
 impl Clone for MyContainer_float_ {
     fn clone(&self) -> Self {
         let __this: Value<MyContainer_float_> = Rc::new(RefCell::new(Self {
@@ -211,3 +190,24 @@ impl MyContainer_int_Impl for Ptr<MyContainer_int_> {
         };
     }
 }
+pub trait MyContainer_char_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<u8>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<u8>);
+}
+pub trait MyContainer_float_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<f32>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<f32>);
+}
+pub trait MyContainer_int_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<i32>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<i32>);
+}