mirror of
https://github.com/uutils/coreutils
synced 2024-10-07 00:19:14 +00:00
801 lines
20 KiB
Rust
801 lines
20 KiB
Rust
// This file is part of the uutils coreutils package.
|
|
//
|
|
// For the full copyright and license information, please view the LICENSE
|
|
// file that was distributed with this source code.
|
|
|
|
// spell-checker:ignore (ToDO) unwritable
|
|
use crate::common::util::TestScenario;
|
|
|
|
#[test]
|
|
fn test_invalid_arg() {
|
|
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_output_is_random_permutation() {
|
|
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!().pipe_in(input.as_bytes()).succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_ne!(result.stdout_str(), input, "Output is not randomized");
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_explicit_stdin_file() {
|
|
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!().arg("-").pipe_in(input.as_bytes()).succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_termination() {
|
|
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let result = new_ucmd!().arg("-z").arg("-i1-10").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\0')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_termination_multi() {
|
|
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let result = new_ucmd!().arg("-z").arg("-z").arg("-i1-10").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\0')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_very_large_range() {
|
|
let num_samples = 10;
|
|
let result = new_ucmd!()
|
|
.arg("-n")
|
|
.arg(num_samples.to_string())
|
|
.arg("-i0-1234567890")
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<isize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
|
|
assert!(
|
|
result_seq.iter().all(|x| (0..=1234567890).contains(x)),
|
|
"Output includes element not from range: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_very_large_range_offset() {
|
|
let num_samples = 10;
|
|
let result = new_ucmd!()
|
|
.arg("-n")
|
|
.arg(num_samples.to_string())
|
|
.arg("-i1234567890-2147483647")
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<isize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
|
|
assert!(
|
|
result_seq
|
|
.iter()
|
|
.all(|x| (1234567890..=2147483647).contains(x)),
|
|
"Output includes element not from range: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat_no_overflow_1_max() {
|
|
let upper_bound = usize::MAX;
|
|
let result = new_ucmd!()
|
|
.arg("-rn1")
|
|
.arg(&format!("-i1-{upper_bound}"))
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<usize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), 1, "Miscounted output length!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat_no_overflow_0_max_minus_1() {
|
|
let upper_bound = usize::MAX - 1;
|
|
let result = new_ucmd!()
|
|
.arg("-rn1")
|
|
.arg(&format!("-i0-{upper_bound}"))
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<usize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), 1, "Miscounted output length!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_permute_no_overflow_1_max() {
|
|
let upper_bound = usize::MAX;
|
|
let result = new_ucmd!()
|
|
.arg("-n1")
|
|
.arg(&format!("-i1-{upper_bound}"))
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<usize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), 1, "Miscounted output length!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_permute_no_overflow_0_max_minus_1() {
|
|
let upper_bound = usize::MAX - 1;
|
|
let result = new_ucmd!()
|
|
.arg("-n1")
|
|
.arg(&format!("-i0-{upper_bound}"))
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<usize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), 1, "Miscounted output length!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_permute_no_overflow_0_max() {
|
|
// NOTE: This is different from GNU shuf!
|
|
// GNU shuf accepts -i0-MAX-1 and -i1-MAX, but not -i0-MAX.
|
|
// This feels like a bug in GNU shuf.
|
|
let upper_bound = usize::MAX;
|
|
let result = new_ucmd!()
|
|
.arg("-n1")
|
|
.arg(&format!("-i0-{upper_bound}"))
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<usize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), 1, "Miscounted output length!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_very_high_range_full() {
|
|
let input_seq = vec![
|
|
2147483641, 2147483642, 2147483643, 2147483644, 2147483645, 2147483646, 2147483647,
|
|
];
|
|
let result = new_ucmd!().arg("-i2147483641-2147483647").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<isize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat() {
|
|
let num_samples = 500;
|
|
let result = new_ucmd!()
|
|
.arg("-r")
|
|
.arg("-n")
|
|
.arg(num_samples.to_string())
|
|
.arg("-i12-34")
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<isize> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
|
|
assert!(
|
|
result_seq.iter().all(|x| (12..=34).contains(x)),
|
|
"Output includes element not from range: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_empty_input() {
|
|
let result = new_ucmd!().pipe_in(vec![]).succeeds();
|
|
result.no_stderr();
|
|
result.no_stdout();
|
|
}
|
|
|
|
#[test]
|
|
fn test_echo() {
|
|
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let result = new_ucmd!()
|
|
.arg("-e")
|
|
.args(
|
|
&input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>(),
|
|
)
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, input_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_echo_multi() {
|
|
let result = new_ucmd!()
|
|
.arg("-e")
|
|
.arg("a")
|
|
.arg("b")
|
|
.arg("-e")
|
|
.arg("c")
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<String> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.into())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_echo_postfix() {
|
|
let result = new_ucmd!().arg("a").arg("b").arg("c").arg("-e").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<String> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.into())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_echo_short_collapsed_zero() {
|
|
let result = new_ucmd!().arg("-ez").arg("a").arg("b").arg("c").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<String> = result
|
|
.stdout_str()
|
|
.split('\0')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_head_count() {
|
|
let repeat_limit = 5;
|
|
let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!()
|
|
.args(&["-n", &repeat_limit.to_string()])
|
|
.pipe_in(input.as_bytes())
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
|
|
assert!(
|
|
result_seq.iter().all(|x| input_seq.contains(x)),
|
|
"Output includes element not from input: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_pipe() {
|
|
let result = new_ucmd!().arg("-n0").pipe_in(vec![]).succeeds();
|
|
// Output must be completely empty, not even a newline!
|
|
result.no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_pipe_explicit() {
|
|
let result = new_ucmd!().arg("-n0").arg("-").pipe_in(vec![]).succeeds();
|
|
result.no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_file_unreadable() {
|
|
new_ucmd!()
|
|
.arg("-n0")
|
|
.arg("/invalid/unreadable")
|
|
.pipe_in(vec![])
|
|
.succeeds()
|
|
.no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_file_touch_output_negative() {
|
|
new_ucmd!()
|
|
.arg("-n0")
|
|
.arg("-o")
|
|
.arg("/invalid/unwritable")
|
|
.pipe_in(vec![])
|
|
.fails()
|
|
.stderr_contains("failed to open '/invalid/unwritable' for writing:");
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_file_touch_output_positive_new() {
|
|
let (at, mut ucmd) = at_and_ucmd!();
|
|
ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
|
|
assert_eq!(
|
|
at.read_bytes("file"),
|
|
Vec::new(),
|
|
"Output file must exist and be completely empty"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_file_touch_output_positive_existing() {
|
|
let (at, mut ucmd) = at_and_ucmd!();
|
|
at.touch("file");
|
|
ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
|
|
assert_eq!(
|
|
at.read_bytes("file"),
|
|
Vec::new(),
|
|
"Output file must exist and be completely empty"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_echo() {
|
|
new_ucmd!()
|
|
.arg("-n0")
|
|
.arg("-e")
|
|
.arg("hello")
|
|
.pipe_in(vec![])
|
|
.succeeds()
|
|
.no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_head_count_range() {
|
|
new_ucmd!().arg("-n0").arg("-i4-8").succeeds().no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_head_count_multi_big_then_small() {
|
|
let repeat_limit = 5;
|
|
let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!()
|
|
.arg("-n")
|
|
.arg((repeat_limit + 1).to_string())
|
|
.arg("-n")
|
|
.arg(repeat_limit.to_string())
|
|
.pipe_in(input.as_bytes())
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
|
|
assert!(
|
|
result_seq.iter().all(|x| input_seq.contains(x)),
|
|
"Output includes element not from input: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_head_count_multi_small_then_big() {
|
|
let repeat_limit = 5;
|
|
let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!()
|
|
.arg("-n")
|
|
.arg(repeat_limit.to_string())
|
|
.arg("-n")
|
|
.arg((repeat_limit + 1).to_string())
|
|
.pipe_in(input.as_bytes())
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
|
|
assert!(
|
|
result_seq.iter().all(|x| input_seq.contains(x)),
|
|
"Output includes element not from input: {}",
|
|
result.stdout_str()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_repeat() {
|
|
let repeat_limit = 15000;
|
|
let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!()
|
|
.arg("-r")
|
|
.args(&["-n", &repeat_limit.to_string()])
|
|
.pipe_in(input.as_bytes())
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
result_seq.len(),
|
|
repeat_limit,
|
|
"Output is not repeating forever"
|
|
);
|
|
assert!(
|
|
result_seq.iter().all(|x| input_seq.contains(x)),
|
|
"Output includes element not from input: {:?}",
|
|
result_seq
|
|
.iter()
|
|
.filter(|x| !input_seq.contains(x))
|
|
.collect::<Vec<&i32>>()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_repeat_multi() {
|
|
let repeat_limit = 15000;
|
|
let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let input = input_seq
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<String>>()
|
|
.join("\n");
|
|
|
|
let result = new_ucmd!()
|
|
.arg("-r")
|
|
.arg("-r") // The only difference to test_repeat()
|
|
.args(&["-n", &repeat_limit.to_string()])
|
|
.pipe_in(input.as_bytes())
|
|
.succeeds();
|
|
result.no_stderr();
|
|
|
|
let result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
result_seq.len(),
|
|
repeat_limit,
|
|
"Output is not repeating forever"
|
|
);
|
|
assert!(
|
|
result_seq.iter().all(|x| input_seq.contains(x)),
|
|
"Output includes element not from input: {:?}",
|
|
result_seq
|
|
.iter()
|
|
.filter(|x| !input_seq.contains(x))
|
|
.collect::<Vec<&i32>>()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_file_input() {
|
|
let expected_seq = vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
|
|
|
|
let result = new_ucmd!().arg("file_input.txt").succeeds();
|
|
result.no_stderr();
|
|
|
|
let mut result_seq: Vec<i32> = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.map(|x| x.parse().unwrap())
|
|
.collect();
|
|
result_seq.sort_unstable();
|
|
assert_eq!(result_seq, expected_seq, "Output is not a permutation");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_echo_and_input_range_not_allowed() {
|
|
new_ucmd!()
|
|
.args(&["-e", "0", "-i", "0-2"])
|
|
.fails()
|
|
.stderr_contains("cannot be used with");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_input_range_and_file_not_allowed() {
|
|
new_ucmd!()
|
|
.args(&["-i", "0-9", "file"])
|
|
.fails()
|
|
.stderr_contains("cannot be used with");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_invalid_input_range_one() {
|
|
new_ucmd!()
|
|
.args(&["-i", "0"])
|
|
.fails()
|
|
.stderr_contains("invalid input range");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_invalid_input_range_two() {
|
|
new_ucmd!()
|
|
.args(&["-i", "a-9"])
|
|
.fails()
|
|
.stderr_contains("invalid input range: 'a'");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_invalid_input_range_three() {
|
|
new_ucmd!()
|
|
.args(&["-i", "0-b"])
|
|
.fails()
|
|
.stderr_contains("invalid input range: 'b'");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_multiple_input_ranges() {
|
|
new_ucmd!()
|
|
.args(&["-i", "2-9", "-i", "2-9"])
|
|
.fails()
|
|
.stderr_contains("--input-range")
|
|
.stderr_contains("cannot be used multiple times");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_multiple_outputs() {
|
|
new_ucmd!()
|
|
.args(&["-o", "file_a", "-o", "file_b"])
|
|
.fails()
|
|
.stderr_contains("--output")
|
|
.stderr_contains("cannot be used multiple times");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_two_input_files() {
|
|
new_ucmd!()
|
|
.args(&["file_a", "file_b"])
|
|
.fails()
|
|
.stderr_contains("unexpected argument 'file_b' found");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_three_input_files() {
|
|
new_ucmd!()
|
|
.args(&["file_a", "file_b", "file_c"])
|
|
.fails()
|
|
.stderr_contains("unexpected argument 'file_b' found");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_invalid_input_line_count() {
|
|
new_ucmd!()
|
|
.args(&["-n", "a"])
|
|
.fails()
|
|
.stderr_contains("invalid line count: 'a'");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_multiple_input_line_count() {
|
|
let result = new_ucmd!()
|
|
.args(&["-i10-200", "-n", "10", "-n", "5"])
|
|
.succeeds();
|
|
|
|
result.no_stderr();
|
|
|
|
let result_count = result
|
|
.stdout_str()
|
|
.split('\n')
|
|
.filter(|x| !x.is_empty())
|
|
.count();
|
|
assert_eq!(result_count, 5, "Output should have 5 items");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_repeat_empty_range() {
|
|
new_ucmd!()
|
|
.arg("-ri4-3")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: no lines to repeat\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_repeat_empty_echo() {
|
|
new_ucmd!()
|
|
.arg("-re")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: no lines to repeat\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_shuf_repeat_empty_input() {
|
|
new_ucmd!()
|
|
.arg("-r")
|
|
.pipe_in("")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: no lines to repeat\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_one_elem() {
|
|
new_ucmd!()
|
|
.arg("-i5-5")
|
|
.succeeds()
|
|
.no_stderr()
|
|
.stdout_only("5\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_empty() {
|
|
new_ucmd!().arg("-i5-4").succeeds().no_output();
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_empty_minus_one() {
|
|
new_ucmd!()
|
|
.arg("-i5-3")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: invalid input range: '5-3'\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat_one_elem() {
|
|
new_ucmd!()
|
|
.arg("-n1")
|
|
.arg("-ri5-5")
|
|
.succeeds()
|
|
.no_stderr()
|
|
.stdout_only("5\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat_empty() {
|
|
new_ucmd!()
|
|
.arg("-n1")
|
|
.arg("-ri5-4")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: no lines to repeat\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_range_repeat_empty_minus_one() {
|
|
new_ucmd!()
|
|
.arg("-n1")
|
|
.arg("-ri5-3")
|
|
.fails()
|
|
.no_stdout()
|
|
.stderr_only("shuf: invalid input range: '5-3'\n");
|
|
}
|