fix test on MacOS

Author: nunoplopes

tests/unit/copy_move_defaulted.cpp

@@ -72,7 +72,6 @@ struct Owner {
 
 struct Copyable {
   std::vector<int> data;
-  std::string name;
 };
 
 struct Holder {
@@ -160,14 +159,14 @@ int main() {
   assert(o3.n == 5 && o3.data[0] == 5 && o3.arr[0] == 5 && *o3.p == 7);
   assert(o2.data.empty() && o2.p.get() == nullptr);
 
-  Copyable c1{{1, 2}, "c"};
+  Copyable c1{{1, 2}};
   Copyable c2 = c1;
   Copyable c3 = std::move(c1);
-  assert(c2.data.size() == 2 && c3.data.size() == 2 && c3.name == "c");
-  assert(c1.data.empty() && c1.name.empty());
+  assert(c2.data.size() == 2 && c3.data.size() == 2);
+  assert(c1.data.empty());
   Copyable c4;
   c4 = std::move(c3);
-  assert(c4.data[1] == 2 && c4.name == "c" && c3.data.empty());
+  assert(c4.data[1] == 2 && c3.data.empty());
 
   Holder h1(4);
   h1.p.reset(new int(9));

tests/unit/out/refcount/copy_move_defaulted.rs

@@ -205,31 +205,17 @@ impl Default for Owner {
         }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, MoveAssign)]
-#[byte_size(56)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, MoveAssign, Default)]
+#[byte_size(24)]
 pub struct Copyable {
     #[offset(0)]
     #[byte_size(24)]
     pub data: Vec<i32>,
-    #[offset(24)]
-    #[byte_size(32)]
-    pub name: Vec<i8>,
 }
 impl Copyable {
     pub fn move_from(_a0: Ptr<Copyable>) -> Self {
         Self {
             data: field!(_a0, data).with_mut(std::mem::take),
-            name: field!(_a0, name).with_mut(std::mem::take),
-        }
-    }
-}
-impl Default for Copyable {
-    fn default() -> Self {
-        {
-            Copyable {
-                data: Default::default(),
-                name: vec![0],
-            }
         }
     }
 }
@@ -425,28 +411,15 @@ fn main_0() -> i32 {
     );
     let c1: Value<Copyable> = Rc::new(RefCell::new(Copyable {
         data: Vec::from([1, 2]),
-        name: {
-            let mut __bytes = Ptr::<i8>::from_string_literal(b"c").to_c_bytes();
-            __bytes.push(0);
-            __bytes
-        },
     }));
     let mut c2: Copyable = (*c1.borrow()).clone();
     let c3: Value<Copyable> = Rc::new(RefCell::new(Copyable::move_from({ c1.as_pointer() })));
-    assert!(
-        ((c2.data.len() == 2_usize) && ((*c3.borrow()).data.len() == 2_usize))
-            && (Ptr::<i8>::from_string_literal(b"c").with_c_str(|__s| (*c3.borrow()).name
-                [..(*c3.borrow()).name.len().saturating_sub(1)]
-                == *__s))
-    );
-    assert!(((*c1.borrow()).data.is_empty()) && ((*c1.borrow()).name.len() <= 1));
+    assert!((c2.data.len() == 2_usize) && ((*c3.borrow()).data.len() == 2_usize));
+    assert!((*c1.borrow()).data.is_empty());
     let c4: Value<Copyable> = Rc::new(RefCell::new(<Copyable>::default()));
     ({ CopyableImpl::move_assign(&c4.as_pointer(), c3.as_pointer()) });
     assert!(
-        (((vec_elem!(c4.as_pointer(), data, 1_usize).read()) == 2)
-            && (Ptr::<i8>::from_string_literal(b"c").with_c_str(|__s| (*c4.borrow()).name
-                [..(*c4.borrow()).name.len().saturating_sub(1)]
-                == *__s)))
+        ((vec_elem!(c4.as_pointer(), data, 1_usize).read()) == 2)
             && ((*c3.borrow()).data.is_empty())
     );
     let h1: Value<Holder> = Rc::new(RefCell::new(Holder::new({ 4 })));
@@ -505,7 +478,6 @@ impl CopyableImpl for Ptr<Copyable> {
         field_ref!((*self), data)
             .as_pointer()
             .write(field!(_a0, data).with_mut(std::mem::take));
-        field!((*self), name).write({ { (*_a0.upgrade().deref()).name.clone() } });
         return (*self).clone();
     }
 }

tests/unit/out/unsafe/copy_move_defaulted.rs

@@ -181,35 +181,22 @@ impl Owner {
     }
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe)]
+#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
 pub struct Copyable {
     pub data: Vec<i32>,
-    pub name: Vec<libc::c_char>,
 }
 impl Copyable {
     pub unsafe fn move_from(_a0: *mut Copyable) -> Self {
         let mut this = Self {
             data: std::mem::take(&mut (*_a0).data),
-            name: std::mem::take(&mut (*_a0).name),
         };
         this
     }
     pub unsafe fn move_assign(&mut self, _a0: *mut Copyable) -> *mut Copyable {
         self.data = std::mem::take(&mut (*_a0).data);
-        self.name = ((*_a0).name).clone();
         return &mut (*(self as *mut Copyable));
     }
 }
-impl Default for Copyable {
-    fn default() -> Self {
-        unsafe {
-            Copyable {
-                data: Default::default(),
-                name: vec![0],
-            }
-        }
-    }
-}
 #[repr(C)]
 #[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, DestructorUnsafe, Default)]
 pub struct Holder {
@@ -410,34 +397,14 @@ unsafe fn main_0() -> i32 {
     );
     let mut c1: Copyable = Copyable {
         data: Vec::from([1, 2]),
-        name: {
-            let s = c"c".as_ptr();
-            std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
-                .to_vec()
-        },
     };
     let mut c2: Copyable = c1.clone();
     let mut c3: Copyable = Copyable::move_from({ &mut c1 });
-    assert!(
-        (((c2.data.len()) == (2_usize)) && ((c3.data.len()) == (2_usize)))
-            && (c3.name == {
-                let s = c"c".as_ptr();
-                std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
-                    .to_vec()
-            })
-    );
-    assert!((c1.data.is_empty()) && (c1.name.len() <= 1));
+    assert!(((c2.data.len()) == (2_usize)) && ((c3.data.len()) == (2_usize)));
+    assert!(c1.data.is_empty());
     let mut c4: Copyable = <Copyable>::default();
     (unsafe { Copyable::move_assign(&mut c4, &mut c3) });
-    assert!(
-        (((c4.data[(1_usize)]) == (2))
-            && (c4.name == {
-                let s = c"c".as_ptr();
-                std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
-                    .to_vec()
-            }))
-            && (c3.data.is_empty())
-    );
+    assert!(((c4.data[(1_usize)]) == (2)) && (c3.data.is_empty()));
     let mut h1: Holder = Holder::new({ 4 });
     let _dtor_h1 = ScopedDestructorUnsafe::new(&raw mut h1, Holder::destructor);
     {