remove dynamic test

src/deflate.rs

@@ -2520,142 +2520,17 @@ mod test {
         (&mut output[..stream.total_out as usize], ReturnCode::Ok)
     }
 
-    fn compress_slice_dynamic<'a>(
-        output: &'a mut [u8],
-        input: &[u8],
-        config: DeflateConfig,
-    ) -> (&'a mut [u8], ReturnCode) {
-        unsafe fn deflate_dynamic(strm: *mut libz_ng_sys::z_stream, flush: i32) -> std::ffi::c_int {
-            const LIBZ_NG_SO: &str = "/home/folkertdev/rust/zlib-ng/libz-ng.so";
-
-            let lib = libloading::Library::new(LIBZ_NG_SO).unwrap();
-
-            type Func = unsafe extern "C" fn(strm: *mut libz_ng_sys::z_stream, flush: i32) -> i32;
-
-            let f: libloading::Symbol<Func> = lib.get(b"zng_deflate").unwrap();
-
-            f(strm, flush)
-        }
-
-        #[allow(non_camel_case_types)]
-        #[allow(non_snake_case)]
-        unsafe fn deflateInit2_dynamic(
-            strm: *mut libz_ng_sys::z_stream,
-            level: libc::c_int,
-            method: libc::c_int,
-            windowBits: libc::c_int,
-            memLevel: libc::c_int,
-            strategy: libc::c_int,
-        ) -> std::ffi::c_int {
-            const LIBZ_NG_SO: &str = "/home/folkertdev/rust/zlib-ng/libz-ng.so";
-
-            const VERSION: *const libc::c_char = "2.1.4\0".as_ptr() as *const libc::c_char;
-            const STREAM_SIZE: libc::c_int =
-                std::mem::size_of::<libz_ng_sys::z_stream>() as libc::c_int;
-
-            let lib = libloading::Library::new(LIBZ_NG_SO).unwrap();
-
-            type Func = unsafe extern "C" fn(
-                strm: *mut libz_ng_sys::z_stream,
-                level: libc::c_int,
-                method: libc::c_int,
-                windowBits: libc::c_int,
-                memLevel: libc::c_int,
-                strategy: libc::c_int,
-                version: *const libc::c_char,
-                stream_size: libc::c_int,
-            ) -> i32;
-
-            let f: libloading::Symbol<Func> = lib.get(b"zng_deflateInit2_").unwrap();
-
-            f(
-                strm,
-                level,
-                method,
-                windowBits,
-                memLevel,
-                strategy,
-                VERSION,
-                STREAM_SIZE,
-            )
-        }
-
-        let DeflateConfig {
-            level,
-            method,
-            window_bits,
-            mem_level,
-            strategy,
-        } = config;
-
-        let mut stream = libz_ng_sys::z_stream {
-            next_in: input.as_ptr() as *mut u8,
-            avail_in: input.len() as _,
-            total_in: 0,
-            next_out: output.as_mut_ptr(),
-            avail_out: output.len() as _,
-            total_out: 0,
-            msg: std::ptr::null_mut(),
-            state: std::ptr::null_mut(),
-            zalloc: crate::allocate::zcalloc,
-            zfree: crate::allocate::zcfree,
-            opaque: std::ptr::null_mut(),
-            data_type: 0,
-            adler: 0,
-            reserved: 0,
-        };
-
-        unsafe {
-            let err = deflateInit2_dynamic(
-                &mut stream,
-                level,
-                method as i32,
-                window_bits,
-                mem_level,
-                strategy as i32,
-                // b"1.3.0\0".as_ptr() as *const i8,
-                // std::mem::size_of::<libz_ng_sys::z_stream>() as i32,
-            );
-            let return_code = ReturnCode::from(err);
-
-            if return_code != ReturnCode::Ok {
-                return (&mut [], return_code);
-            }
-        };
-
-        // let error = unsafe { libz_ng_sys::deflate(&mut stream, Flush::Finish as _) };
-        let error = unsafe { deflate_dynamic(&mut stream, Flush::Finish as _) };
-
-        let error: ReturnCode = ReturnCode::from(error as i32);
-        assert_eq!(ReturnCode::StreamEnd, error);
-
-        unsafe {
-            let err = libz_ng_sys::deflateEnd(&mut stream);
-            let return_code: ReturnCode = ReturnCode::from(err);
-            assert_eq!(ReturnCode::Ok, return_code);
-        }
-
-        (&mut output[..stream.total_out as usize], ReturnCode::Ok)
-    }
-
     fn fuzz_based_test(input: &str, config: DeflateConfig, expected: &[u8]) {
         let mut output = [0; 1 << 10];
 
         let mut output_ng = [0; 1 << 10];
         let (output_ng, err) = compress_slice_ng(&mut output_ng, input.as_bytes(), config);
         assert_eq!(err, ReturnCode::Ok);
 
-        let mut output_dynamic = [0; 1 << 10];
-        let (output_dynamic, err) =
-            compress_slice_dynamic(&mut output_dynamic, input.as_bytes(), config);
-        assert_eq!(err, ReturnCode::Ok);
-
         let (output, err) = compress_slice(&mut output, input.as_bytes(), config);
         assert_eq!(err, ReturnCode::Ok);
 
-        println!("{:#x?}", &output_ng);
-
-        assert_eq!(output_dynamic, expected);
+        assert_eq!(output_ng, expected);
 
         assert_eq!(output, expected);
     }