Add pre-commit tests

Author: joaotgouveia

tests/unit/class_templates.cpp

@@ -0,0 +1,43 @@
+#include <cassert>
+#include <vector>
+
+template <typename T> class MyContainer {
+  std::vector<T> vec;
+
+public:
+  using value_type = T;
+  using reference = T &;
+  using const_reference = const T &;
+  using size_type = std::size_t;
+
+  bool empty() const { return vec.empty(); }
+  size_type size() const { return vec.size(); }
+  const_reference back() const { return vec.back(); }
+  reference back() { return vec.back(); }
+  void pop_back() { return vec.pop_back(); }
+  void push_back(const_reference item) { vec.push_back(item); }
+};
+
+int main() {
+  MyContainer<int> imc;
+  assert(imc.empty());
+  imc.push_back(1);
+  assert(imc.size() == 1 && imc.back() == 1);
+  imc.pop_back();
+  assert(imc.empty());
+
+  MyContainer<char> cmc;
+  assert(cmc.empty());
+  cmc.push_back('a');
+  assert(cmc.size() == 1 && cmc.back() == 'a');
+  cmc.pop_back();
+  assert(cmc.empty());
+
+  MyContainer<float> fmc;
+  assert(fmc.empty());
+  fmc.push_back('a');
+  assert(fmc.size() == 1 && fmc.back() == 'a');
+  fmc.pop_back();
+  assert(fmc.empty());
+  return 0;
+}

tests/unit/out/refcount/class_templates.rs

@@ -0,0 +1,86 @@
+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 MyContainer {
+    vec_: Value<Vec<i32>>,
+}
+impl MyContainer {
+    pub fn empty(&self) -> bool {
+        return (*self.vec_.borrow()).is_empty();
+    }
+    pub fn size(&self) -> usize {
+        return (*self.vec_.borrow()).len();
+    }
+    pub fn back_const(&self) -> Ptr<i32> {
+        return (self.vec_.as_pointer() as Ptr<i32>).to_last();
+    }
+    pub fn back(&self) -> Ptr<i32> {
+        return (self.vec_.as_pointer() as Ptr<i32>).to_last();
+    }
+    pub fn pop_back(&self) {
+        (*self.vec_.borrow_mut()).pop();
+        return;
+    }
+    pub fn push_back(&self, item: Ptr<i32>) {
+        {
+            let a0_clone = (item.read()).clone();
+            (*self.vec_.borrow_mut()).push(a0_clone)
+        };
+    }
+}
+impl Clone for MyContainer {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            vec_: Rc::new(RefCell::new((*self.vec_.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for MyContainer {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let imc: Value<MyContainer> = Rc::new(RefCell::new(<MyContainer>::default()));
+    assert!(({ (*imc.borrow()).empty() }));
+    ({
+        let _item: Value<i32> = Rc::new(RefCell::new(1));
+        (*imc.borrow()).push_back(_item.as_pointer())
+    });
+    assert!(
+        (({ (*imc.borrow()).size() }) == 1_usize) && ((({ (*imc.borrow()).back() }).read()) == 1)
+    );
+    ({ (*imc.borrow()).pop_back() });
+    assert!(({ (*imc.borrow()).empty() }));
+    let cmc: Value<MyContainer> = Rc::new(RefCell::new(<MyContainer>::default()));
+    assert!(({ (*cmc.borrow()).empty() }));
+    ({
+        let _item: Value<u8> = Rc::new(RefCell::new(('a' as u8)));
+        (*cmc.borrow()).push_back(_item.as_pointer())
+    });
+    assert!(
+        (({ (*cmc.borrow()).size() }) == 1_usize)
+            && (((({ (*cmc.borrow()).back() }).read()) as i32) == (('a' as u8) as i32))
+    );
+    ({ (*cmc.borrow()).pop_back() });
+    assert!(({ (*cmc.borrow()).empty() }));
+    let fmc: Value<MyContainer> = Rc::new(RefCell::new(<MyContainer>::default()));
+    assert!(({ (*fmc.borrow()).empty() }));
+    ({
+        let _item: Value<f32> = Rc::new(RefCell::new((('a' as u8) as f32)));
+        (*fmc.borrow()).push_back(_item.as_pointer())
+    });
+    assert!(
+        (({ (*fmc.borrow()).size() }) == 1_usize)
+            && ((({ (*fmc.borrow()).back() }).read()) == ((('a' as u8) as i32) as f32))
+    );
+    ({ (*fmc.borrow()).pop_back() });
+    assert!(({ (*fmc.borrow()).empty() }));
+    return 0;
+}

tests/unit/out/unsafe/class_templates.rs

@@ -0,0 +1,78 @@
+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(Clone, Default)]
+pub struct MyContainer {
+    vec_: Vec<i32>,
+}
+impl MyContainer {
+    pub unsafe fn empty(&self) -> bool {
+        return self.vec_.is_empty();
+    }
+    pub unsafe fn size(&self) -> usize {
+        return self.vec_.len();
+    }
+    pub unsafe fn back_const(&self) -> *const i32 {
+        return ((self.vec_).last().unwrap());
+    }
+    pub unsafe fn back(&mut self) -> *mut i32 {
+        return ((self.vec_).last_mut().unwrap());
+    }
+    pub unsafe fn pop_back(&mut self) {
+        self.vec_.pop();
+        return;
+    }
+    pub unsafe fn push_back(&mut self, item: *const i32) {
+        {
+            let a0_clone = (*item).clone();
+            self.vec_.push(a0_clone)
+        };
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut imc: MyContainer = <MyContainer>::default();
+    assert!((unsafe { imc.empty() }));
+    (unsafe {
+        let mut _item = 1;
+        imc.push_back(&mut _item)
+    });
+    assert!(((unsafe { imc.size() }) == (1_usize)) && ((*(unsafe { imc.back() })) == (1)));
+    (unsafe { imc.pop_back() });
+    assert!((unsafe { imc.empty() }));
+    let mut cmc: MyContainer = <MyContainer>::default();
+    assert!((unsafe { cmc.empty() }));
+    (unsafe {
+        let mut _item = ('a' as u8);
+        cmc.push_back(&mut _item)
+    });
+    assert!(
+        ((unsafe { cmc.size() }) == (1_usize))
+            && (((*(unsafe { cmc.back() })) as i32) == (('a' as u8) as i32))
+    );
+    (unsafe { cmc.pop_back() });
+    assert!((unsafe { cmc.empty() }));
+    let mut fmc: MyContainer = <MyContainer>::default();
+    assert!((unsafe { fmc.empty() }));
+    (unsafe {
+        let mut _item = (('a' as u8) as f32);
+        fmc.push_back(&mut _item)
+    });
+    assert!(
+        ((unsafe { fmc.size() }) == (1_usize))
+            && ((*(unsafe { fmc.back() })) == ((('a' as u8) as i32) as f32))
+    );
+    (unsafe { fmc.pop_back() });
+    assert!((unsafe { fmc.empty() }));
+    return 0;
+}