Add test for sending message to a wrapped object

This appears to leak memory, but it is a idiom that is used in
quite many places.

To observe the leak, try running
    cargo test --no-run && leaks -atExit -- ./target/debug/objc-c36d5ae3a7514045

To see it disappear, comment out the line that does
`msg_send![obj, isEqual:obj];` in the test.

Author: scoopr

src/message/mod.rs

@@ -293,4 +293,11 @@ mod tests {
         // Unimplemented selector
         assert!(obj.verify_message::<(u32,), ()>(sel!(setFoo)).is_err());
     }
+
+    #[test]
+    fn test_send_message_wrapped_object() {
+        let obj = test_utils::WrappedObject::new();
+        unsafe { msg_send![obj, isEqual:obj]; }
+    }
+
 }

src/test_utils.rs

@@ -177,3 +177,37 @@ pub fn custom_subclass() -> &'static Class {
 pub fn custom_subclass_object() -> CustomObject {
     CustomObject::new(custom_subclass())
 }
+
+pub struct WrappedObject(std::ptr::NonNull<crate::runtime::Object>);
+pub enum WrappedObjectRef {}
+impl WrappedObject {
+    pub fn new() -> Self {
+        let cls = class!(NSObject);
+        unsafe {
+            let obj: *mut crate::runtime::Object = msg_send![cls, alloc];
+            let res: Self = msg_send![obj, init];
+            res
+        }
+    }
+}
+
+unsafe impl crate::Message for WrappedObject {}
+unsafe impl crate::Message for WrappedObjectRef {}
+
+impl Deref for WrappedObject {
+    type Target = WrappedObjectRef;
+
+    fn deref(&self) -> &WrappedObjectRef {
+        let obj_ptr = self.0.as_ptr();
+        let ref_ptr = obj_ptr as *const WrappedObjectRef;
+        unsafe { &*ref_ptr }
+    }
+}
+
+impl Drop for WrappedObject {
+    fn drop(&mut self) {
+        unsafe {
+            msg_send![self.0.as_ptr(), release];
+        }
+    }
+}