Refactor rc/mod.rs tests

Author: madsmtm

crates/objc2/src/rc/id.rs

@@ -741,10 +741,12 @@ impl<T: UnwindSafe + ?Sized> UnwindSafe for Id<T, Owned> {}
 
 #[cfg(test)]
 mod tests {
+    use core::mem::size_of;
+
     use super::*;
     use crate::msg_send;
     use crate::rc::{__RcTestObject, __ThreadTestData, autoreleasepool};
-    use crate::runtime::Object;
+    use crate::runtime::{NSObject, Object};
 
     #[track_caller]
     fn assert_retain_count(obj: &Object, expected: usize) {
@@ -844,4 +846,28 @@ mod tests {
         let _obj: Id<__RcTestObject, _> = unsafe { Id::cast(obj) };
         expected.assert_current();
     }
+
+    #[repr(C)]
+    struct MyObject<'a> {
+        inner: NSObject,
+        p: PhantomData<&'a str>,
+    }
+
+    /// Test that `Id<T, O>` is covariant over `T`.
+    #[allow(unused)]
+    fn assert_id_variance<'a, 'b, O: Ownership>(
+        obj: &'a Id<MyObject<'static>, O>,
+    ) -> &'a Id<MyObject<'b>, O> {
+        obj
+    }
+
+    #[test]
+    fn test_size_of() {
+        let ptr_size = size_of::<&NSObject>();
+
+        assert_eq!(size_of::<Id<NSObject, Owned>>(), ptr_size);
+        assert_eq!(size_of::<Id<NSObject, Shared>>(), ptr_size);
+        assert_eq!(size_of::<Option<Id<NSObject, Owned>>>(), ptr_size);
+        assert_eq!(size_of::<Option<Id<NSObject, Shared>>>(), ptr_size);
+    }
 }

crates/objc2/src/rc/mod.rs

@@ -74,58 +74,3 @@ pub use self::id_traits::{DefaultId, SliceId, SliceIdMut};
 pub use self::ownership::{Owned, Ownership, Shared};
 pub use self::test_object::{__RcTestObject, __ThreadTestData};
 pub use self::weak_id::WeakId;
-
-#[cfg(test)]
-mod tests {
-    use core::marker::PhantomData;
-    use core::mem::size_of;
-
-    use super::{Id, Owned, Ownership, Shared, WeakId};
-    use crate::runtime::Object;
-
-    #[repr(C)]
-    struct TestType {
-        inner: Object,
-    }
-
-    #[repr(C)]
-    struct MyObject<'a> {
-        inner: Object,
-        p: PhantomData<&'a str>,
-    }
-
-    /// Test that `Id<T, O>` is covariant over `T`.
-    #[allow(unused)]
-    fn assert_id_variance<'a, 'b, O: Ownership>(
-        obj: &'a Id<MyObject<'static>, O>,
-    ) -> &'a Id<MyObject<'b>, O> {
-        obj
-    }
-
-    /// Test that `WeakId<T>` is covariant over `T`.
-    #[allow(unused)]
-    fn assert_weak_id_variance<'a, 'b>(
-        obj: &'a WeakId<MyObject<'static>>,
-    ) -> &'a WeakId<MyObject<'b>> {
-        obj
-    }
-
-    #[test]
-    fn test_size_of() {
-        assert_eq!(size_of::<Id<TestType, Owned>>(), size_of::<&TestType>());
-        assert_eq!(size_of::<Id<TestType, Shared>>(), size_of::<&TestType>());
-        assert_eq!(
-            size_of::<Option<Id<TestType, Owned>>>(),
-            size_of::<&TestType>()
-        );
-        assert_eq!(
-            size_of::<Option<Id<TestType, Shared>>>(),
-            size_of::<&TestType>()
-        );
-
-        assert_eq!(
-            size_of::<Option<WeakId<TestType>>>(),
-            size_of::<*const ()>()
-        );
-    }
-}

crates/objc2/src/rc/weak_id.rs

@@ -149,9 +149,11 @@ impl<T: Message> TryFrom<WeakId<T>> for Id<T, Shared> {
 
 #[cfg(test)]
 mod tests {
+    use core::mem;
+
     use super::*;
     use crate::rc::{__RcTestObject, __ThreadTestData};
-    use crate::runtime::Object;
+    use crate::runtime::NSObject;
 
     #[test]
     fn test_weak() {
@@ -214,8 +216,28 @@ mod tests {
 
     #[test]
     fn test_weak_default() {
-        let weak: WeakId<Object> = WeakId::default();
+        let weak: WeakId<NSObject> = WeakId::default();
         assert!(weak.load().is_none());
         drop(weak);
     }
+
+    #[repr(C)]
+    struct MyObject<'a> {
+        inner: NSObject,
+        p: PhantomData<&'a str>,
+    }
+
+    /// Test that `WeakId<T>` is covariant over `T`.
+    #[allow(unused)]
+    fn assert_variance<'a, 'b>(obj: &'a WeakId<MyObject<'static>>) -> &'a WeakId<MyObject<'b>> {
+        obj
+    }
+
+    #[test]
+    fn test_size_of() {
+        assert_eq!(
+            mem::size_of::<Option<WeakId<NSObject>>>(),
+            mem::size_of::<*const ()>()
+        );
+    }
 }