Add tests for blocks taking/returning large structs

Author: madsmtm

tests/Cargo.toml

@@ -12,6 +12,7 @@ build = "build.rs"
 [dependencies]
 block2 = { path = "../block2" }
 block-sys = { path = "../block-sys" }
+objc2-encode = { path = "../objc2-encode" }
 
 [build-dependencies]
 cc = "1.0"

tests/extern/block_utils.c

@@ -1,8 +1,14 @@
 #include <stdint.h>
 #include <Block.h>
 
+typedef struct {
+    float x;
+    uint8_t y[100];
+} LargeStruct;
+
 typedef int32_t (^IntBlock)();
 typedef int32_t (^AddBlock)(int32_t);
+typedef LargeStruct (^LargeStructBlock)(LargeStruct);
 
 IntBlock get_int_block() {
     return ^{ return (int32_t)7; };
@@ -27,3 +33,23 @@ int32_t invoke_int_block(IntBlock block) {
 int32_t invoke_add_block(AddBlock block, int32_t a) {
     return block(a);
 }
+
+LargeStructBlock get_large_struct_block() {
+    return ^(LargeStruct s) {
+        s.x -= 1.0;
+        s.y[12] += 1;
+        s.y[99] = 123;
+        return s;
+    };
+}
+
+LargeStructBlock get_large_struct_block_with(LargeStruct a) {
+    return Block_copy(^(LargeStruct s) {
+        (void)s; // Unused
+        return a;
+    });
+}
+
+LargeStruct invoke_large_struct_block(LargeStructBlock block, LargeStruct s) {
+    return block(s);
+}

tests/src/ffi.rs

@@ -1,3 +1,5 @@
+use objc2_encode::{Encode, Encoding};
+
 /// A block that takes no arguments and returns an integer: `int32_t (^)()`.
 #[repr(C)]
 pub struct IntBlock {
@@ -11,6 +13,37 @@ pub struct AddBlock {
     _priv: [u8; 0],
 }
 
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct LargeStruct {
+    pub x: f32,
+    pub y: [u8; 100],
+}
+
+impl LargeStruct {
+    pub fn get() -> Self {
+        let mut y = [10; 100];
+        y[42] = 123;
+        Self { x: 5.0, y }
+    }
+
+    pub fn mutate(&mut self) {
+        self.x -= 1.0;
+        self.y[12] += 1;
+        self.y[99] = 123;
+    }
+}
+
+unsafe impl Encode for LargeStruct {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("LargeStruct", &[f32::ENCODING, <[u8; 100]>::ENCODING]);
+}
+
+#[repr(C)]
+pub struct LargeStructBlock {
+    _priv: [u8; 0],
+}
+
 extern "C" {
     /// Returns a pointer to a global `IntBlock` that returns 7.
     pub fn get_int_block() -> *mut IntBlock;
@@ -24,6 +57,10 @@ extern "C" {
     pub fn invoke_int_block(block: *mut IntBlock) -> i32;
     /// Invokes an `AddBlock` with `a` and returns the result.
     pub fn invoke_add_block(block: *mut AddBlock, a: i32) -> i32;
+
+    pub fn get_large_struct_block() -> *mut LargeStructBlock;
+    pub fn get_large_struct_block_with(i: LargeStruct) -> *mut LargeStructBlock;
+    pub fn invoke_large_struct_block(block: *mut LargeStructBlock, s: LargeStruct) -> LargeStruct;
 }
 
 #[cfg(test)]
@@ -45,4 +82,20 @@ mod tests {
             assert_eq!(invoke_add_block(get_add_block_with(3), 5), 8);
         }
     }
+
+    #[test]
+    fn test_large_struct_block() {
+        let data = LargeStruct::get();
+        let mut expected = data.clone();
+        expected.mutate();
+
+        assert_eq!(
+            unsafe { invoke_large_struct_block(get_large_struct_block(), data) },
+            expected
+        );
+        assert_eq!(
+            unsafe { invoke_large_struct_block(get_large_struct_block_with(expected), data) },
+            expected
+        );
+    }
 }

tests/src/lib.rs

@@ -8,6 +8,7 @@ use block2::{Block, RcBlock};
 extern crate alloc;
 
 pub mod ffi;
+use crate::ffi::LargeStruct;
 
 pub fn get_int_block_with(i: i32) -> RcBlock<(), i32> {
     unsafe {
@@ -33,6 +34,14 @@ pub fn invoke_add_block(block: &Block<(i32,), i32>, a: i32) -> i32 {
     unsafe { ffi::invoke_add_block(ptr as *mut _, a) }
 }
 
+pub fn invoke_large_struct_block(
+    block: &Block<(LargeStruct,), LargeStruct>,
+    x: LargeStruct,
+) -> LargeStruct {
+    let ptr = block as *const _;
+    unsafe { ffi::invoke_large_struct_block(ptr as *mut _, x) }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -103,4 +112,30 @@ mod tests {
         let block = make_block();
         assert_eq!(invoke_int_block(&block), 7);
     }
+
+    #[test]
+    fn test_large_struct_block() {
+        global_block! {
+            static BLOCK = |data: LargeStruct| -> LargeStruct {
+                let mut data = data;
+                data.mutate();
+                data
+            }
+        }
+
+        let data = LargeStruct::get();
+        let mut new_data = data.clone();
+        new_data.mutate();
+
+        assert_eq!(unsafe { BLOCK.call((data,)) }, new_data);
+        assert_eq!(invoke_large_struct_block(&BLOCK, data), new_data);
+
+        let block = ConcreteBlock::new(|mut x: LargeStruct| {
+            x.mutate();
+            x
+        });
+        assert_eq!(invoke_large_struct_block(&block, data), new_data);
+        let block = block.copy();
+        assert_eq!(invoke_large_struct_block(&block, data), new_data);
+    }
 }