structured-zstd 0.0.22

Pure Rust zstd implementation — managed fork of ruzstd. Dictionary decompression, no FFI.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

use std::fs;
use std::path::Path;
use structured_zstd::encoding::{CompressionLevel, compress_to_vec};

mod common;

#[test]
#[ignore = "manual probe — run with --ignored"]
fn corpus_z000033_level22_ratio_breakdown() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("decodecorpus_files/z000033");
    let data = fs::read(&path).expect("z000033 corpus file present");
    println!("Corpus z000033 size: {} bytes", data.len());

    let rust = compress_to_vec(&data[..], CompressionLevel::Level(22));
    let c = zstd::bulk::compress(&data[..], 22).unwrap();
    let delta = rust.len() as i64 - c.len() as i64;
    let pct = (rust.len() as f64 / c.len() as f64 - 1.0) * 100.0;
    println!(
        "Level 22 output:  rust={}  c={}  delta={delta:+}b ({pct:+.4}%)",
        rust.len(),
        c.len()
    );

    // Count block types in each output so we can tell if the gap is
    // structural (different block split decisions) or content
    // (per-block entropy differences within identical splits).
    common::dump_block_breakdown("Rust", &rust);
    common::dump_block_breakdown("C   ", &c);

    // Sanity: outputs must roundtrip.
    let rt = zstd::bulk::decompress(&rust, data.len() + 64).unwrap();
    assert_eq!(
        rt.len(),
        data.len(),
        "rust output decompresses to wrong size"
    );
    assert_eq!(rt, data, "rust output decompresses to different bytes");
}