Update tests

Author: lucic71

rules/pair/src.cpp

@@ -5,8 +5,6 @@
 
 template <typename T1, typename T2> using t1 = std::pair<T1, T2>;
 
-template <typename T1, typename T2> using t2 = std::pair<const T1, T2>;
-
 template <typename T1, typename T2> T2 &f1(std::pair<T1, T2> &o) {
   return o.second;
 }

rules/pair/tgt_refcount.rs

@@ -12,13 +12,6 @@ fn t1<T1: Default, T2: Default>() -> (Value<T1>, Value<T2>) {
     )
 }
 
-fn t2<T1: Default, T2: Default>() -> (Value<T1>, Value<T2>) {
-    (
-        Rc::new(RefCell::new(T1::default())),
-        Rc::new(RefCell::new(T2::default())),
-    )
-}
-
 fn f1<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Value<T2> {
     a0.1
 }

rules/pair/tgt_unsafe.rs

@@ -5,10 +5,6 @@ fn t1<T1: Default, T2: Default>() -> (T1, T2) {
     <(T1, T2)>::default()
 }
 
-fn t2<T1: Default, T2: Default>() -> (T1, T2) {
-    <(T1, T2)>::default()
-}
-
 unsafe fn f1<T1, T2>(a0: (T1, T2)) -> T2 {
     a0.1
 }

tests/unit/out/refcount/pair.rs

@@ -29,6 +29,26 @@ fn main_0() -> i32 {
     )));
     assert!(((*(*p3.borrow()).0.borrow()) == 5_f64));
     assert!(((*(*p3.borrow()).1.borrow()) == 6));
+    let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2])));
+    let mut n: u32 = 2_u32;
+    let const_ptr_pairs: Value<Vec<(Value<Ptr<i32>>, Value<u64>)>> = Rc::new(RefCell::new(
+        (0..(1_usize) as usize)
+            .map(|_| <(Value<Ptr<i32>>, Value<u64>)>::default())
+            .collect::<Vec<_>>(),
+    ));
+    (*const_ptr_pairs.borrow_mut())[0_usize] = (
+        Rc::new(RefCell::new(
+            (arr.as_pointer() as Ptr<i32>)
+                .offset((1) as isize)
+                .try_into()
+                .expect("failed conversion"),
+        )),
+        Rc::new(RefCell::new(n.try_into().expect("failed conversion"))),
+    );
+    assert!(
+        (((*(*const_ptr_pairs.borrow())[0_usize].0.borrow()).read()) == 2)
+            && ((*(*const_ptr_pairs.borrow())[0_usize].1.borrow()) == 2_u64)
+    );
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/pair.rs

@@ -22,6 +22,15 @@ unsafe fn main_0() -> i32 {
     let mut p3: (f64, i32) = (5.into(), 6.into());
     assert!(((p3.0) == (5_f64)));
     assert!(((p3.1) == (6)));
+    let arr: [i32; 2] = [1, 2];
+    let mut n: u32 = 2_u32;
+    let mut const_ptr_pairs: Vec<(*const i32, u64)> = (0..(1_usize) as usize)
+        .map(|_| <(*const i32, u64)>::default())
+        .collect::<Vec<_>>();
+    const_ptr_pairs[(0_usize)] = (arr.as_ptr().offset((1) as isize).into(), n.into());
+    assert!(
+        ((*const_ptr_pairs[(0_usize)].0) == (2)) && ((const_ptr_pairs[(0_usize)].1) == (2_u64))
+    );
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/pair.cpp

@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <utility>
+#include <vector>
 
 int main() {
   std::pair<double, int> p1(1, 2);
@@ -11,5 +12,10 @@ int main() {
   std::pair<double, int> p3 = std::make_pair(5, 6);
   assert(p3.first == 5.0);
   assert(p3.second == 6);
+  const int arr[2] = {1, 2};
+  unsigned n = 2;
+  std::vector<std::pair<const int *, size_t>> const_ptr_pairs(1);
+  const_ptr_pairs[0] = std::make_pair(arr + 1, n);
+  assert(*const_ptr_pairs[0].first == 2 && const_ptr_pairs[0].second == 2);
   return 0;
 }