remove unnecessary dirty tests

Author: joemphilips

bindings/src/ffi_test_utils.rs

@@ -1,12 +1,6 @@
 use std::sync::Arc;
 use crate::error::FFIResult;
 
-use crate::handle::{Out, Ref, HandleShared};
-
-/// Lower level items for debugging wrapper library.
-/// When the FFI crashes without error messages, testing with these might be useful to understand
-/// what is the exact cause of the crash.
-
 /// These tests should be used for asserting that the wrapper code can see the expected
 /// error messages when it fails (or succeeds).
 ffi! {
@@ -21,92 +15,3 @@ ffi! {
     }
 }
 
-
-#[repr(C)]
-pub struct FFITestInputStructWithPtr {
-    fn_ptr: extern "cdecl" fn(*const Self),
-}
-impl FFITestInputStructWithPtr {
-    pub fn call(&self) {
-        (self.fn_ptr)(self as *const _)
-    }
-}
-
-pub struct FFITestOutputStruct {
-    field: Arc<FFITestInputStructWithPtr>
-}
-
-impl FFITestOutputStruct {
-    fn complete(&self) {
-        println!("finished!");
-        self.field.call();
-    }
-}
-
-type FFITestOutputStructHandle<'a> = HandleShared<'a, FFITestOutputStruct>;
-
-type FFIFunctionPointer = extern "cdecl" fn (input: *const FFITestInputStructWithPtr);
-type FFIFunctionPointerWithReturn = extern "cdecl" fn (input: i32) -> i32;
-type FFIFunctionPointerWithReturnRef = extern "cdecl" fn (input: *const i32) -> *const i32;
-
-ffi! {
-    fn ffi_test_function_ptr(struct_arg_ptr: Ref<FFITestInputStructWithPtr>, fn_ptr: Ref<FFIFunctionPointer>) -> FFIResult {
-        // verify that if we pass functoin pointer and wrapper object separately and only calls the formar, it works.
-        let func = unsafe_block!("" => fn_ptr.as_ref());
-        let struct_arg = unsafe_block!("" => struct_arg_ptr.as_ref());
-        (func)(struct_arg);
-        FFIResult::ok()
-    }
-
-    fn ffi_simple_nested_struct(input: Ref<FFIFunctionPointer>, output: Out<FFITestOutputStructHandle>) -> FFIResult {
-        // verify that function pointer can be a member of other object.
-        let input_ref = unsafe_block!(" " => input.as_ref());
-        let result = FFITestOutputStruct { field: Arc::new(FFITestInputStructWithPtr{ fn_ptr: *input_ref }) };
-        result.complete();
-        unsafe_block!("" => output.init(HandleShared::alloc(result)));
-        FFIResult::ok()
-    }
-
-    fn ffi_simple_nested_struct_with_return_value(val_return_fn: Ref<FFIFunctionPointerWithReturn>, ref_return_fn: Ref<FFIFunctionPointerWithReturnRef>) -> FFIResult {
-        // verify that functoin pointer can return value. and it could be seen in wrapper lang side.
-        let val_return_fn_ref = unsafe_block!("" => val_return_fn.as_ref());
-        let ref_return_fn_ref = unsafe_block!("" => ref_return_fn.as_ref());
-
-        let val = (val_return_fn_ref)(33);
-        let r_ptr = (ref_return_fn_ref)(&44);
-        let r = unsafe_block!("" => *r_ptr);
-        println!("val was {}", val);
-        println!("ref was {}", r);
-
-        let val2 = (val_return_fn_ref)(66);
-        let r_ptr2 = (ref_return_fn_ref)(&88);
-        let r2 = unsafe_block!("" => *r_ptr2);
-        println!("val2 was {}", val2);
-        println!("ref2 was {}", r2);
-        FFIResult::ok()
-    }
-
-    fn ffi_test_simple_struct_with_function_pointer(
-        input: Ref<FFITestInputStructWithPtr>,
-        output: Out<FFITestOutputStructHandle>
-    ) -> FFIResult {
-        // this test does not work, it seems that calling a function passed by wrapper struct will cause program to crash.
-        let input_ref = unsafe_block!(" " => input.as_ref());
-        // input_ref.call();
-        let input_arc = unsafe_block!(" " => input.as_arc());
-        // input_arc.call();
-        // let result = FFITestOutputStruct{ field: input_arc };
-        // result.field.call();
-        // unsafe_block!("We know output is not null by wrapper macro. And we know `Out` is writable" => output.init(HandleShared::alloc(result)));
-        FFIResult::ok()
-    }
-
-    fn ffi_test_release(handle: FFITestOutputStructHandle) -> FFIResult {
-        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFITestOutputStructHandle::dealloc(handle, |mut handle| {
-            handle.complete();
-
-            FFIResult::ok()
-        }))
-    }
-
-}