zstd-complete 0.3.0

A pure Rust Zstandard compressor and decompressor with bounded streaming I/O
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

use super::{best_split_mid_by_decompressed_bytes, derive_best_partitions, PreparedRange};
use crate::encoding::{
    blocks::{PreparedBlock, PreparedSequence},
    frame_compressor::OffsetHistory,
};
use alloc::{vec, vec::Vec};

#[test]
fn best_split_mid_biases_toward_balanced_decompressed_bytes() {
    let prepared = PreparedBlock {
        literals: crate::workspace::ReusableVec::from_owned(vec![0; 103]),
        sequences: crate::workspace::ReusableVec::from_owned(vec![
            PreparedSequence {
                ll: 100,
                ml: 100,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 1,
                ml: 1,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 1,
                ml: 1,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 1,
                ml: 1,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
        ]),
    };

    assert_eq!(best_split_mid_by_decompressed_bytes(prepared.as_ref()), 1);
}

#[test]
fn best_split_mid_keeps_even_sequences_centered() {
    let prepared = PreparedBlock {
        literals: crate::workspace::ReusableVec::from_owned(vec![0; 8]),
        sequences: crate::workspace::ReusableVec::from_owned(vec![
            PreparedSequence {
                ll: 2,
                ml: 2,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 2,
                ml: 2,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 2,
                ml: 2,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
            PreparedSequence {
                ll: 2,
                ml: 2,
                raw_offset: 4,
                encoded_offset_value: 0,
            },
        ]),
    };

    assert_eq!(best_split_mid_by_decompressed_bytes(prepared.as_ref()), 2);
}

#[test]
fn derive_best_partitions_respects_partition_budget() {
    let quarter_len = 300;
    let sequence_count = quarter_len * 4;
    let mut literals = Vec::with_capacity(sequence_count);
    literals.extend(core::iter::repeat_n(0u8, quarter_len));
    literals.extend(core::iter::repeat_n(1u8, quarter_len));
    literals.extend(core::iter::repeat_n(2u8, quarter_len));
    literals.extend(core::iter::repeat_n(3u8, quarter_len));
    let sequences = vec![
        PreparedSequence {
            ll: 1,
            ml: 3,
            raw_offset: 4,
            encoded_offset_value: 0,
        };
        sequence_count
    ];
    let prepared = PreparedBlock {
        literals: crate::workspace::ReusableVec::from_owned(literals),
        sequences: crate::workspace::ReusableVec::from_owned(sequences),
    };
    let data = vec![0u8; sequence_count * 4];
    let whole_range = PreparedRange {
        prepared: prepared.as_ref(),
        data: &data,
    };
    let mut partitions = Vec::new();

    let used = derive_best_partitions(whole_range, OffsetHistory::new(), 2, &mut partitions);

    assert_eq!(used, 2);
    assert_eq!(partitions.len(), 2);
}