ggstd 0.1.0

Partial implementation of Go standard 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
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
135
136
137
138

// Copyright 2023 The rust-ggstd authors. All rights reserved.
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use super::writer::{
    Writer, BEST_COMPRESSION, BEST_SPEED, DEFAULT_COMPRESSION, HUFFMAN_ONLY, NO_COMPRESSION,
};
use crate::bytes;
use crate::compress::zlib;
use crate::os as ggos;
use std::io::Read;

const FILE_NAMES: &[&str] = &[
    "src/compress/testdata/gettysburg.txt",
    "src/compress/testdata/e.txt",
    "src/compress/testdata/pi.txt",
];

const DATA: &[&str] = &["test a reasonable sized string that can be compressed"];

/// Tests that compressing and then decompressing the given file at the given compression level and dictionary
/// yields equivalent bytes to the original file.
fn test_file_level_dict(file_name: &str, level: isize, d: &[u8]) {
    let b0 = ggos::read_file(file_name).unwrap();
    test_level_dict(file_name, &b0, level, d);
}

fn test_level_dict(_name: &str, b0: &[u8], level: isize, dict: &[u8]) {
    let mut b = bytes::Buffer::new();

    // compress
    let mut zlibw = Writer::new_level_dict(&mut b, level, dict).unwrap();
    zlibw.write(b0).unwrap();
    zlibw.close().unwrap();

    // decompress
    let mut r = zlib::Reader::new_dict(&mut b, dict).unwrap();
    let mut decompressed = Vec::new();
    r.read_to_end(&mut decompressed).unwrap();

    // compare
    assert_eq!(b0, decompressed);
}

fn test_file_level_dict_reset(file_name: &str, level: isize, dict: &[u8]) {
    let mut buf = bytes::Buffer::new();
    let mut zlibw = zlib::Writer::new_level_dict(&mut buf, level, dict).unwrap();

    // Compress once.
    let data = ggos::read_file(file_name).unwrap();
    zlibw.write(&data).unwrap();
    zlibw.close().unwrap();

    // Reset and compress again.
    let data = ggos::read_file(file_name).unwrap();
    let mut buf2 = bytes::Buffer::new();
    zlibw.reset(&mut buf2);
    zlibw.write(&data).unwrap();
    zlibw.close().unwrap();

    assert_eq!(buf.len(), buf2.len());
    assert_eq!(bytes::Buffer::bytes(&buf), bytes::Buffer::bytes(&buf2));
}

#[test]
fn test_writer() {
    for (i, s) in DATA.iter().enumerate() {
        let b = s.as_bytes();
        let tag = format!("#{}", i);
        test_level_dict(&tag, b, DEFAULT_COMPRESSION, &[]);
        test_level_dict(&tag, b, NO_COMPRESSION, &[]);
        test_level_dict(&tag, b, HUFFMAN_ONLY, &[]);
        for level in BEST_SPEED..=BEST_COMPRESSION {
            test_level_dict(&tag, b, level, &[]);
        }
    }
}

#[test]
fn test_writer_big() {
    for (_i, file_name) in FILE_NAMES.iter().enumerate() {
        test_file_level_dict(file_name, DEFAULT_COMPRESSION, &[]);
        test_file_level_dict(file_name, NO_COMPRESSION, &[]);
        test_file_level_dict(file_name, HUFFMAN_ONLY, &[]);
        for level in BEST_SPEED..=BEST_COMPRESSION {
            test_file_level_dict(file_name, level, &[]);
        }
    }
}

#[test]
fn test_writer_dict() {
    let dictionary = b"0123456789.";
    for file_name in FILE_NAMES {
        test_file_level_dict(file_name, DEFAULT_COMPRESSION, dictionary);
        test_file_level_dict(file_name, NO_COMPRESSION, dictionary);
        test_file_level_dict(file_name, HUFFMAN_ONLY, dictionary);
        for level in BEST_SPEED..=BEST_COMPRESSION {
            test_file_level_dict(file_name, level, dictionary);
        }
    }
}

#[test]
fn test_writer_reset() {
    let dictionary = b"0123456789.";
    for file_name in FILE_NAMES {
        test_file_level_dict_reset(file_name, NO_COMPRESSION, &[]);
        test_file_level_dict_reset(file_name, DEFAULT_COMPRESSION, &[]);
        test_file_level_dict_reset(file_name, HUFFMAN_ONLY, &[]);
        test_file_level_dict_reset(file_name, NO_COMPRESSION, dictionary);
        test_file_level_dict_reset(file_name, DEFAULT_COMPRESSION, dictionary);
        test_file_level_dict_reset(file_name, HUFFMAN_ONLY, dictionary);
        for level in BEST_SPEED..=BEST_COMPRESSION {
            test_file_level_dict_reset(file_name, level, &[]);
        }
    }
}

#[test]
fn test_writer_dict_is_used() {
    let input = b"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
    let mut buf = bytes::Buffer::new();
    {
        let mut compressor = Writer::new_level_dict(&mut buf, BEST_COMPRESSION, input).unwrap();
        compressor.write(input).unwrap();
        compressor.close().unwrap();
    }
    let expected_max_size = 25;
    let output = bytes::Buffer::bytes(&buf);
    assert!(
        output.len() <= expected_max_size,
        "result too large (got {}, want <= {} bytes). Is the dictionary being used?",
        output.len(),
        expected_max_size
    );
}