structured-zstd 0.0.49

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::*;
use std::format;

fn corpus() -> Vec<u8> {
    let mut data = Vec::new();
    for i in 0..500u32 {
        data.extend_from_slice(
            format!("tenant=demo table=orders key={i} region=eu payload=aaaaabbbbbccccdddd\n")
                .as_bytes(),
        );
    }
    data
}

#[test]
fn fastcover_raw_produces_non_empty_dict() {
    let sample = corpus();
    let dict = train_fastcover_raw(
        sample.as_slice(),
        4096,
        FastCoverParams {
            k: 256,
            d: 8,
            f: 20,
            accel: 1,
        },
    );
    assert!(!dict.is_empty());
    assert!(dict.len() <= 4096);
}

#[test]
fn fastcover_raw_returns_empty_for_empty_or_zero_budget() {
    let sample = corpus();
    let params = FastCoverParams {
        k: 256,
        d: 8,
        f: 20,
        accel: 1,
    };
    assert!(train_fastcover_raw(&[], 1024, params).is_empty());
    assert!(train_fastcover_raw(sample.as_slice(), 0, params).is_empty());
}

#[test]
fn fastcover_optimizer_selects_valid_params() {
    let sample = corpus();
    let (dict, tuned) = optimize_fastcover_raw(
        sample.as_slice(),
        4096,
        0.75,
        1,
        &[6, 8],
        &[18, 20],
        &[128, 256],
    );
    assert!(!dict.is_empty());
    assert!([6, 8].contains(&tuned.d));
    assert!([18, 20].contains(&tuned.f));
    assert!([128, 256].contains(&tuned.k));
}

#[test]
fn fastcover_optimizer_falls_back_when_k_candidates_empty() {
    let sample = corpus();
    let (dict, tuned) =
        optimize_fastcover_raw(sample.as_slice(), 4096, 0.75, 1, &[6, 8], &[18, 20], &[]);
    assert!(!dict.is_empty());
    assert!(DEFAULT_K_CANDIDATES.contains(&tuned.k));
}

#[test]
fn fastcover_optimizer_handles_one_byte_sample_without_panic() {
    let sample = [0xAB];
    let (dict, tuned) = optimize_fastcover_raw(&sample, 16, 0.75, 1, &[], &[], &[]);
    assert!(!dict.is_empty());
    assert!(dict.len() <= 16);
    assert!(DEFAULT_K_CANDIDATES.contains(&tuned.k));
    assert!(DEFAULT_D_CANDIDATES.contains(&tuned.d));
    assert!(DEFAULT_F_CANDIDATES.contains(&tuned.f));
}

#[test]
fn fastcover_optimizer_seeds_winner_when_all_scores_are_zero() {
    let sample = b"abcdefghijklmnopqrst";
    let (dict, tuned) = optimize_fastcover_raw(sample, 16, 0.9, 1, &[6], &[16], &[8]);
    assert!(!dict.is_empty());
    assert_eq!(tuned.k, 16);
    assert_eq!(tuned.d, 6);
    assert_eq!(tuned.f, 16);
    assert_eq!(tuned.score, 0);
}

#[test]
fn fastcover_optimizer_handles_zero_dict_budget() {
    let sample = corpus();
    let (dict, tuned) = optimize_fastcover_raw(
        sample.as_slice(),
        0,
        0.75,
        1,
        &[6, 8],
        &[18, 20],
        &[128, 256],
    );
    assert!(dict.is_empty());
    assert!([6, 8].contains(&tuned.d));
    assert!([18, 20].contains(&tuned.f));
    assert!([128, 256].contains(&tuned.k));
}

#[test]
fn fastcover_optimizer_clamps_extreme_split_points() {
    let sample = corpus();
    let (dict_low, tuned_low) =
        optimize_fastcover_raw(sample.as_slice(), 2048, 0.0, 1, &[6], &[18], &[128]);
    let (dict_high, tuned_high) =
        optimize_fastcover_raw(sample.as_slice(), 2048, 1.0, 1, &[6], &[18], &[128]);
    assert!(!dict_low.is_empty());
    assert!(!dict_high.is_empty());
    assert_eq!(tuned_low.k, 128);
    assert_eq!(tuned_high.k, 128);
}

#[test]
fn fastcover_optimizer_reports_normalized_params() {
    let sample = corpus();
    let (dict, tuned) =
        optimize_fastcover_raw(sample.as_slice(), 1024, 0.75, 1, &[64], &[42], &[8]);
    assert!(!dict.is_empty());
    assert_eq!(tuned.d, 32);
    assert_eq!(tuned.f, 20);
    assert_eq!(tuned.k, 32);
}