Update tests

Author: lucic71

tests/unit/out/refcount/push_emplace_back.rs

@@ -263,7 +263,18 @@ pub fn emplace_ctor_args_7(pairs: Ptr<Vec<Pair>>) {
         (*pairs.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
 }
-pub fn emplace_scalar_8(values: Ptr<Vec<i64>>, x: i32) {
+pub fn emplace_deque_8(queue: Ptr<Vec<Pair>>) {
+    let queue: Value<Ptr<Vec<Pair>>> = Rc::new(RefCell::new(queue));
+    {
+        let __init = Pair::Pair3({ 6 }, { 7 });
+        (*queue.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
+    };
+    {
+        let __init = Pair::Pair1();
+        (*queue.borrow()).with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
+    };
+}
+pub fn emplace_scalar_9(values: Ptr<Vec<i64>>, x: i32) {
     let values: Value<Ptr<Vec<i64>>> = Rc::new(RefCell::new(values));
     let x: Value<i32> = Rc::new(RefCell::new(x));
     {
@@ -464,8 +475,36 @@ fn main_0() -> i32 {
             .borrow())
                 == 10)
     );
+    let queue: Value<Vec<Pair>> = Rc::new(RefCell::new(Default::default()));
+    ({ emplace_deque_8((queue.as_pointer())) });
+    assert!(
+        ((*(*(queue.as_pointer() as Ptr<Pair>).upgrade().deref())
+            .first
+            .borrow())
+            == 6)
+            && ((*(*(queue.as_pointer() as Ptr<Pair>).upgrade().deref())
+                .second
+                .borrow())
+                == 14)
+    );
+    assert!(
+        ((*(*(queue.as_pointer() as Ptr<Pair>)
+            .to_last()
+            .upgrade()
+            .deref())
+        .first
+        .borrow())
+            == -1_i32)
+            && ((*(*(queue.as_pointer() as Ptr<Pair>)
+                .to_last()
+                .upgrade()
+                .deref())
+            .second
+            .borrow())
+                == -1_i32)
+    );
     let values: Value<Vec<i64>> = Rc::new(RefCell::new(Vec::new()));
-    ({ emplace_scalar_8((values.as_pointer()), 7) });
+    ({ emplace_scalar_9((values.as_pointer()), 7) });
     assert!(((*values.borrow()).len() == 2_usize));
     assert!((((values.as_pointer() as Ptr<i64>).offset(0_usize).read()) == 0_i64));
     assert!((((values.as_pointer() as Ptr<i64>).offset(1_usize).read()) == 7_i64));

tests/unit/out/unsafe/push_emplace_back.rs

@@ -129,7 +129,17 @@ pub unsafe fn emplace_ctor_args_7(mut pairs: *mut Vec<Pair>) {
         (*pairs).push(__init)
     };
 }
-pub unsafe fn emplace_scalar_8(mut values: *mut Vec<i64>, mut x: i32) {
+pub unsafe fn emplace_deque_8(mut queue: *mut Vec<Pair>) {
+    {
+        let __init = Pair::Pair3({ 6 }, { 7 });
+        (*queue).push(__init)
+    };
+    {
+        let __init = Pair::Pair1();
+        (*queue).push(__init)
+    };
+}
+pub unsafe fn emplace_scalar_9(mut values: *mut Vec<i64>, mut x: i32) {
     {
         let __init = 0_i64;
         (*values).push(__init)
@@ -187,8 +197,18 @@ unsafe fn main_0() -> i32 {
     assert!(((pairs[(0_usize)].first) == (-1_i32)) && ((pairs[(0_usize)].second) == (-1_i32)));
     assert!(((pairs[(1_usize)].first) == (3)) && ((pairs[(1_usize)].second) == (0)));
     assert!(((pairs[(2_usize)].first) == (4)) && ((pairs[(2_usize)].second) == (10)));
+    let mut queue: Vec<Pair> = Default::default();
+    (unsafe { emplace_deque_8((&mut queue as *mut Vec<Pair>)) });
+    assert!(
+        (((*((queue).first_mut().unwrap())).first) == (6))
+            && (((*((queue).first_mut().unwrap())).second) == (14))
+    );
+    assert!(
+        (((*(queue.last_mut().unwrap())).first) == (-1_i32))
+            && (((*(queue.last_mut().unwrap())).second) == (-1_i32))
+    );
     let mut values: Vec<i64> = Vec::new();
-    (unsafe { emplace_scalar_8((&mut values as *mut Vec<i64>), 7) });
+    (unsafe { emplace_scalar_9((&mut values as *mut Vec<i64>), 7) });
     assert!(((values.len()) == (2_usize)));
     assert!(((values[(0_usize)]) == (0_i64)));
     assert!(((values[(1_usize)]) == (7_i64)));

tests/unit/push_emplace_back.cpp

@@ -1,5 +1,6 @@
 #include <cassert>
 #include <cstdint>
+#include <deque>
 #include <vector>
 
 struct Chunk {
@@ -70,6 +71,11 @@ void emplace_ctor_args(std::vector<Pair> *pairs) {
   pairs->emplace_back(4, 5);
 }
 
+void emplace_deque(std::deque<Pair> *queue) {
+  queue->emplace_back(6, 7);
+  queue->emplace_back();
+}
+
 void emplace_scalar(std::vector<long> *values, int x) {
   values->emplace_back();
   values->emplace_back(x);
@@ -125,6 +131,11 @@ int main() {
   assert(pairs[1].first == 3 && pairs[1].second == 0);
   assert(pairs[2].first == 4 && pairs[2].second == 10);
 
+  std::deque<Pair> queue;
+  emplace_deque(&queue);
+  assert(queue.front().first == 6 && queue.front().second == 14);
+  assert(queue.back().first == -1 && queue.back().second == -1);
+
   std::vector<long> values;
   emplace_scalar(&values, 7);
   assert(values.size() == 2);