lzfse_rust 0.2.1

A pure Rust LZFSE library.
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

use crate::kit::WIDE;
use crate::ops::Skip;
use crate::ring::{RingBlock, RingBox, RingReader, RingSize, RingType};
use crate::types::ByteReader;

use test_kit::Seq;

use super::block::RawBlock;
use super::ops;

#[derive(Copy, Clone, Debug)]
pub struct T;

unsafe impl RingSize for T {
    const RING_SIZE: u32 = 0x1000;
}

unsafe impl RingType for T {
    const RING_LIMIT: u32 = WIDE as u32;
}

unsafe impl RingBlock for T {
    const RING_BLK_SIZE: u32 = 0x0200;
}

const ABCD: [u8; 4] = [0x41, 0x42, 0x43, 0x44];

const ABCD_RAW: [u8; 12] = [0x62, 0x76, 0x78, 0x2d, 0x04, 0x00, 0x00, 0x00, 0x41, 0x42, 0x43, 0x44];

// Basic block 4 byte raw encoding test.
#[test]
fn block_enc_basic() -> crate::Result<()> {
    let mut enc = Vec::default();
    ops::raw_compress(&mut enc, ABCD.as_ref())?;
    assert_eq!(ABCD_RAW.as_ref(), &enc);
    Ok(())
}

// Basic block 4 byte raw decoding test.
#[test]
fn block_dec_basic() -> crate::Result<()> {
    let mut dec = Vec::default();
    let mut src = ABCD_RAW.as_ref();
    ops::raw_decompress(&mut dec, &mut src)?;
    assert_eq!(src.len(), 0);
    assert_eq!(ABCD.as_ref(), &dec);
    Ok(())
}

#[test]
#[ignore = "expensive"]
fn block_enc_dec_vec() -> crate::Result<()> {
    let src = Seq::default().take(65536).collect::<Vec<_>>();
    let mut dec = Vec::default();
    let mut enc = Vec::default();
    for n in 0..=src.len() {
        let src = &src[..n];
        enc.clear();
        ops::raw_compress(&mut enc, src)?;
        dec.clear();
        ops::raw_decompress(&mut dec, &mut enc.as_ref())?;
        assert_eq!(src, dec);
    }
    Ok(())
}

#[test]
#[ignore = "expensive"]
fn block_enc_dec_ring() -> crate::Result<()> {
    let mut ring_box = RingBox::<T>::default();
    let src = Seq::default().take(65536).collect::<Vec<_>>();
    let mut dec = Vec::default();
    let mut enc = Vec::default();
    for n in 0..src.len() {
        let src = &src[..n];
        enc.clear();
        ops::raw_compress(&mut enc, src)?;
        let mut enc = enc.as_slice();
        let mut rdr = RingReader::new((&mut ring_box).into(), &mut enc);
        dec.clear();
        ops::raw_decompress(&mut dec, &mut rdr)?;
        assert_eq!(src, dec);
    }
    Ok(())
}

#[test]
#[ignore = "expensive"]
fn block_enc_dec_ring_n() -> crate::Result<()> {
    let mut block = RawBlock::default();
    let mut ring_box = RingBox::<T>::default();
    let src = Seq::default().take(65536).collect::<Vec<_>>();
    let mut dec = Vec::default();
    let mut enc = Vec::default();
    ops::raw_compress(&mut enc, src.as_ref())?;
    for n in 1..src.len() {
        let mut enc = enc.as_slice();
        let mut rdr = RingReader::new((&mut ring_box).into(), &mut enc);
        dec.clear();
        rdr.fill()?;
        rdr.skip(block.load_short(rdr.view())? as usize);
        while block.decode_n(&mut dec, &mut rdr, n as u32)? {}
        assert_eq!(src, dec);
    }
    Ok(())
}