110 lines
4.1 KiB
Rust
110 lines
4.1 KiB
Rust
use flate2::Compression;
|
|
use flate2::read::DeflateDecoder;
|
|
use flate2::write::DeflateEncoder;
|
|
use std::fs::{File, OpenOptions};
|
|
use std::io;
|
|
use std::io::{Read, Write};
|
|
use std::path::Path;
|
|
use std::string::String;
|
|
|
|
pub struct TestCompression {}
|
|
|
|
impl TestCompression {
|
|
pub fn compress_string(input: &str) -> Vec<u8> {
|
|
let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
|
|
encoder
|
|
.write_all(input.as_bytes())
|
|
.expect("Failed to write data");
|
|
encoder.finish().expect("Failed to finish compression")
|
|
}
|
|
|
|
pub fn decompress_to_string(compressed_data: &[u8]) -> String {
|
|
let mut decoder = DeflateDecoder::new(compressed_data);
|
|
let mut decompressed = String::new();
|
|
decoder
|
|
.read_to_string(&mut decompressed)
|
|
.expect("Unablew to decompress data to string");
|
|
decompressed
|
|
}
|
|
|
|
/// Load a pre-compressed test result to a string for comparison in an assert macro
|
|
pub fn load_compressed_file_to_string(source: &Path) -> String {
|
|
let mut compressed_file = File::open(&source)
|
|
.expect(format!("Unable to open compressed file at [{}]", source.display()).as_str());
|
|
let mut compressed_data = Vec::new();
|
|
compressed_file
|
|
.read_to_end(&mut compressed_data)
|
|
.expect(format!("Unable to read compressed data from [{}]", source.display()).as_str());
|
|
TestCompression::decompress_to_string(&compressed_data)
|
|
}
|
|
|
|
/// Save a str to a specified file as compressed data
|
|
pub fn save_string_as_compressed_data(source: &str, target_file: &Path) {
|
|
let mut compressed_file = OpenOptions::new()
|
|
.write(true)
|
|
.truncate(true) // optional: clear existing contents
|
|
.create(true)
|
|
.open(target_file)
|
|
.expect(&format!(
|
|
"Unable to open target file [{}] for writing",
|
|
target_file.display()
|
|
));
|
|
|
|
let compressed_data = TestCompression::compress_string(source);
|
|
|
|
compressed_file.write_all(&compressed_data).expect(&format!(
|
|
"Unable to write compressed data to [{}]",
|
|
target_file.display()
|
|
));
|
|
}
|
|
|
|
pub fn compress_file<P: AsRef<Path>>(source: P, destination: P) -> io::Result<()> {
|
|
// Read the source file
|
|
let mut read_buffer = String::new();
|
|
let mut read_file = File::open(&source)?;
|
|
read_file.read_to_string(&mut read_buffer)?;
|
|
|
|
// Compress the data
|
|
let compressed_data = TestCompression::compress_string(&read_buffer);
|
|
|
|
// Write the compressed data to the destination file
|
|
let mut write_file = File::create(&destination)?;
|
|
write_file.write_all(&compressed_data)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn compress_string_to_file(text: &str, target: &Path) {
|
|
let compressed_text = TestCompression::compress_string(text);
|
|
let mut writer = File::create(target).expect("Unable to create target file.");
|
|
writer
|
|
.write_all(&compressed_text)
|
|
.expect("Unable to write compressed data");
|
|
}
|
|
|
|
pub fn decompress_file_to_string(source: &Path) -> String {
|
|
let mut compressed_file = File::open(source).expect("Unable to open source to compress.");
|
|
let mut compressed_data = Vec::new();
|
|
compressed_file
|
|
.read_to_end(&mut compressed_data)
|
|
.expect("Unable to read compressed data");
|
|
TestCompression::decompress_to_string(&compressed_data)
|
|
}
|
|
|
|
pub fn compress_file_to_array(file_to_compress: &Path) -> Vec<u8> {
|
|
let mut read_buffer = String::new();
|
|
let mut file = File::open(file_to_compress).unwrap();
|
|
file.read_to_string(&mut read_buffer)
|
|
.expect("Unable to read data to compress");
|
|
TestCompression::compress_string(&read_buffer)
|
|
}
|
|
|
|
pub fn decompress_file_to_array(to_decompress: &Path) -> Vec<u8> {
|
|
let file = File::open(to_decompress).expect("Failed to open file");
|
|
let mut decoder = DeflateDecoder::new(file);
|
|
let mut output = Vec::new();
|
|
decoder.read_to_end(&mut output).expect("Failed to decompress");
|
|
output
|
|
}
|
|
}
|