use our dictbuilder in test

Author: folkertdev

test-libzstd-rs-sys/src/decompress.rs

@@ -844,128 +844,126 @@ mod fastest_wasm_zlib_continue {
 fn decompress_using_dict() {
     use std::ffi::c_void;
 
-    use libzstd_rs_sys::*;
-
     let input_data = "The quick brown fox jumps high";
 
-    let (compressed, dict_buffer) = unsafe {
-        use zstd_sys::*;
-
-        let samples: [&str; 16] = [
-            "The quick brown fox jumps over the lazy dog",
-            "The quick brown fox jumps high",
-            "The slow turtle crawls under the energetic cat",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
-            "Pack my box with five dozen liquor jugs",
-            "Bright vixens jump; dozy fowl quack",
-            "Sphinx of black quartz, judge my vow",
-            "How razorback-jumping frogs can level six piqued gymnasts",
-            "Crazy Fredrick bought many very exquisite opal jewels",
-            "Five quacking zephyrs jolt my wax bed",
-            "Jackdaws love my big sphinx of quartz",
-            "Two driven jocks help fax my big quiz",
-            "The wizard quickly jinxed the gnomes before they vaporized",
-            "Quick zephyrs blow, vexing daft Jim",
-            "Heavy boxes perform quick waltzes and jigs",
-            "Jovial harpooned sharks quizzed exotic men drinking water",
-        ];
-
-        let mut sample_data = Vec::new();
-
-        let mut sample_sizes = Vec::new();
-
-        for &s in &samples {
-            sample_data.extend_from_slice(s.as_bytes());
-
-            sample_sizes.push(s.len());
-        }
+    let samples: [&str; 16] = [
+        "The quick brown fox jumps over the lazy dog",
+        "The quick brown fox jumps high",
+        "The slow turtle crawls under the energetic cat",
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+        "Pack my box with five dozen liquor jugs",
+        "Bright vixens jump; dozy fowl quack",
+        "Sphinx of black quartz, judge my vow",
+        "How razorback-jumping frogs can level six piqued gymnasts",
+        "Crazy Fredrick bought many very exquisite opal jewels",
+        "Five quacking zephyrs jolt my wax bed",
+        "Jackdaws love my big sphinx of quartz",
+        "Two driven jocks help fax my big quiz",
+        "The wizard quickly jinxed the gnomes before they vaporized",
+        "Quick zephyrs blow, vexing daft Jim",
+        "Heavy boxes perform quick waltzes and jigs",
+        "Jovial harpooned sharks quizzed exotic men drinking water",
+    ];
+
+    assert_eq_rs_c!({
+        let (compressed, dict_buffer) = unsafe {
+            let mut sample_data = Vec::new();
+
+            let mut sample_sizes = Vec::new();
+
+            for &s in &samples {
+                sample_data.extend_from_slice(s.as_bytes());
+
+                sample_sizes.push(s.len());
+            }
 
-        let dict_capacity = 16 * 1024;
+            let dict_capacity = 16 * 1024;
 
-        let mut dict_buffer = vec![0u8; dict_capacity];
+            let mut dict_buffer = vec![0u8; dict_capacity];
 
-        let dict_size = ZDICT_trainFromBuffer(
-            dict_buffer.as_mut_ptr() as *mut c_void,
-            dict_buffer.len(),
-            sample_data.as_ptr() as *const c_void,
-            sample_sizes.as_ptr(),
-            dbg!(sample_sizes.len() as u32),
-        );
+            let dict_size = ZDICT_trainFromBuffer(
+                dict_buffer.as_mut_ptr() as *mut c_void,
+                dict_buffer.len(),
+                sample_data.as_ptr() as *const c_void,
+                sample_sizes.as_ptr(),
+                sample_sizes.len() as u32,
+            );
 
-        assert_eq!(
-            ZDICT_isError(dict_size),
-            0,
-            "Dict training failed {:?}",
-            CStr::from_ptr(ZDICT_getErrorName(dict_size)).to_str(),
-        );
+            assert_eq!(
+                ZDICT_isError(dict_size),
+                0,
+                "Dict training failed {:?}",
+                CStr::from_ptr(ZDICT_getErrorName(dict_size)).to_str(),
+            );
 
-        dict_buffer.truncate(dict_size);
+            dict_buffer.truncate(dict_size);
 
-        println!("Dictionary size: {}", dict_size);
+            println!("Dictionary size: {}", dict_size);
 
-        let cctx = ZSTD_createCCtx();
+            let cctx = ZSTD_createCCtx();
 
-        assert!(!cctx.is_null());
+            assert!(!cctx.is_null());
 
-        let max_compressed_size = ZSTD_compressBound(input_data.len());
+            let max_compressed_size = ZSTD_compressBound(input_data.len());
 
-        let mut compressed = vec![0u8; max_compressed_size];
+            let mut compressed = vec![0u8; max_compressed_size];
 
-        let compressed_size = ZSTD_compress_usingDict(
-            cctx,
-            compressed.as_mut_ptr() as *mut c_void,
-            compressed.len(),
-            input_data.as_bytes().as_ptr() as *const c_void,
-            input_data.len(),
-            dict_buffer.as_ptr() as *const c_void,
-            dict_buffer.len(),
-            3, // compression level
-        );
+            let compressed_size = ZSTD_compress_usingDict(
+                cctx,
+                compressed.as_mut_ptr() as *mut c_void,
+                compressed.len(),
+                input_data.as_bytes().as_ptr() as *const c_void,
+                input_data.len(),
+                dict_buffer.as_ptr() as *const c_void,
+                dict_buffer.len(),
+                3, // compression level
+            );
 
-        assert_eq!(ZSTD_isError(compressed_size), 0, "Compression failed");
+            assert_eq!(ZSTD_isError(compressed_size), 0, "Compression failed");
 
-        compressed.truncate(compressed_size);
+            compressed.truncate(compressed_size);
 
-        println!("Compressed size: {}", compressed_size);
+            println!("Compressed size: {}", compressed_size);
 
-        ZSTD_freeCCtx(cctx);
+            ZSTD_freeCCtx(cctx);
 
-        (compressed, dict_buffer)
-    };
+            (compressed, dict_buffer)
+        };
 
-    unsafe {
-        let dctx = ZSTD_createDCtx();
+        unsafe {
+            let dctx = ZSTD_createDCtx();
 
-        assert!(!dctx.is_null());
+            assert!(!dctx.is_null());
 
-        // Initialize decompression with the raw dictionary buffer
+            // Initialize decompression with the raw dictionary buffer
 
-        let res = ZSTD_decompressBegin_usingDict(
-            dctx,
-            dict_buffer.as_ptr() as *const c_void,
-            dict_buffer.len(),
-        );
+            let res = ZSTD_decompressBegin_usingDict(
+                dctx,
+                dict_buffer.as_ptr() as *const c_void,
+                dict_buffer.len(),
+            );
 
-        assert_eq!(ZSTD_isError(res), 0, "Init decompression failed");
+            assert_eq!(ZSTD_isError(res), 0, "Init decompression failed");
 
-        let mut decompressed = vec![0u8; input_data.len()];
+            let mut decompressed = vec![0u8; input_data.len()];
 
-        let decompressed_size = ZSTD_decompress_usingDict(
-            dctx,
-            decompressed.as_mut_ptr() as *mut c_void,
-            decompressed.len(),
-            compressed.as_ptr() as *const c_void,
-            compressed.len(),
-            dict_buffer.as_ptr() as *const c_void,
-            dict_buffer.len(),
-        );
+            let decompressed_size = ZSTD_decompress_usingDict(
+                dctx,
+                decompressed.as_mut_ptr() as *mut c_void,
+                decompressed.len(),
+                compressed.as_ptr() as *const c_void,
+                compressed.len(),
+                dict_buffer.as_ptr() as *const c_void,
+                dict_buffer.len(),
+            );
 
-        assert_eq!(ZSTD_isError(decompressed_size), 0, "Decompression failed");
+            assert_eq!(ZSTD_isError(decompressed_size), 0, "Decompression failed");
 
-        ZSTD_freeDCtx(dctx);
+            ZSTD_freeDCtx(dctx);
 
-        assert_eq!(input_data, String::from_utf8(decompressed).unwrap());
-    }
+            assert_eq!(input_data, String::from_utf8(decompressed).unwrap());
+        }
+    });
 }
 
 #[test]

test-libzstd-rs-sys/src/lib.rs

@@ -10,6 +10,7 @@ macro_rules! assert_eq_rs_c {
     ($tt:tt) => {{
         #[cfg(not(miri))]
         #[allow(clippy::macro_metavars_in_unsafe)]
+        #[allow(unused_unsafe)]
         let _c = unsafe {
             use zstd_sys::*;
 
@@ -18,6 +19,7 @@ macro_rules! assert_eq_rs_c {
         };
 
         #[allow(clippy::macro_metavars_in_unsafe)]
+        #[allow(unused_unsafe)]
         let _rs = unsafe {
             use libzstd_rs_sys::*;