132 lines
3.3 KiB
Rust
132 lines
3.3 KiB
Rust
use anyhow::Result;
|
|
|
|
use thinp::file_utils;
|
|
|
|
use crate::args;
|
|
use crate::common::process::*;
|
|
use crate::common::program::*;
|
|
use crate::common::test_dir::*;
|
|
|
|
//-----------------------------------------
|
|
// test invalid arguments
|
|
|
|
pub fn test_missing_output_option<'a, P>() -> Result<()>
|
|
where
|
|
P: OutputProgram<'a>,
|
|
{
|
|
let mut td = TestDir::new()?;
|
|
let input = P::mk_valid_input(&mut td)?;
|
|
let stderr = run_fail(P::path(), args!["-i", &input])?;
|
|
assert!(stderr.contains(P::missing_output_arg()));
|
|
Ok(())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! test_missing_output_option {
|
|
($program: ident) => {
|
|
#[test]
|
|
fn missing_output_option() -> Result<()> {
|
|
test_missing_output_option::<$program>()
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn test_output_file_not_found<'a, P>() -> Result<()>
|
|
where
|
|
P: OutputProgram<'a>,
|
|
{
|
|
let mut td = TestDir::new()?;
|
|
let input = P::mk_valid_input(&mut td)?;
|
|
let stderr = run_fail(P::path(), args!["-i", &input, "-o", "no-such-file"])?;
|
|
assert!(stderr.contains(<P as OutputProgram>::file_not_found()));
|
|
Ok(())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! test_output_file_not_found {
|
|
($program: ident) => {
|
|
#[test]
|
|
fn output_file_not_found() -> Result<()> {
|
|
test_output_file_not_found::<$program>()
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn test_output_cannot_be_a_directory<'a, P>() -> Result<()>
|
|
where
|
|
P: OutputProgram<'a>,
|
|
{
|
|
let mut td = TestDir::new()?;
|
|
let input = P::mk_valid_input(&mut td)?;
|
|
let stderr = run_fail(P::path(), args!["-i", &input, "-o", "/tmp"])?;
|
|
assert!(stderr.contains("Not a block device or regular file"));
|
|
Ok(())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! test_output_cannot_be_a_directory {
|
|
($program: ident) => {
|
|
#[test]
|
|
fn output_cannot_be_a_directory() -> Result<()> {
|
|
test_output_cannot_be_a_directory::<$program>()
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn test_unwritable_output_file<'a, P>() -> Result<()>
|
|
where
|
|
P: OutputProgram<'a>,
|
|
{
|
|
let mut td = TestDir::new()?;
|
|
let input = P::mk_valid_input(&mut td)?;
|
|
|
|
let output = td.mk_path("meta.bin");
|
|
let _file = file_utils::create_sized_file(&output, 4096);
|
|
duct::cmd!("chmod", "-w", &output).run()?;
|
|
|
|
let stderr = run_fail(P::path(), args!["-i", &input, "-o", &output])?;
|
|
assert!(stderr.contains("Permission denied"));
|
|
Ok(())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! test_unwritable_output_file {
|
|
($program: ident) => {
|
|
#[test]
|
|
fn unwritable_output_file() -> Result<()> {
|
|
test_unwritable_output_file::<$program>()
|
|
}
|
|
};
|
|
}
|
|
|
|
//----------------------------------------
|
|
// test invalid content
|
|
|
|
// currently thin/cache_restore only
|
|
pub fn test_tiny_output_file<'a, P>() -> Result<()>
|
|
where
|
|
P: BinaryOutputProgram<'a>,
|
|
{
|
|
let mut td = TestDir::new()?;
|
|
let input = P::mk_valid_input(&mut td)?;
|
|
|
|
let output = td.mk_path("meta.bin");
|
|
let _file = file_utils::create_sized_file(&output, 4096);
|
|
|
|
let stderr = run_fail(P::path(), args!["-i", &input, "-o", &output])?;
|
|
assert!(stderr.contains("Output file too small"));
|
|
Ok(())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! test_tiny_output_file {
|
|
($program: ident) => {
|
|
#[test]
|
|
fn tiny_output_file() -> Result<()> {
|
|
test_tiny_output_file::<$program>()
|
|
}
|
|
};
|
|
}
|
|
|
|
//-----------------------------------------
|