fix: prevent memory leaks in FFI tests (#323)

* Fix `FFIArray` test cleanup memory leaks

The tests were wrapping `FFIArray` in a `Box` before passing to
`dash_spv_ffi_array_destroy`, but that function only frees the internal
data buffer, not the struct itself. This caused the `Box` allocations to leak.

* Free sync progress and stats in `test_client_resource_cleanup`

* Prevent wallet related memory leaks in tests

- Properly keep track of all create wallets and wallet infos and clean them up at the end.
- Head allocate wallet infos like it would happen in real FFI usage and
  free them properly at the end.

* Prevent `FFIError` message leaks in tests

- Modified `set_error`, `set_success`, and `ffi_error_set` macro to
  free previous error messages before setting new ones
- Added `FFIError::free_message` helper for test cleanup
- Added cleanup in all relevalt tests

Author: xdustinface

dash-spv-ffi/tests/test_types.rs

@@ -43,7 +43,7 @@ mod tests {
     fn test_ffi_array_new_and_destroy() {
         let test_data = vec![1u32, 2, 3, 4, 5];
         let len = test_data.len();
-        let array = FFIArray::new(test_data);
+        let mut array = FFIArray::new(test_data);
 
         assert!(!array.data.is_null());
         assert_eq!(array.len, len);
@@ -54,26 +54,22 @@ mod tests {
             assert_eq!(slice.len(), len);
             assert_eq!(slice, &[1, 2, 3, 4, 5]);
 
-            // Allocate on heap for proper FFI destroy
-            let array_ptr = Box::into_raw(Box::new(array));
-            dash_spv_ffi_array_destroy(array_ptr);
+            dash_spv_ffi_array_destroy(&mut array as *mut FFIArray);
         }
     }
 
     #[test]
     fn test_ffi_array_empty() {
         let empty_vec: Vec<u8> = vec![];
-        let array = FFIArray::new(empty_vec);
+        let mut array = FFIArray::new(empty_vec);
 
         assert_eq!(array.len, 0);
 
         unsafe {
             let slice = array.as_slice::<u8>();
             assert_eq!(slice.len(), 0);
 
-            // Allocate on heap for proper FFI destroy
-            let array_ptr = Box::into_raw(Box::new(array));
-            dash_spv_ffi_array_destroy(array_ptr);
+            dash_spv_ffi_array_destroy(&mut array as *mut FFIArray);
         }
     }
 

dash-spv-ffi/tests/unit/test_client_lifecycle.rs

@@ -142,8 +142,11 @@ mod tests {
                 assert!(!client.is_null());
 
                 // Do some operations
-                let _ = dash_spv_ffi_client_get_sync_progress(client);
-                let _ = dash_spv_ffi_client_get_stats(client);
+                let progress = dash_spv_ffi_client_get_sync_progress(client);
+                let stats = dash_spv_ffi_client_get_stats(client);
+
+                dash_spv_ffi_sync_progress_destroy(progress);
+                dash_spv_ffi_spv_stats_destroy(stats);
 
                 dash_spv_ffi_client_destroy(client);
                 dash_spv_ffi_config_destroy(config);

dash-spv-ffi/tests/unit/test_memory_management.rs

@@ -45,25 +45,25 @@ mod tests {
         unsafe {
             // Test with different types and sizes
             let small_array: Vec<u32> = vec![1, 2, 3, 4, 5];
-            let small_ffi = FFIArray::new(small_array);
+            let mut small_ffi = FFIArray::new(small_array);
             assert!(!small_ffi.data.is_null());
             assert_eq!(small_ffi.len, 5);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(small_ffi)));
+            dash_spv_ffi_array_destroy(&mut small_ffi as *mut FFIArray);
 
             // Test with large array
             let large_array: Vec<u64> = (0..100_000).collect();
-            let large_ffi = FFIArray::new(large_array);
+            let mut large_ffi = FFIArray::new(large_array);
             assert!(!large_ffi.data.is_null());
             assert_eq!(large_ffi.len, 100_000);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(large_ffi)));
+            dash_spv_ffi_array_destroy(&mut large_ffi as *mut FFIArray);
 
             // Test with empty array
             let empty_array: Vec<u8> = vec![];
-            let empty_ffi = FFIArray::new(empty_array);
+            let mut empty_ffi = FFIArray::new(empty_array);
             // Even empty arrays have valid pointers
             assert!(!empty_ffi.data.is_null());
             assert_eq!(empty_ffi.len, 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_ffi)));
+            dash_spv_ffi_array_destroy(&mut empty_ffi as *mut FFIArray);
         }
     }
 
