Test runtime introspection on a class created by Objective-C

In particular, I wanted to make sure that ivars actually work as they should

Author: madsmtm

tests/Cargo.toml

@@ -31,6 +31,8 @@ gnustep-2-0 = ["gnustep-1-9", "block2/gnustep-2-0", "objc2-foundation/gnustep-2-
 gnustep-2-1 = ["gnustep-2-0", "block2/gnustep-2-1", "objc2-foundation/gnustep-2-1"]
 winobjc = ["gnustep-1-8", "block2/winobjc", "objc2-foundation/winobjc"]
 
+malloc = ["objc2/malloc"]
+
 [dependencies]
 block2 = { path = "../block2", default-features = false }
 block-sys = { path = "../block-sys", default-features = false }

tests/build.rs

@@ -1,12 +1,12 @@
 use std::env;
 
 fn main() {
-    println!("cargo:rerun-if-changed=extern/block_utils.c");
-    println!("cargo:rerun-if-changed=extern/encode_utils.m");
+    println!("cargo:rerun-if-changed=build.rs");
 
     let mut builder = cc::Build::new();
     builder.compiler("clang");
     builder.file("extern/block_utils.c");
+    println!("cargo:rerun-if-changed=extern/block_utils.c");
 
     for flag in env::var("DEP_BLOCK_0_0_CC_ARGS").unwrap().split(' ') {
         builder.flag(flag);
@@ -17,13 +17,16 @@ fn main() {
     let mut builder = cc::Build::new();
     builder.compiler("clang");
     builder.file("extern/encode_utils.m");
+    builder.file("extern/test_object.m");
+    println!("cargo:rerun-if-changed=extern/encode_utils.m");
+    println!("cargo:rerun-if-changed=extern/test_object.m");
 
     for flag in env::var("DEP_OBJC_0_2_CC_ARGS").unwrap().split(' ') {
         builder.flag(flag);
     }
 
+    builder.compile("libobjc_utils.a");
+
     // For assembly tests
     println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
-
-    builder.compile("libencode_utils.a");
 }

tests/extern/test_object.m

@@ -0,0 +1,47 @@
+#include <Foundation/NSObject.h>
+
+@interface MyTestObject: NSObject <NSObject> {
+    int var1;
+    BOOL var2;
+}
+
++ (instancetype) getAutoreleasedInstance;
++ (int) add: (int) a and: (int) b;
+
+- (int) var1;
+- (void) addToVar1: (int) number;
+
+- (BOOL) var2;
+@end
+
+
+@implementation MyTestObject
+- (id)init {
+    self = [super init];
+    if (self) {
+        var1 = 42;
+        var2 = YES;
+    }
+    return self;
+}
+
++ (instancetype) getAutoreleasedInstance {
+    return [[MyTestObject alloc] init];
+}
+
++ (int) add: (int) a and: (int) b {
+    return a + b;
+}
+
+- (int) var1 {
+    return var1;
+}
+
+- (void) addToVar1: (int) number {
+    var1 += number;
+}
+
+- (BOOL) var2 {
+    return var2;
+}
+@end

tests/src/lib.rs

@@ -10,6 +10,9 @@ extern crate std;
 pub mod ffi;
 #[cfg(test)]
 mod test_encode_utils;
+#[cfg(test)]
+mod test_object;
+
 use crate::ffi::LargeStruct;
 
 pub fn get_int_block_with(i: i32) -> RcBlock<(), i32> {

tests/src/test_object.rs

@@ -0,0 +1,161 @@
+use core::mem::size_of;
+use std::os::raw::c_int;
+
+use objc2::rc::{autoreleasepool, AutoreleasePool, Id, Owned};
+use objc2::runtime::{Bool, Class, Protocol};
+#[cfg(feature = "malloc")]
+use objc2::sel;
+use objc2::{class, msg_send, msg_send_bool};
+use objc2_foundation::NSObject;
+
+#[repr(C)]
+struct MyTestObject {
+    inner: NSObject,
+}
+
+unsafe impl ::objc2::Message for MyTestObject {}
+
+unsafe impl ::objc2::RefEncode for MyTestObject {
+    const ENCODING_REF: ::objc2::Encoding<'static> = ::objc2::Encoding::Object;
+}
+
+impl MyTestObject {
+    fn class() -> &'static Class {
+        class!(MyTestObject)
+    }
+
+    fn new() -> Id<Self, Owned> {
+        let cls = Self::class();
+        unsafe { Id::new(msg_send![cls, new]).unwrap() }
+    }
+
+    fn new_autoreleased<'p>(pool: &'p AutoreleasePool) -> &'p Self {
+        let cls = Self::class();
+        let ptr: *const Self = unsafe { msg_send![cls, getAutoreleasedInstance] };
+        unsafe { pool.ptr_as_ref(ptr) }
+    }
+
+    fn add_numbers(a: c_int, b: c_int) -> c_int {
+        let cls = Self::class();
+        unsafe { msg_send![cls, add: a, and: b] }
+    }
+
+    fn var1(&self) -> c_int {
+        unsafe { msg_send![self, var1] }
+    }
+
+    fn var1_ivar(&self) -> &c_int {
+        unsafe { self.inner.ivar("var1") }
+    }
+
+    fn var1_ivar_mut(&mut self) -> &mut c_int {
+        unsafe { self.inner.ivar_mut("var1") }
+    }
+
+    fn add_to_ivar1(&mut self, number: c_int) {
+        unsafe { msg_send![self, addToVar1: number] }
+    }
+
+    fn var2(&self) -> bool {
+        unsafe { msg_send_bool![self, var2] }
+    }
+
+    fn var2_ivar(&self) -> &Bool {
+        unsafe { self.inner.ivar("var2") }
+    }
+
+    fn var2_ivar_mut(&mut self) -> &mut Bool {
+        unsafe { self.inner.ivar_mut("var2") }
+    }
+}
+
+#[cfg(feature = "malloc")]
+macro_rules! assert_in {
+    ($item:expr, $lst:expr) => {{
+        let mut found = false;
+        for &x in $lst.iter() {
+            if x == $item {
+                found = true;
+            }
+        }
+        assert!(
+            found,
+            "Did not find {} in {}",
+            stringify!($item),
+            stringify!($lst),
+        );
+    }};
+}
+
+#[test]
+fn test_class() {
+    let cls = MyTestObject::class();
+    assert_eq!(MyTestObject::add_numbers(-3, 15), 12);
+
+    #[cfg(feature = "malloc")]
+    {
+        let classes = Class::classes();
+        assert_eq!(classes.len(), Class::classes_count());
+        assert_in!(cls, classes);
+    }
+
+    // Test objc2::runtime functionality
+    assert_eq!(Class::get("MyTestObject"), Some(cls));
+    assert_ne!(cls, class!(NSObject));
+    assert_eq!(cls.name(), "MyTestObject");
+    assert_eq!(cls.superclass(), Some(class!(NSObject)));
+    assert_eq!(cls.metaclass().name(), "MyTestObject");
+    assert_ne!(cls.metaclass(), cls);
+    assert_eq!(cls.instance_size(), {
+        #[repr(C)]
+        struct MyTestObjectLayout {
+            isa: *const Class,
+            var1: c_int,
+            var2: Bool,
+        }
+        size_of::<MyTestObjectLayout>()
+    });
+
+    let protocol = Protocol::get("NSObject").unwrap();
+    assert!(cls.conforms_to(protocol));
+    assert!(!cls.conforms_to(Protocol::get("NSCopying").unwrap()));
+    #[cfg(feature = "malloc")]
+    assert_in!(protocol, cls.adopted_protocols());
+
+    #[cfg(feature = "malloc")]
+    {
+        let method = cls.instance_method(sel!(addToVar1:)).unwrap();
+        assert_in!(method, cls.instance_methods());
+
+        let ivar = cls.instance_variable("var1").unwrap();
+        assert_in!(ivar, cls.instance_variables());
+    }
+}
+
+#[test]
+fn test_object() {
+    autoreleasepool(|pool| {
+        let _obj = MyTestObject::new_autoreleased(pool);
+    });
+
+    let mut obj = MyTestObject::new();
+    assert_eq!((*obj.inner).class(), MyTestObject::class());
+
+    assert_eq!(obj.var1(), 42);
+    assert_eq!(*obj.var1_ivar(), 42);
+
+    obj.add_to_ivar1(3);
+    assert_eq!(obj.var1(), 45);
+    assert_eq!(*obj.var1_ivar(), 45);
+
+    *obj.var1_ivar_mut() = 100;
+    assert_eq!(obj.var1(), 100);
+    assert_eq!(*obj.var1_ivar(), 100);
+
+    assert!(obj.var2());
+    assert!(obj.var2_ivar().is_true());
+
+    *obj.var2_ivar_mut() = Bool::NO;
+    assert!(!obj.var2());
+    assert!(obj.var2_ivar().is_false());
+}