Revert "fix(ffi): Fix memory leaks in FFIArray test cleanup"

This reverts commit 5fcb0ea.

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 mut array = FFIArray::new(test_data);
+        let array = FFIArray::new(test_data);
 
         assert!(!array.data.is_null());
         assert_eq!(array.len, len);
@@ -54,22 +54,26 @@ mod tests {
             assert_eq!(slice.len(), len);
             assert_eq!(slice, &[1, 2, 3, 4, 5]);
 
-            dash_spv_ffi_array_destroy(&mut array as *mut FFIArray);
+            // Allocate on heap for proper FFI destroy
+            let array_ptr = Box::into_raw(Box::new(array));
+            dash_spv_ffi_array_destroy(array_ptr);
         }
     }
 
     #[test]
     fn test_ffi_array_empty() {
         let empty_vec: Vec<u8> = vec![];
-        let mut array = FFIArray::new(empty_vec);
+        let array = FFIArray::new(empty_vec);
 
         assert_eq!(array.len, 0);
 
         unsafe {
             let slice = array.as_slice::<u8>();
             assert_eq!(slice.len(), 0);
 
-            dash_spv_ffi_array_destroy(&mut array as *mut FFIArray);
+            // 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/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 mut small_ffi = FFIArray::new(small_array);
+            let small_ffi = FFIArray::new(small_array);
             assert!(!small_ffi.data.is_null());
             assert_eq!(small_ffi.len, 5);
-            dash_spv_ffi_array_destroy(&mut small_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(small_ffi)));
 
             // Test with large array
             let large_array: Vec<u64> = (0..100_000).collect();
-            let mut large_ffi = FFIArray::new(large_array);
+            let large_ffi = FFIArray::new(large_array);
             assert!(!large_ffi.data.is_null());
             assert_eq!(large_ffi.len, 100_000);
-            dash_spv_ffi_array_destroy(&mut large_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(large_ffi)));
 
             // Test with empty array
             let empty_array: Vec<u8> = vec![];
-            let mut empty_ffi = FFIArray::new(empty_array);
+            let 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(&mut empty_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_ffi)));
         }
     }
 
@@ -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 mut ffi_array = FFIArray::new(array);
+                        let ffi_array = FFIArray::new(array);
 
                         // Simulate some work
                         thread::sleep(Duration::from_micros(10));
 
-                        dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
+                        dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
                     }
                 }
             });
@@ -163,11 +163,11 @@ mod tests {
 
                 // Array allocation
                 let large_array: Vec<u8> = vec![0xFF; size];
-                let mut ffi_array = FFIArray::new(large_array);
+                let ffi_array = FFIArray::new(large_array);
                 assert!(!ffi_array.data.is_null());
                 assert_eq!(ffi_array.len, size);
 
-                dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
+                dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
             }
         }
     }
@@ -192,18 +192,18 @@ mod tests {
             dash_spv_ffi_string_destroy(null_string);
 
             // Test with array
-            let mut ffi_array = FFIArray::new(vec![1u32, 2, 3]);
-            dash_spv_ffi_array_destroy(&mut ffi_array as *mut FFIArray);
+            let ffi_array = FFIArray::new(vec![1u32, 2, 3]);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(ffi_array)));
 
             // Destroying with null should be safe
-            let mut null_array = FFIArray {
+            let null_array = FFIArray {
                 data: std::ptr::null_mut(),
                 len: 0,
                 capacity: 0,
                 elem_size: 0,
                 elem_align: 1,
             };
-            dash_spv_ffi_array_destroy(&mut null_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(null_array)));
         }
     }
 
@@ -215,21 +215,21 @@ mod tests {
 
             // u8 - 1 byte alignment
             let u8_array = vec![1u8, 2, 3, 4];
-            let mut u8_ffi = FFIArray::new(u8_array);
+            let u8_ffi = FFIArray::new(u8_array);
             assert_eq!(u8_ffi.data as usize % std::mem::align_of::<u8>(), 0);
-            dash_spv_ffi_array_destroy(&mut u8_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u8_ffi)));
 
             // u32 - 4 byte alignment
             let u32_array = vec![1u32, 2, 3, 4];
-            let mut u32_ffi = FFIArray::new(u32_array);
+            let u32_ffi = FFIArray::new(u32_array);
             assert_eq!(u32_ffi.data as usize % std::mem::align_of::<u32>(), 0);
-            dash_spv_ffi_array_destroy(&mut u32_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u32_ffi)));
 
             // u64 - 8 byte alignment
             let u64_array = vec![1u64, 2, 3, 4];
-            let mut u64_ffi = FFIArray::new(u64_array);
+            let u64_ffi = FFIArray::new(u64_array);
             assert_eq!(u64_ffi.data as usize % std::mem::align_of::<u64>(), 0);
-            dash_spv_ffi_array_destroy(&mut u64_ffi as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(u64_ffi)));
         }
     }
 
@@ -341,10 +341,10 @@ mod tests {
 
             // Empty array
             let empty_vec: Vec<u8> = vec![];
-            let mut empty_array = FFIArray::new(empty_vec);
+            let empty_array = FFIArray::new(empty_vec);
             assert!(!empty_array.data.is_null());
             assert_eq!(empty_array.len, 0);
-            dash_spv_ffi_array_destroy(&mut empty_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_array)));
         }
     }
 
@@ -407,8 +407,8 @@ mod tests {
                     dash_spv_ffi_string_destroy(s);
                 }
 
-                for mut a in arrays {
-                    dash_spv_ffi_array_destroy(&mut a as *mut FFIArray);
+                for a in arrays {
+                    dash_spv_ffi_array_destroy(Box::into_raw(Box::new(a)));
                 }
 
                 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 mut array = FFIArray::new(vec![1u32, 2, 3, 4, 5]);
+            let 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(&mut array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(array)));
         }
     }
 }

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 mut empty_array = FFIArray::new(empty);
+        let 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(&mut empty_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(empty_array)));
         }
 
         // Test single element
         let single = vec![42u32];
-        let mut single_array = FFIArray::new(single);
+        let 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(&mut single_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(single_array)));
         }
 
         // Test large array
         let large: Vec<u32> = (0..10000).collect();
-        let mut large_array = FFIArray::new(large.clone());
+        let 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(&mut large_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(large_array)));
         }
     }
 
     #[test]
     fn test_ffi_array_memory_alignment() {
         // Test with u8
         let bytes: Vec<u8> = vec![1, 2, 3, 4];
-        let mut byte_array = FFIArray::new(bytes);
+        let 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(&mut byte_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(byte_array)));
         }
 
         // Test with u64 (requires 8-byte alignment)
         let longs: Vec<u64> = vec![u64::MAX, 0, 42];
-        let mut long_array = FFIArray::new(longs);
+        let 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(&mut long_array as *mut FFIArray);
+            dash_spv_ffi_array_destroy(Box::into_raw(Box::new(long_array)));
         }
     }