@@ -125,12 +125,12 @@ mod tests {
                     // Each thread creates and destroys arrays
                     for j in 0..50 {
                         let array: Vec<u32> = (0..j * 10).collect();
-                        let ffi_array = FFIArray::new(array);
+                        let mut ffi_array = FFIArray::new(array);
 
                         // Simulate some work
                         thread::sleep(Duration::from_micros(10));
 
-                        dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
+                        dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
                     }
                 }
             });
@@ -163,11 +163,11 @@ mod tests {
 
                 // Array allocation
                 let large_array: Vec<u8> = vec![0xFF; size];
-                let ffi_array = FFIArray::new(large_array);
+                let mut ffi_array = FFIArray::new(large_array);
                 assert!(!ffi_array.data.is_null());
                 assert_eq!(ffi_array.len, size);
 
-                dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
+                dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
             }
         }
     }
@@ -192,18 +192,18 @@ mod tests {
             dash_spv_ffi_string_destroy(null_string);
 
             // Test with array
-            let ffi_array = FFIArray::new(vec![1u32, 2, 3]);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
+            let mut ffi_array = FFIArray::new(vec![1u32, 2, 3]);
+            dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
 
             // Destroying with null should be safe
-            let null_array = FFIArray {
+            let mut null_array = FFIArray {
                 data: std::ptr::null_mut(),
                 len: 0,
                 capacity: 0,
                 elem_size: 0,
                 elem_align: 1,
             };
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(null_array)));
+            dash_spv_ffi_array_destroy(&mut null_array as *mut FFIArray);
         }
     }
 
@@ -215,21 +215,21 @@ mod tests {
 
             // u8 - 1 byte alignment
             let u8_array = vec![1u8, 2, 3, 4];
-            let u8_ffi = FFIArray::new(u8_array);
+            let mut u8_ffi = FFIArray::new(u8_array);
             assert_eq!(u8_ffi.data as usize % std::mem::align_of::<u8>(), 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u8_ffi)));
+            dash_spv_ffi_array_destroy(&mut u8_ffi as *mut FFIArray);
 
             // u32 - 4 byte alignment
             let u32_array = vec![1u32, 2, 3, 4];
-            let u32_ffi = FFIArray::new(u32_array);
+            let mut u32_ffi = FFIArray::new(u32_array);
             assert_eq!(u32_ffi.data as usize % std::mem::align_of::<u32>(), 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u32_ffi)));
+            dash_spv_ffi_array_destroy(&mut u32_ffi as *mut FFIArray);
 
             // u64 - 8 byte alignment
             let u64_array = vec![1u64, 2, 3, 4];
-            let u64_ffi = FFIArray::new(u64_array);
+            let mut u64_ffi = FFIArray::new(u64_array);
             assert_eq!(u64_ffi.data as usize % std::mem::align_of::<u64>(), 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u64_ffi)));
+            dash_spv_ffi_array_destroy(&mut u64_ffi as *mut FFIArray);
         }
     }
 
@@ -341,10 +341,10 @@ mod tests {
 
             // Empty array
             let empty_vec: Vec<u8> = vec![];
-            let empty_array = FFIArray::new(empty_vec);
+            let mut empty_array = FFIArray::new(empty_vec);
             assert!(!empty_array.data.is_null());
             assert_eq!(empty_array.len, 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_array)));
+            dash_spv_ffi_array_destroy(&mut empty_array as *mut FFIArray);
         }
     }
 
@@ -407,8 +407,8 @@ mod tests {
                     dash_spv_ffi_string_destroy(s);
                 }
 
-                for a in arrays {
-                    dash_spv_ffi_array_destroy(Box::into_raw(Box::new(a)));
+                for mut a in arrays {
+                    dash_spv_ffi_array_destroy(&mut a as *mut FFIArray);
                 }
 
                 cycle += 1;
@@ -424,7 +424,7 @@ mod tests {
         // Test that memory allocated in one thread can be safely used in another
         unsafe {
             let string = FFIString::new("Allocated in thread 1");
-            let array = FFIArray::new(vec![1u32, 2, 3, 4, 5]);
+            let mut array = FFIArray::new(vec![1u32, 2, 3, 4, 5]);
 
             // Verify we can read the data
             let s = FFIString::from_ptr(string.ptr).unwrap();
@@ -435,7 +435,7 @@ mod tests {
 
             // Clean up
             dash_spv_ffi_string_destroy(string);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(array)));
+            dash_spv_ffi_array_destroy(&mut array as *mut FFIArray);
         }
     }
 }

dash-spv-ffi/tests/unit/test_type_conversions.rs

