use file_rw::{file, FileReader, FileWriter};
#[cfg(feature = "sha3_256")]
use sha3::Digest;
use std::fs::File;
use std::io::{Read, Write};
use std::path::Path;
use tempfile::tempdir;
macro_rules! file_reader_test {
($file_name:expr, |$tempdir:ident, $tempdir_path:ident, $test_file_path:ident, $file_writer:ident, $file_reader:ident| $block:block) => {{
let $tempdir = tempdir().unwrap();
let $tempdir_path = $tempdir.path();
create_test_files(&$tempdir_path);
let $test_file_path = $tempdir_path.join($file_name);
let $file_reader = FileReader::open(&$test_file_path).unwrap();
let mut $file_writer = FileWriter::open(&$test_file_path).unwrap();
$block
}};
}
#[cfg(test)]
fn create_test_files(dir: &Path) {
let mut file = File::create(dir.join("test_file")).unwrap();
file.write_all(b"test file\n").unwrap();
let mut file2 = File::create(dir.join("test_file2")).unwrap();
file2.write_all(b"test file\n").unwrap();
let mut diff_file = File::create(dir.join("test_file_diff")).unwrap();
diff_file.write_all(b"test file diff\n").unwrap();
let mut find_bytes_file = File::create(dir.join("test_find_bytes")).unwrap();
find_bytes_file
.write_all(b" test test test test\n")
.unwrap();
}
#[test]
fn test_open() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.read_to_string(), "test file\n");
}
);
}
#[cfg(feature = "filepath")]
#[test]
fn test_open_file() {
let tempdir = tempdir().unwrap();
create_test_files(tempdir.path());
let file = std::fs::OpenOptions::new()
.read(true)
.open(tempdir.path().join("test_file"))
.unwrap();
let file_reader = FileReader::open_file(file).unwrap();
assert_eq!(file_reader.read_to_string(), "test file\n");
}
#[test]
fn test_read_to_string() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.read_to_string(), "test file\n");
}
);
}
#[test]
fn test_as_slice() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.as_slice(), b"test file\n");
}
);
}
#[test]
fn test_to_vec() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.to_vec(), b"test file\n");
}
);
}
#[test]
fn test_file() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let mut file_text_buffer = String::new();
file_reader
.file()
.unwrap()
.read_to_string(&mut file_text_buffer)
.unwrap_or_else(|_| panic!("Could not read file"));
let expected_text = "test file\n".to_string();
assert_eq!(file_text_buffer, expected_text);
}
);
}
#[test]
fn test_mmap() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.mmap.len(), 10);
}
);
}
#[test]
fn test_path() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert_eq!(file_reader.path(), &test_file_path);
}
);
}
#[test]
fn test_to_writer() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, file_writer, file_reader| {
file_writer.write(b"testwrite\n");
assert_eq!(file_reader.read_to_string(), "testwrite\n");
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_hash() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let expected_hash = sha3::Sha3_256::digest(b"test file\n");
assert_eq!(file_reader.hash(), expected_hash);
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_hash_with() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let expected_hash = sha3::Sha3_256::digest(b"test file\n");
assert_eq!(file_reader.hash_with::<sha3::Sha3_256>(), expected_hash);
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_hash_to_string() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let expected_string =
"301285a36e29434a5a13a2c307284e0d64edf827b723290ff4351a6414aa18cf".to_string();
assert_eq!(file_reader.hash_to_string(), expected_string);
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_find_as_slice() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offset = 8;
assert_eq!(file_reader.find_bytes(bytes), Some(expected_offset));
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_rfind_as_slice() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offset = 23;
assert_eq!(file_reader.rfind_bytes(bytes), Some(expected_offset));
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_find_bytes_all() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offsets = vec![8, 13, 18, 23];
assert_eq!(file_reader.find_bytes_all(bytes), expected_offsets);
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_rfind_bytes_all() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offsets = vec![23, 18, 13, 8];
assert_eq!(file_reader.rfind_bytes_all(bytes), expected_offsets);
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_find_bytes_nth() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offset = 13;
assert_eq!(file_reader.find_bytes_nth(bytes, 1), Some(expected_offset));
}
);
}
#[cfg(feature = "search")]
#[test]
fn test_rfind_bytes_nth() {
file_reader_test!(
"test_find_bytes",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let bytes = b"test";
let expected_offset = 18;
assert_eq!(file_reader.rfind_bytes_nth(bytes, 1), Some(expected_offset));
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_compare_files() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, _file_reader| {
let file_reader_same_path = tempdir_path.join("test_file2");
let file_reader_diff_path = tempdir_path.join("test_file_diff");
assert!(file_rw::read::compare_files(
&test_file_path,
&file_reader_same_path
));
assert!(!file_rw::read::compare_files(
&test_file_path,
&file_reader_diff_path
));
assert!(!file_rw::read::compare_files(
&file_reader_same_path,
&file_reader_diff_path
));
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_compare_to() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
assert!(file_reader.compare_to_file_at_path(tempdir_path.join("test_file2")));
assert!(!file_reader.compare_to_file_at_path(tempdir_path.join("test_file_diff")));
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_compare_to_file() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let file = std::fs::OpenOptions::new()
.read(true)
.open(tempdir_path.join("test_file2"))
.unwrap();
assert!(file_reader.compare_to_file(file));
}
);
}
#[cfg(feature = "sha3_256")]
#[test]
fn test_compare_hash() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let self_hash = file_reader.hash();
let file_reader_same = FileReader::open(tempdir_path.join("test_file2")).unwrap();
let same_hash = file_reader_same.hash();
let file_reader_diff = FileReader::open(tempdir_path.join("test_file_diff")).unwrap();
let diff_hash = file_reader_diff.hash();
assert!(file_reader.compare_hash(&self_hash));
assert!(file_reader.compare_hash(&same_hash));
assert!(!file_reader.compare_hash(&diff_hash));
}
);
}
#[test]
fn test_into_iter() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let mut iter = file_reader.into_iter();
assert_eq!(iter.next(), Some(b't'));
assert_eq!(iter.next(), Some(b'e'));
assert_eq!(iter.next(), Some(b's'));
assert_eq!(iter.next(), Some(b't'));
assert_eq!(iter.next(), Some(b' '));
assert_eq!(iter.next(), Some(b'f'));
assert_eq!(iter.next(), Some(b'i'));
assert_eq!(iter.next(), Some(b'l'));
assert_eq!(iter.next(), Some(b'e'));
assert_eq!(iter.next(), Some(b'\n'));
assert_eq!(iter.next(), None);
}
);
}
#[test]
fn test_eq() {
file_reader_test!(
"test_file",
|tempdir, tempdir_path, test_file_path, _file_writer, file_reader| {
let same_path = tempdir_path.join("test_file2");
let diff_path = tempdir_path.join("test_file_diff");
let file_reader_same = FileReader::open(&same_path).unwrap();
let file_reader_diff = FileReader::open(&diff_path).unwrap();
assert_eq!(file_reader, file_reader_same);
assert_ne!(file_reader, file_reader_diff);
}
);
}
#[test]
fn test_as_writer() {
let tempdir = tempdir().unwrap();
let tempdir_path = tempdir.path();
let write_file_path_buf = tempdir_path.join("write_file");
let write_file_path = write_file_path_buf.as_path();
let write_file = file::open_as_write(write_file_path).unwrap();
let file_reader = FileReader::open_file_at_path(write_file, write_file_path).unwrap();
let mut writer = file_reader.as_writer().unwrap();
writer.overwrite(b"testwrite\n").unwrap();
let reader = writer.to_reader().unwrap();
assert_eq!(reader.read_to_string(), "testwrite\n");
let write_file = file::open_as_write(write_file_path).unwrap();
let new_file_reader = FileReader::open_file_at_path(write_file, &write_file_path).unwrap();
assert_eq!(new_file_reader.read_to_string(), "testwrite\n");
}
#[test]
fn test_mmap_mut() {
let tempdir = tempdir().unwrap();
let tempdir_path = tempdir.path();
let write_file_path_buf = tempdir_path.join("write_file");
let write_file_path = write_file_path_buf.as_path();
let write_file = file::open_as_write(write_file_path).unwrap();
let mut writer = FileWriter::open_file_at_path(write_file, write_file_path).unwrap();
writer.overwrite(b"testwrite\n").unwrap();
let write_file = file::open_as_write(write_file_path).unwrap();
let file_reader = FileReader::open_file_at_path(write_file, write_file_path).unwrap();
let mut mmap_mut = file_reader.mmap_mut().unwrap();
assert_eq!(&mmap_mut[..], b"testwrite\n");
mmap_mut.copy_from_slice(b"newwrite2\n");
assert_eq!(&mmap_mut[..], b"newwrite2\n");
let write_file = file::open_as_write(write_file_path).unwrap();
let file_reader_new = FileReader::open_file_at_path(write_file, write_file_path).unwrap();
assert_eq!(file_reader_new.read_to_string(), "newwrite2\n");
}