libdeflate-rs/tests/parallel_test.rs at 36af7cec54ed496c64eb16aad9dffcdbe222ffc1 · 404Setup/libdeflate-rs · GitHub

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
use libdeflate::{Compressor, Decompressor};

#[test]
fn test_parallel_deflate_1mb() {
    let size = 1024 * 1024;
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i % 256) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();
    let mut decompressor = Decompressor::new();

    let compressed = compressor.compress_deflate(&data).unwrap();
    assert!(compressed.len() > 0);

    let decompressed = decompressor.decompress_deflate(&compressed, size).unwrap();

    assert_eq!(decompressed, data);
}

#[test]
fn test_parallel_deflate_boundary() {
    // 256KB + 1 byte
    let size = 256 * 1024 + 1;
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i % 256) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();
    let mut decompressor = Decompressor::new();

    let compressed = compressor.compress_deflate(&data).unwrap();
    assert!(compressed.len() > 0);

    let decompressed = decompressor.decompress_deflate(&compressed, size).unwrap();
    assert_eq!(decompressed, data);
}

#[test]
fn test_parallel_deflate_large() {
    // 10MB
    let size = 10 * 1024 * 1024;
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i % 256) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();
    let mut decompressor = Decompressor::new();

    let compressed = compressor.compress_deflate(&data).unwrap();
    assert!(compressed.len() > 0);

    let decompressed = decompressor.decompress_deflate(&compressed, size).unwrap();
    assert_eq!(decompressed, data);
}

#[test]
fn test_parallel_zlib_large() {
    let size = 5 * 1024 * 1024;
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i.wrapping_mul(3) % 251) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();
    let mut decompressor = Decompressor::new();

    let compressed = compressor.compress_zlib(&data).unwrap();
    assert!(compressed.len() > 0);

    let decompressed = decompressor.decompress_zlib(&compressed, size).unwrap();
    assert_eq!(decompressed, data);
}

#[test]
fn test_parallel_gzip_large() {
    let size = 5 * 1024 * 1024;
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i.wrapping_mul(7) % 251) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();
    let mut decompressor = Decompressor::new();

    let compressed = compressor.compress_gzip(&data).unwrap();
    assert!(compressed.len() > 0);

    let decompressed = decompressor.decompress_gzip(&compressed, size).unwrap();
    assert_eq!(decompressed, data);
}

#[test]
fn test_parallel_insufficient_space() {
    let size = 1024 * 1024; // 1MB, triggers parallel
    let mut data = Vec::with_capacity(size);
    for i in 0..size {
        data.push((i % 256) as u8);
    }

    let mut compressor = Compressor::new(6).unwrap();

    // Provide a buffer that is too small
    let mut output = vec![0u8; 100]; // Definitely too small

    let result = compressor.compress_deflate_into(&data, &mut output);
    assert!(result.is_err());
    // We expect "Insufficient space" or similar error
    let err = result.unwrap_err();
    assert!(err.to_string().contains("Insufficient space") || err.to_string().contains("Compression failed"));
}