@@ -61,60 +61,60 @@ mod tests {
     fn test_ffi_array_different_sizes() {
         // Test empty array
         let empty: Vec<u32> = vec![];
-        let empty_array = FFIArray::new(empty);
+        let mut empty_array = FFIArray::new(empty);
         assert_eq!(empty_array.len, 0);
         assert!(!empty_array.data.is_null()); // Even empty vec has allocated pointer
         unsafe {
             let slice = empty_array.as_slice::<u32>();
             assert_eq!(slice.len(), 0);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_array)));
+            dash_spv_ffi_array_destroy(&mut empty_array as *mut FFIArray);
         }
 
         // Test single element
         let single = vec![42u32];
-        let single_array = FFIArray::new(single);
+        let mut single_array = FFIArray::new(single);
         assert_eq!(single_array.len, 1);
         unsafe {
             let slice = single_array.as_slice::<u32>();
             assert_eq!(slice.len(), 1);
             assert_eq!(slice[0], 42);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(single_array)));
+            dash_spv_ffi_array_destroy(&mut single_array as *mut FFIArray);
         }
 
         // Test large array
         let large: Vec<u32> = (0..10000).collect();
-        let large_array = FFIArray::new(large.clone());
+        let mut large_array = FFIArray::new(large.clone());
         assert_eq!(large_array.len, 10000);
         unsafe {
             let slice = large_array.as_slice::<u32>();
             assert_eq!(slice.len(), 10000);
             for (i, &val) in slice.iter().enumerate() {
                 assert_eq!(val, i as u32);
             }
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(large_array)));
+            dash_spv_ffi_array_destroy(&mut large_array as *mut FFIArray);
         }
     }
 
     #[test]
     fn test_ffi_array_memory_alignment() {
         // Test with u8
         let bytes: Vec<u8> = vec![1, 2, 3, 4];
-        let byte_array = FFIArray::new(bytes);
+        let mut byte_array = FFIArray::new(bytes);
         unsafe {
             let slice = byte_array.as_slice::<u8>();
             assert_eq!(slice, &[1, 2, 3, 4]);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(byte_array)));
+            dash_spv_ffi_array_destroy(&mut byte_array as *mut FFIArray);
         }
 
         // Test with u64 (requires 8-byte alignment)
         let longs: Vec<u64> = vec![u64::MAX, 0, 42];
-        let long_array = FFIArray::new(longs);
+        let mut long_array = FFIArray::new(longs);
         unsafe {
             let slice = long_array.as_slice::<u64>();
             assert_eq!(slice[0], u64::MAX);
             assert_eq!(slice[1], 0);
             assert_eq!(slice[2], 42);
-            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(long_array)));
+            dash_spv_ffi_array_destroy(&mut long_array as *mut FFIArray);
         }
     }
 

key-wallet-ffi/src/account_derivation_tests.rs

@@ -59,6 +59,7 @@ mod tests {
             extended_private_key_free(master_xpriv);
             account_free(account);
             wallet::wallet_free(wallet);
+            error.free_message();
         }
     }
 
@@ -97,6 +98,8 @@ mod tests {
             );
             assert_eq!(error.code, FFIErrorCode::InvalidInput);
         }
+
+        unsafe { error.free_message() };
     }
 
     #[test]
@@ -134,6 +137,7 @@ mod tests {
             extended_private_key_free(master_xpriv);
             account_free(account);
             wallet::wallet_free(wallet);
+            error.free_message();
         }
     }
 
@@ -213,6 +217,7 @@ mod tests {
         unsafe {
             account_free(account);
             wallet::wallet_free(wallet);
+            error.free_message();
         }
     }
 

key-wallet-ffi/src/account_tests.rs

@@ -77,6 +77,8 @@ mod tests {
 
         assert_eq!(count, 0);
         assert_eq!(error.code, FFIErrorCode::InvalidInput);
+
+        unsafe { error.free_message() };
     }
 
     #[test]
@@ -105,6 +107,7 @@ mod tests {
         // Clean up
         unsafe {
             wallet::wallet_free(wallet);
+            error.free_message();
         }
     }
 
@@ -190,6 +193,7 @@ mod tests {
         // Clean up
         unsafe {
             wallet::wallet_free(wallet);
+            error.free_message();
         }
     }
 

key-wallet-ffi/src/address_pool.rs

@@ -1135,6 +1135,7 @@ mod tests {
             managed_account_free(account);
             wallet_manager_free_wallet_ids(wallet_ids_out, count_out);
             wallet_manager_free(manager);
+            error.free_message();
         }
     }
 
@@ -1263,6 +1264,7 @@ mod tests {
             managed_account_free(account);
             wallet_manager_free_wallet_ids(wallet_ids_out, count_out);
             wallet_manager_free(manager);
+            error.free_message();
         }
     }
 }