Add tests

Author: lucic71

rules/memory/src_until_cxx23.cpp

@@ -6,6 +6,4 @@
 
 void f1(char *a0, std::size_t a1) { return std::declare_no_pointers(a0, a1); }
 
-void f2(char *a0, std::size_t a1) {
-  return std::undeclare_no_pointers(a0, a1);
-}
+void f2(char *a0, std::size_t a1) { return std::undeclare_no_pointers(a0, a1); }

rules/memory/tgt_refcount.rs

@@ -3,6 +3,10 @@
 
 use libcc2rs::*;
 
-fn f1(_a0: Ptr<i8>, _a1: usize) {}
+fn f1(a0: Ptr<i8>, a1: usize) {
+    ()
+}
 
-fn f2(_a0: Ptr<i8>, _a1: usize) {}
+fn f2(a0: Ptr<i8>, a1: usize) {
+    ()
+}

rules/memory/tgt_unsafe.rs

@@ -1,6 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1(_a0: *mut libc::c_char, _a1: usize) {}
+unsafe fn f1(a0: *mut libc::c_char, a1: usize) {
+    ()
+}
 
-unsafe fn f2(_a0: *mut libc::c_char, _a1: usize) {}
+unsafe fn f2(a0: *mut libc::c_char, a1: usize) {
+    ()
+}

tests/unit/08_unique_array.cpp

@@ -1,3 +1,4 @@
+// ADDITIONAL_COMPILE_FLAGS: -std=c++20
 #include <cassert>
 #include <memory>
 
@@ -9,5 +10,10 @@ int main() {
   g_ptr[0] = 13;
   g_ptr[1] = 14;
   assert(g[0] + g[1] == 27);
+  auto buf = std::make_unique<char[]>(16);
+  std::declare_no_pointers(buf.get(), 16);
+  buf[0] = 'x';
+  std::undeclare_no_pointers(buf.get(), 16);
+  assert(buf[0] == 'x');
   return 0;
 }

tests/unit/elidable_iterator_copy_cxx11.cpp

@@ -10,5 +10,8 @@ int main() {
   std::vector<int>::iterator it = std::find(v.begin(), v.end(), 7);
   assert(it != v.end());
   assert(*it == 7);
+  std::random_shuffle(v.begin(), v.end());
+  std::sort(v.begin(), v.end());
+  assert(v[0] == 4 && v[1] == 7);
   return 0;
 }

tests/unit/out/refcount/08_unique_array.rs

@@ -24,6 +24,13 @@ fn main_0() -> i32 {
             + g.as_ref().unwrap().borrow()[(1_usize) as usize])
             == 27)
     );
+    let mut buf: Option<Value<Box<[i8]>>> = Some(Rc::new(RefCell::new(
+        (0..16_usize).map(|_| <i8>::default()).collect::<Box<[_]>>(),
+    )));
+    ();
+    buf.as_ref().unwrap().borrow_mut()[(0_usize) as usize] = ('x' as i8);
+    ();
+    assert!(((buf.as_ref().unwrap().borrow()[(0_usize) as usize] as i32) == (('x' as i8) as i32)));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs

@@ -34,6 +34,21 @@ fn main_0() -> i32 {
     };
     assert!(it != (v.as_pointer() as Ptr<i32>).to_end());
     assert!(((it.read()) == 7));
+    {
+        let count = (v.as_pointer() as Ptr<i32>).to_end().get_offset()
+            - (v.as_pointer() as Ptr<i32>).get_offset();
+        let random = std::hash::RandomState::new();
+        for i in (1..count).rev() {
+            let j = std::hash::BuildHasher::hash_one(&random, i) as usize % (i + 1);
+            let x = (v.as_pointer() as Ptr<i32>).offset(i);
+            let y = (v.as_pointer() as Ptr<i32>).offset(j);
+            let tmp = x.read();
+            x.write(y.read());
+            y.write(tmp);
+        }
+    };
+    (v.as_pointer() as Ptr<i32>).sort((v.as_pointer() as Ptr<i32>).to_end().get_offset());
+    assert!(({ (*v.borrow())[0_usize] } == 4) && ({ (*v.borrow())[1_usize] } == 7));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/string.rs

@@ -29,6 +29,14 @@ fn main_0() -> i32 {
         Ptr::<i8>::from_string_literal(b"hello")
             .with_c_str(|__s| (*s1.borrow())[..(*s1.borrow()).len().saturating_sub(1)] == *__s)
     );
+    assert!(
+        Ptr::<i8>::from_string_literal(b"world")
+            .with_c_str(|__s| (*s1.borrow())[..(*s1.borrow()).len().saturating_sub(1)] != *__s)
+    );
+    assert!(
+        !(Ptr::<i8>::from_string_literal(b"hello")
+            .with_c_str(|__s| (*s1.borrow())[..(*s1.borrow()).len().saturating_sub(1)] != *__s))
+    );
     let mut p1: Ptr<i8> = (s1.as_pointer() as Ptr<i8>);
     assert!((((elem!(p1, 0).read()) as i32) == (('h' as i8) as i32)));
     assert!((((elem!(p1, 1).read()) as i32) == (('e' as i8) as i32)));

tests/unit/out/unsafe/08_unique_array.rs

@@ -23,6 +23,15 @@ unsafe fn main_0() -> i32 {
     (*g_ptr.offset((0) as isize)) = 13;
     (*g_ptr.offset((1) as isize)) = 14;
     assert!((((g.as_mut().unwrap()[(0_usize)]) + (g.as_mut().unwrap()[(1_usize)])) == (27)));
+    let mut buf: Option<Box<[libc::c_char]>> = Some(
+        (0..16_usize)
+            .map(|_| <libc::c_char>::default())
+            .collect::<Box<[_]>>(),
+    );
+    ();
+    buf.as_mut().unwrap()[(0_usize)] = ('x' as libc::c_char);
+    ();
+    assert!(((buf.as_mut().unwrap()[(0_usize)] as i32) == (('x' as libc::c_char) as i32)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs

@@ -31,6 +31,18 @@ unsafe fn main_0() -> i32 {
     };
     assert!(it != v.as_mut_ptr().add(v.len()));
     assert!(((*it) == (7)));
+    {
+        let len = v.as_mut_ptr().add(v.len()).offset_from(v.as_mut_ptr()) as usize;
+        let slice = ::std::slice::from_raw_parts_mut(v.as_mut_ptr(), len);
+        for i in (1..len).rev() {
+            slice.swap(i, libc::rand() as usize % (i + 1));
+        }
+    };
+    {
+        let len = v.as_mut_ptr().add(v.len()).offset_from(v.as_mut_ptr()) as usize;
+        ::std::slice::from_raw_parts_mut(v.as_mut_ptr(), len).sort()
+    };
+    assert!(((v[(0_usize)]) == (4)) && ((v[(1_usize)]) == (7)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}