RGBCube/uutils-coreutils
1
Fork 0
mirror of https://github.com/RGBCube/uutils-coreutils synced 2025-07-28 03:27:44 +00:00
Code Issues Activity

Merge pull request #7371 from sylvestre/use-new-function

Browse source 
use the new function fails_with_code
This commit is contained in:
Sylvestre Ledru 2025-03-04 08:31:18 +01:00 • committed by GitHub
commit 0936cee9d5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
90 changed files with 448 additions and 732 deletions
Download patch file Download diff file Expand all files Collapse all files

2
tests/by-util/test_arch.rs
View file

@ -19,5 +19,5 @@ fn test_arch_help() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }

5
tests/by-util/test_basename.rs
View file

@ -192,14 +192,13 @@ fn test_simple_format() {
new_ucmd!().args(&["a-z", "-z"]).succeeds().stdout_is("a\n"); new_ucmd!().args(&["a-z", "-z"]).succeeds().stdout_is("a\n");
new_ucmd!() new_ucmd!()
.args(&["a", "b", "c"]) .args(&["a", "b", "c"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("extra operand 'c'"); .stderr_contains("extra operand 'c'");
} }
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

3
tests/by-util/test_cat.rs
View file

@ -615,8 +615,7 @@ fn test_write_to_self() {
.arg("first_file") .arg("first_file")
.arg("first_file") .arg("first_file")
.arg("second_file") .arg("second_file")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("cat: first_file: input file is output file\ncat: first_file: input file is output file\n"); .stderr_only("cat: first_file: input file is output file\ncat: first_file: input file is output file\n");
assert_eq!( assert_eq!(

2
tests/by-util/test_chgrp.rs
View file

@ -14,7 +14,7 @@ fn test_invalid_option() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
static DIR: &str = "/dev"; static DIR: &str = "/dev";

31
tests/by-util/test_chmod.rs
View file

@ -266,8 +266,7 @@ fn test_chmod_error_permissions() {
ucmd.args(&["-w", "file"]) ucmd.args(&["-w", "file"])
.umask(0o022) .umask(0o022)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is( .stderr_is(
// spell-checker:disable-next-line // spell-checker:disable-next-line
"chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x\n", "chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x\n",
@ -442,9 +441,8 @@ fn test_chmod_non_existing_file_silent() {
.arg("--quiet") .arg("--quiet")
.arg("-r,a+w") .arg("-r,a+w")
.arg("does-not-exist") .arg("does-not-exist")
.fails() .fails_with_code(1)
.no_stderr() .no_stderr();
.code_is(1);
} }
#[test] #[test]
@ -454,7 +452,7 @@ fn test_chmod_preserve_root() {
.arg("--preserve-root") .arg("--preserve-root")
.arg("755") .arg("755")
.arg("/") .arg("/")
.fails() .fails_with_code(1)
.stderr_contains("chmod: it is dangerous to operate recursively on '/'"); .stderr_contains("chmod: it is dangerous to operate recursively on '/'");
} }
@ -478,8 +476,7 @@ fn test_chmod_symlink_non_existing_file() {
.arg("755") .arg("755")
.arg("-v") .arg("-v")
.arg(test_symlink) .arg(test_symlink)
.fails() .fails_with_code(1)
.code_is(1)
.stdout_contains(expected_stdout) .stdout_contains(expected_stdout)
.stderr_contains(expected_stderr); .stderr_contains(expected_stderr);
@ -585,14 +582,13 @@ fn test_chmod_keep_setgid() {
fn test_no_operands() { fn test_no_operands() {
new_ucmd!() new_ucmd!()
.arg("777") .arg("777")
.fails() .fails_with_code(1)
.code_is(1)
.usage_error("missing operand"); .usage_error("missing operand");
} }
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -624,9 +620,8 @@ fn test_chmod_file_after_non_existing_file() {
.arg("u+x") .arg("u+x")
.arg("does-not-exist") .arg("does-not-exist")
.arg(TEST_FILE) .arg(TEST_FILE)
.fails() .fails_with_code(1)
.stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory") .stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory");
.code_is(1);
assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100_764); assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100_764);
@ -636,9 +631,8 @@ fn test_chmod_file_after_non_existing_file() {
.arg("--q") .arg("--q")
.arg("does-not-exist") .arg("does-not-exist")
.arg("file2") .arg("file2")
.fails() .fails_with_code(1)
.no_stderr() .no_stderr();
.code_is(1);
assert_eq!(at.metadata("file2").permissions().mode(), 0o100_764); assert_eq!(at.metadata("file2").permissions().mode(), 0o100_764);
} }
@ -669,8 +663,7 @@ fn test_chmod_file_symlink_after_non_existing_file() {
.arg("-v") .arg("-v")
.arg(test_dangling_symlink) .arg(test_dangling_symlink)
.arg(test_existing_symlink) .arg(test_existing_symlink)
.fails() .fails_with_code(1)
.code_is(1)
.stdout_contains(expected_stdout) .stdout_contains(expected_stdout)
.stderr_contains(expected_stderr); .stderr_contains(expected_stderr);
assert_eq!( assert_eq!(

2
tests/by-util/test_chown.rs
View file

@ -81,7 +81,7 @@ fn test_invalid_option() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

23
tests/by-util/test_chroot.rs
View file

@ -10,14 +10,12 @@ use crate::common::util::{run_ucmd_as_root, TestScenario};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(125); new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
} }
#[test] #[test]
fn test_missing_operand() { fn test_missing_operand() {
let result = new_ucmd!().fails(); let result = new_ucmd!().fails_with_code(125);
result.code_is(125);
assert!(result assert!(result
.stderr_str() .stderr_str()
@ -34,8 +32,7 @@ fn test_enter_chroot_fails() {
at.mkdir("jail"); at.mkdir("jail");
let result = ucmd.arg("jail").fails(); let result = ucmd.arg("jail").fails_with_code(125);
result.code_is(125);
assert!(result assert!(result
.stderr_str() .stderr_str()
.starts_with("chroot: cannot chroot to 'jail': Operation not permitted (os error 1)")); .starts_with("chroot: cannot chroot to 'jail': Operation not permitted (os error 1)"));
@ -48,9 +45,8 @@ fn test_no_such_directory() {
at.touch(at.plus_as_string("a")); at.touch(at.plus_as_string("a"));
ucmd.arg("a") ucmd.arg("a")
.fails() .fails_with_code(125)
.stderr_is("chroot: cannot change root directory to 'a': no such directory\n") .stderr_is("chroot: cannot change root directory to 'a': no such directory\n");
.code_is(125);
} }
#[test] #[test]
@ -160,9 +156,7 @@ fn test_preference_of_userspec() {
.arg("--groups") .arg("--groups")
.arg("ABC,DEF") .arg("ABC,DEF")
.arg(format!("--userspec={username}:{group_name}")) .arg(format!("--userspec={username}:{group_name}"))
.fails(); .fails_with_code(125);
result.code_is(125);
println!("result.stdout = {}", result.stdout_str()); println!("result.stdout = {}", result.stdout_str());
println!("result.stderr = {}", result.stderr_str()); println!("result.stderr = {}", result.stderr_str());
@ -216,9 +210,8 @@ fn test_chroot_skip_chdir_not_root() {
ucmd.arg("--skip-chdir") ucmd.arg("--skip-chdir")
.arg(dir) .arg(dir)
.fails() .fails_with_code(125)
.stderr_contains("chroot: option --skip-chdir only permitted if NEWROOT is old '/'") .stderr_contains("chroot: option --skip-chdir only permitted if NEWROOT is old '/'");
.code_is(125);
} }
#[test] #[test]

71
tests/by-util/test_cksum.rs
View file

@ -12,7 +12,7 @@ const ALGOS: [&str; 11] = [
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -75,7 +75,7 @@ fn test_nonexisting_file() {
new_ucmd!() new_ucmd!()
.arg(file_name) .arg(file_name)
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains(format!("cksum: {file_name}: No such file or directory")); .stderr_contains(format!("cksum: {file_name}: No such file or directory"));
} }
@ -301,32 +301,28 @@ fn test_check_algo() {
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails()
.no_stdout() .no_stdout()
.stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}") .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("-a=sysv") .arg("-a=sysv")
.arg("--check") .arg("--check")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}") .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("-a=crc") .arg("-a=crc")
.arg("--check") .arg("--check")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}") .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("-a=crc32b") .arg("-a=crc32b")
.arg("--check") .arg("--check")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}") .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
.code_is(1);
} }
#[test] #[test]
@ -335,20 +331,18 @@ fn test_length_with_wrong_algorithm() {
.arg("--length=16") .arg("--length=16")
.arg("--algorithm=md5") .arg("--algorithm=md5")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: --length is only supported with --algorithm=blake2b") .stderr_contains("cksum: --length is only supported with --algorithm=blake2b");
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("--length=16") .arg("--length=16")
.arg("--algorithm=md5") .arg("--algorithm=md5")
.arg("-c") .arg("-c")
.arg("foo.sums") .arg("foo.sums")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: --length is only supported with --algorithm=blake2b") .stderr_contains("cksum: --length is only supported with --algorithm=blake2b");
.code_is(1);
} }
#[test] #[test]
@ -356,10 +350,9 @@ fn test_length_not_supported() {
new_ucmd!() new_ucmd!()
.arg("--length=15") .arg("--length=15")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("--length is only supported with --algorithm=blake2b") .stderr_contains("--length is only supported with --algorithm=blake2b");
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("-l") .arg("-l")
@ -368,10 +361,9 @@ fn test_length_not_supported() {
.arg("-a") .arg("-a")
.arg("crc") .arg("crc")
.arg("/tmp/xxx") .arg("/tmp/xxx")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("--length is only supported with --algorithm=blake2b") .stderr_contains("--length is only supported with --algorithm=blake2b");
.code_is(1);
} }
#[test] #[test]
@ -394,7 +386,7 @@ fn test_length_greater_than_512() {
.arg("--algorithm=blake2b") .arg("--algorithm=blake2b")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.arg("alice_in_wonderland.txt") .arg("alice_in_wonderland.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is_fixture("length_larger_than_512.expected"); .stderr_is_fixture("length_larger_than_512.expected");
} }
@ -443,10 +435,9 @@ fn test_raw_multiple_files() {
.arg("--raw") .arg("--raw")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.arg("alice_in_wonderland.txt") .arg("alice_in_wonderland.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: the --raw option is not supported with multiple files") .stderr_contains("cksum: the --raw option is not supported with multiple files");
.code_is(1);
} }
#[test] #[test]
@ -455,7 +446,7 @@ fn test_base64_raw_conflicts() {
.arg("--base64") .arg("--base64")
.arg("--raw") .arg("--raw")
.arg("lorem_ipsum.txt") .arg("lorem_ipsum.txt")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("--base64") .stderr_contains("--base64")
.stderr_contains("cannot be used with") .stderr_contains("cannot be used with")
@ -749,12 +740,11 @@ fn test_conflicting_options() {
.arg("--binary") .arg("--binary")
.arg("--check") .arg("--check")
.arg("f") .arg("f")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains( .stderr_contains(
"cksum: the --binary and --text options are meaningless when verifying checksums", "cksum: the --binary and --text options are meaningless when verifying checksums",
) );
.code_is(1);
scene scene
.ucmd() .ucmd()
@ -762,12 +752,11 @@ fn test_conflicting_options() {
.arg("-c") .arg("-c")
.arg("-a") .arg("-a")
.arg("md5") .arg("md5")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains( .stderr_contains(
"cksum: the --binary and --text options are meaningless when verifying checksums", "cksum: the --binary and --text options are meaningless when verifying checksums",
) );
.code_is(1);
} }
#[test] #[test]
@ -784,10 +773,9 @@ fn test_check_algo_err() {
.arg("sm3") .arg("sm3")
.arg("--check") .arg("--check")
.arg("f") .arg("f")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: f: no properly formatted checksum lines found") .stderr_contains("cksum: f: no properly formatted checksum lines found");
.code_is(1);
} }
#[test] #[test]
@ -803,10 +791,9 @@ fn test_check_pipe() {
.arg("--check") .arg("--check")
.arg("-") .arg("-")
.pipe_in("f") .pipe_in("f")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_contains("cksum: 'standard input': no properly formatted checksum lines found") .stderr_contains("cksum: 'standard input': no properly formatted checksum lines found");
.code_is(1);
} }
#[test] #[test]

17
tests/by-util/test_comm.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -459,8 +459,7 @@ fn test_sorted() {
scene scene
.ucmd() .ucmd()
.args(&["comm1", "comm2"]) .args(&["comm1", "comm2"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("1\n\t\t3\n\t2\n") .stdout_is("1\n\t\t3\n\t2\n")
.stderr_is(expected_stderr); .stderr_is(expected_stderr);
} }
@ -477,8 +476,7 @@ fn test_sorted_check_order() {
.ucmd() .ucmd()
.arg("--check-order") .arg("--check-order")
.args(&["comm1", "comm2"]) .args(&["comm1", "comm2"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("1\n\t\t3\n") .stdout_is("1\n\t\t3\n")
.stderr_is(expected_stderr); .stderr_is(expected_stderr);
} }
@ -493,8 +491,7 @@ fn test_both_inputs_out_of_order() {
scene scene
.ucmd() .ucmd()
.args(&["file_a", "file_b"]) .args(&["file_a", "file_b"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("\t\t3\n1\n0\n\t2\n\t0\n") .stdout_is("\t\t3\n1\n0\n\t2\n\t0\n")
.stderr_is( .stderr_is(
"comm: file 1 is not in sorted order\n\ "comm: file 1 is not in sorted order\n\
@ -513,8 +510,7 @@ fn test_both_inputs_out_of_order_last_pair() {
scene scene
.ucmd() .ucmd()
.args(&["file_a", "file_b"]) .args(&["file_a", "file_b"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("\t\t3\n1\n\t2\n") .stdout_is("\t\t3\n1\n\t2\n")
.stderr_is( .stderr_is(
"comm: file 1 is not in sorted order\n\ "comm: file 1 is not in sorted order\n\
@ -533,8 +529,7 @@ fn test_first_input_out_of_order_extended() {
scene scene
.ucmd() .ucmd()
.args(&["file_a", "file_b"]) .args(&["file_a", "file_b"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("0\n\t2\n\t\t3\n1\n") .stdout_is("0\n\t2\n\t\t3\n1\n")
.stderr_is( .stderr_is(
"comm: file 1 is not in sorted order\n\ "comm: file 1 is not in sorted order\n\

18
tests/by-util/test_cp.rs
View file

@ -185,8 +185,7 @@ fn test_cp_same_file() {
ucmd.arg(file) ucmd.arg(file)
.arg(file) .arg(file)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("'{file}' and '{file}' are the same file")); .stderr_contains(format!("'{file}' and '{file}' are the same file"));
} }
@ -664,8 +663,7 @@ fn test_cp_arg_interactive_update_overwrite_older() {
at.touch("a"); at.touch("a");
ucmd.args(&["-i", "-u", "a", "b"]) ucmd.args(&["-i", "-u", "a", "b"])
.pipe_in("N\n") .pipe_in("N\n")
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout() .no_stdout()
.stderr_is("cp: overwrite 'b'? "); .stderr_is("cp: overwrite 'b'? ");
@ -1720,8 +1718,7 @@ fn test_cp_preserve_invalid_rejected() {
.arg("--preserve=invalid-value") .arg("--preserve=invalid-value")
.arg(TEST_COPY_FROM_FOLDER_FILE) .arg(TEST_COPY_FROM_FOLDER_FILE)
.arg(TEST_HELLO_WORLD_DEST) .arg(TEST_HELLO_WORLD_DEST)
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
@ -3465,8 +3462,7 @@ fn test_copy_dir_preserve_permissions_inaccessible_file() {
// | | | | // | | | |
// V V V V // V V V V
ucmd.args(&["-p", "-R", "d1", "d2"]) ucmd.args(&["-p", "-R", "d1", "d2"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("cp: cannot open 'd1/f' for reading: permission denied\n"); .stderr_only("cp: cannot open 'd1/f' for reading: permission denied\n");
assert!(at.dir_exists("d2")); assert!(at.dir_exists("d2"));
assert!(!at.file_exists("d2/f")); assert!(!at.file_exists("d2/f"));
@ -5979,16 +5975,14 @@ fn test_cp_with_options_backup_and_rem_when_dest_is_symlink() {
fn test_cp_single_file() { fn test_cp_single_file() {
let (_at, mut ucmd) = at_and_ucmd!(); let (_at, mut ucmd) = at_and_ucmd!();
ucmd.arg(TEST_HELLO_WORLD_SOURCE) ucmd.arg(TEST_HELLO_WORLD_SOURCE)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("missing destination file"); .stderr_contains("missing destination file");
} }
#[test] #[test]
fn test_cp_no_file() { fn test_cp_no_file() {
let (_at, mut ucmd) = at_and_ucmd!(); let (_at, mut ucmd) = at_and_ucmd!();
ucmd.fails() ucmd.fails_with_code(1)
.code_is(1)
.stderr_contains("error: the following required arguments were not provided:"); .stderr_contains("error: the following required arguments were not provided:");
} }

8
tests/by-util/test_csplit.rs
View file

@ -13,7 +13,7 @@ fn generate(from: u32, to: u32) -> String {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -1467,12 +1467,10 @@ fn test_directory_input_file() {
#[cfg(unix)] #[cfg(unix)]
ucmd.args(&["test_directory", "1"]) ucmd.args(&["test_directory", "1"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("csplit: read error: Is a directory\n"); .stderr_only("csplit: read error: Is a directory\n");
#[cfg(windows)] #[cfg(windows)]
ucmd.args(&["test_directory", "1"]) ucmd.args(&["test_directory", "1"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("csplit: cannot open 'test_directory' for reading: Permission denied\n"); .stderr_only("csplit: cannot open 'test_directory' for reading: Permission denied\n");
} }

24
tests/by-util/test_cut.rs
View file

@ -55,7 +55,7 @@ fn test_no_args() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -107,24 +107,21 @@ fn test_whitespace_delimited() {
fn test_whitespace_with_explicit_delimiter() { fn test_whitespace_with_explicit_delimiter() {
new_ucmd!() new_ucmd!()
.args(&["-w", "-f", COMPLEX_SEQUENCE.sequence, "-d:"]) .args(&["-w", "-f", COMPLEX_SEQUENCE.sequence, "-d:"])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
fn test_whitespace_with_byte() { fn test_whitespace_with_byte() {
new_ucmd!() new_ucmd!()
.args(&["-w", "-b", COMPLEX_SEQUENCE.sequence]) .args(&["-w", "-b", COMPLEX_SEQUENCE.sequence])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
fn test_whitespace_with_char() { fn test_whitespace_with_char() {
new_ucmd!() new_ucmd!()
.args(&["-c", COMPLEX_SEQUENCE.sequence, "-w"]) .args(&["-c", COMPLEX_SEQUENCE.sequence, "-w"])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -132,9 +129,9 @@ fn test_delimiter_with_byte_and_char() {
for conflicting_arg in ["-c", "-b"] { for conflicting_arg in ["-c", "-b"] {
new_ucmd!() new_ucmd!()
.args(&[conflicting_arg, COMPLEX_SEQUENCE.sequence, "-d="]) .args(&[conflicting_arg, COMPLEX_SEQUENCE.sequence, "-d="])
.fails() .fails_with_code(1)
.stderr_is("cut: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n") .stderr_is("cut: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n")
.code_is(1); ;
} }
} }
@ -142,8 +139,7 @@ fn test_delimiter_with_byte_and_char() {
fn test_too_large() { fn test_too_large() {
new_ucmd!() new_ucmd!()
.args(&["-b1-18446744073709551615", "/dev/null"]) .args(&["-b1-18446744073709551615", "/dev/null"])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -240,8 +236,7 @@ fn test_is_a_directory() {
ucmd.arg("-b1") ucmd.arg("-b1")
.arg("some") .arg("some")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("cut: some: Is a directory\n"); .stderr_is("cut: some: Is a directory\n");
} }
@ -250,8 +245,7 @@ fn test_no_such_file() {
new_ucmd!() new_ucmd!()
.arg("-b1") .arg("-b1")
.arg("some") .arg("some")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("cut: some: No such file or directory\n"); .stderr_is("cut: some: No such file or directory\n");
} }

7
tests/by-util/test_date.rs
View file

@ -9,7 +9,7 @@ use uucore::process::geteuid;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -214,9 +214,8 @@ fn test_date_format_without_plus() {
// [+FORMAT] // [+FORMAT]
new_ucmd!() new_ucmd!()
.arg("%s") .arg("%s")
.fails() .fails_with_code(1)
.stderr_contains("date: invalid date '%s'") .stderr_contains("date: invalid date '%s'");
.code_is(1);
} }
#[test] #[test]

8
tests/by-util/test_dd.rs
View file

@ -99,7 +99,7 @@ fn build_ascii_block(n: usize) -> Vec<u8> {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
// Sanity Tests // Sanity Tests
@ -1563,8 +1563,7 @@ fn test_nocache_stdin_error() {
let detail = "Invalid seek"; let detail = "Invalid seek";
new_ucmd!() new_ucmd!()
.args(&["iflag=nocache", "count=0", "status=noxfer"]) .args(&["iflag=nocache", "count=0", "status=noxfer"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("dd: failed to discard cache for: 'standard input': {detail}\n0+0 records in\n0+0 records out\n")); .stderr_only(format!("dd: failed to discard cache for: 'standard input': {detail}\n0+0 records in\n0+0 records out\n"));
} }
@ -1573,8 +1572,7 @@ fn test_nocache_stdin_error() {
fn test_empty_count_number() { fn test_empty_count_number() {
new_ucmd!() new_ucmd!()
.args(&["count=B"]) .args(&["count=B"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("dd: invalid number: ‘B’\n"); .stderr_only("dd: invalid number: ‘B’\n");
} }

2
tests/by-util/test_df.rs
View file

@ -16,7 +16,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_dircolors.rs
View file

@ -9,7 +9,7 @@ use dircolors::{guess_syntax, OutputFmt, StrUtils};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_dirname.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

19
tests/by-util/test_du.rs
View file

@ -77,7 +77,7 @@ fn du_basics(s: &str) {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -132,20 +132,17 @@ fn test_du_invalid_size() {
ts.ucmd() ts.ucmd()
.arg(format!("--{s}=1fb4t")) .arg(format!("--{s}=1fb4t"))
.arg("/tmp") .arg("/tmp")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("du: invalid suffix in --{s} argument '1fb4t'\n")); .stderr_only(format!("du: invalid suffix in --{s} argument '1fb4t'\n"));
ts.ucmd() ts.ucmd()
.arg(format!("--{s}=x")) .arg(format!("--{s}=x"))
.arg("/tmp") .arg("/tmp")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("du: invalid --{s} argument 'x'\n")); .stderr_only(format!("du: invalid --{s} argument 'x'\n"));
ts.ucmd() ts.ucmd()
.arg(format!("--{s}=1Y")) .arg(format!("--{s}=1Y"))
.arg("/tmp") .arg("/tmp")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("du: --{s} argument '1Y' too large\n")); .stderr_only(format!("du: --{s} argument '1Y' too large\n"));
} }
} }
@ -1019,7 +1016,7 @@ fn test_du_symlink_fail() {
at.symlink_file("non-existing.txt", "target.txt"); at.symlink_file("non-existing.txt", "target.txt");
ts.ucmd().arg("-L").arg("target.txt").fails().code_is(1); ts.ucmd().arg("-L").arg("target.txt").fails_with_code(1);
} }
#[cfg(not(windows))] #[cfg(not(windows))]
@ -1086,8 +1083,7 @@ fn test_du_files0_from_with_invalid_zero_length_file_names() {
ts.ucmd() ts.ucmd()
.arg("--files0-from=filelist") .arg("--files0-from=filelist")
.fails() .fails_with_code(1)
.code_is(1)
.stdout_contains("testfile") .stdout_contains("testfile")
.stderr_contains("filelist:1: invalid zero-length file name") .stderr_contains("filelist:1: invalid zero-length file name")
.stderr_contains("filelist:3: invalid zero-length file name"); .stderr_contains("filelist:3: invalid zero-length file name");
@ -1133,8 +1129,7 @@ fn test_du_files0_from_stdin_with_invalid_zero_length_file_names() {
new_ucmd!() new_ucmd!()
.arg("--files0-from=-") .arg("--files0-from=-")
.pipe_in("\0\0") .pipe_in("\0\0")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("-:1: invalid zero-length file name") .stderr_contains("-:1: invalid zero-length file name")
.stderr_contains("-:2: invalid zero-length file name"); .stderr_contains("-:2: invalid zero-length file name");
} }

89
tests/by-util/test_env.rs
View file

@ -59,7 +59,7 @@ impl Drop for Target {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(125); new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
} }
#[test] #[test]
@ -84,8 +84,7 @@ fn test_env_version() {
fn test_env_permissions() { fn test_env_permissions() {
new_ucmd!() new_ucmd!()
.arg(".") .arg(".")
.fails() .fails_with_code(126)
.code_is(126)
.stderr_is("env: '.': Permission denied\n"); .stderr_is("env: '.': Permission denied\n");
} }
@ -537,106 +536,91 @@ fn test_env_parsing_errors() {
ts.ucmd() ts.ucmd()
.arg("-S\\|echo hallo") // no quotes, invalid escape sequence | .arg("-S\\|echo hallo") // no quotes, invalid escape sequence |
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\|' in -S\n"); .stderr_is("env: invalid sequence '\\|' in -S\n");
ts.ucmd() ts.ucmd()
.arg("-S\\a") // no quotes, invalid escape sequence a .arg("-S\\a") // no quotes, invalid escape sequence a
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\a' in -S\n"); .stderr_is("env: invalid sequence '\\a' in -S\n");
ts.ucmd() ts.ucmd()
.arg("-S\"\\a\"") // double quotes, invalid escape sequence a .arg("-S\"\\a\"") // double quotes, invalid escape sequence a
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\a' in -S\n"); .stderr_is("env: invalid sequence '\\a' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r#"-S"\a""#) // same as before, just using r#""# .arg(r#"-S"\a""#) // same as before, just using r#""#
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\a' in -S\n"); .stderr_is("env: invalid sequence '\\a' in -S\n");
ts.ucmd() ts.ucmd()
.arg("-S'\\a'") // single quotes, invalid escape sequence a .arg("-S'\\a'") // single quotes, invalid escape sequence a
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\a' in -S\n"); .stderr_is("env: invalid sequence '\\a' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S\|\&\;") // no quotes, invalid escape sequence | .arg(r"-S\|\&\;") // no quotes, invalid escape sequence |
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\|' in -S\n"); .stderr_is("env: invalid sequence '\\|' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S\<\&\;") // no quotes, invalid escape sequence < .arg(r"-S\<\&\;") // no quotes, invalid escape sequence <
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\<' in -S\n"); .stderr_is("env: invalid sequence '\\<' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S\>\&\;") // no quotes, invalid escape sequence > .arg(r"-S\>\&\;") // no quotes, invalid escape sequence >
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\>' in -S\n"); .stderr_is("env: invalid sequence '\\>' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S\`\&\;") // no quotes, invalid escape sequence ` .arg(r"-S\`\&\;") // no quotes, invalid escape sequence `
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r#"-S"\`\&\;""#) // double quotes, invalid escape sequence ` .arg(r#"-S"\`\&\;""#) // double quotes, invalid escape sequence `
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S'\`\&\;'") // single quotes, invalid escape sequence ` .arg(r"-S'\`\&\;'") // single quotes, invalid escape sequence `
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S\`") // ` escaped without quotes .arg(r"-S\`") // ` escaped without quotes
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r#"-S"\`""#) // ` escaped in double quotes .arg(r#"-S"\`""#) // ` escaped in double quotes
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.arg(r"-S'\`'") // ` escaped in single quotes .arg(r"-S'\`'") // ` escaped in single quotes
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\`' in -S\n"); .stderr_is("env: invalid sequence '\\`' in -S\n");
ts.ucmd() ts.ucmd()
.args(&[r"-S\🦉"]) // ` escaped in single quotes .args(&[r"-S\🦉"]) // ` escaped in single quotes
.fails() .fails_with_code(125)
.code_is(125)
.no_stdout() .no_stdout()
.stderr_is("env: invalid sequence '\\\u{FFFD}' in -S\n"); // gnu doesn't show the owl. Instead a invalid unicode ? .stderr_is("env: invalid sequence '\\\u{FFFD}' in -S\n"); // gnu doesn't show the owl. Instead a invalid unicode ?
} }
@ -647,8 +631,7 @@ fn test_env_with_empty_executable_single_quotes() {
ts.ucmd() ts.ucmd()
.args(&["-S''"]) // empty single quotes, considered as program name .args(&["-S''"]) // empty single quotes, considered as program name
.fails() .fails_with_code(127)
.code_is(127)
.no_stdout() .no_stdout()
.stderr_is("env: '': No such file or directory\n"); // gnu version again adds escaping here .stderr_is("env: '': No such file or directory\n"); // gnu version again adds escaping here
} }
@ -659,8 +642,7 @@ fn test_env_with_empty_executable_double_quotes() {
ts.ucmd() ts.ucmd()
.args(&["-S\"\""]) // empty double quotes, considered as program name .args(&["-S\"\""]) // empty double quotes, considered as program name
.fails() .fails_with_code(127)
.code_is(127)
.no_stdout() .no_stdout()
.stderr_is("env: '': No such file or directory\n"); .stderr_is("env: '': No such file or directory\n");
} }
@ -801,23 +783,19 @@ fn test_env_arg_ignore_signal_invalid_signals() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=banana"]) .args(&["--ignore-signal=banana"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: 'banana': invalid signal"); .stderr_contains("env: 'banana': invalid signal");
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=SIGbanana"]) .args(&["--ignore-signal=SIGbanana"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: 'SIGbanana': invalid signal"); .stderr_contains("env: 'SIGbanana': invalid signal");
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=exit"]) .args(&["--ignore-signal=exit"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: 'exit': invalid signal"); .stderr_contains("env: 'exit': invalid signal");
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=SIGexit"]) .args(&["--ignore-signal=SIGexit"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: 'SIGexit': invalid signal"); .stderr_contains("env: 'SIGexit': invalid signal");
} }
@ -829,32 +807,28 @@ fn test_env_arg_ignore_signal_special_signals() {
let signal_kill = nix::sys::signal::SIGKILL; let signal_kill = nix::sys::signal::SIGKILL;
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=stop", "echo", "hello"]) .args(&["--ignore-signal=stop", "echo", "hello"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains(format!( .stderr_contains(format!(
"env: failed to set signal action for signal {}: Invalid argument", "env: failed to set signal action for signal {}: Invalid argument",
signal_stop as i32 signal_stop as i32
)); ));
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=kill", "echo", "hello"]) .args(&["--ignore-signal=kill", "echo", "hello"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains(format!( .stderr_contains(format!(
"env: failed to set signal action for signal {}: Invalid argument", "env: failed to set signal action for signal {}: Invalid argument",
signal_kill as i32 signal_kill as i32
)); ));
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=SToP", "echo", "hello"]) .args(&["--ignore-signal=SToP", "echo", "hello"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains(format!( .stderr_contains(format!(
"env: failed to set signal action for signal {}: Invalid argument", "env: failed to set signal action for signal {}: Invalid argument",
signal_stop as i32 signal_stop as i32
)); ));
ts.ucmd() ts.ucmd()
.args(&["--ignore-signal=SIGKILL", "echo", "hello"]) .args(&["--ignore-signal=SIGKILL", "echo", "hello"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains(format!( .stderr_contains(format!(
"env: failed to set signal action for signal {}: Invalid argument", "env: failed to set signal action for signal {}: Invalid argument",
signal_kill as i32 signal_kill as i32
@ -898,19 +872,16 @@ fn disallow_equals_sign_on_short_unset_option() {
ts.ucmd() ts.ucmd()
.arg("-u=") .arg("-u=")
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: cannot unset '=': Invalid argument"); .stderr_contains("env: cannot unset '=': Invalid argument");
ts.ucmd() ts.ucmd()
.arg("-u=A1B2C3") .arg("-u=A1B2C3")
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: cannot unset '=A1B2C3': Invalid argument"); .stderr_contains("env: cannot unset '=A1B2C3': Invalid argument");
ts.ucmd().arg("--split-string=A1B=2C3=").succeeds(); ts.ucmd().arg("--split-string=A1B=2C3=").succeeds();
ts.ucmd() ts.ucmd()
.arg("--unset=") .arg("--unset=")
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("env: cannot unset '': Invalid argument"); .stderr_contains("env: cannot unset '': Invalid argument");
} }

2
tests/by-util/test_expand.rs
View file

@ -8,7 +8,7 @@ use uucore::display::Quotable;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

44
tests/by-util/test_expr.rs
View file

@ -9,29 +9,25 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_no_arguments() { fn test_no_arguments() {
new_ucmd!() new_ucmd!()
.fails() .fails_with_code(2)
.code_is(2)
.usage_error("missing operand"); .usage_error("missing operand");
} }
#[test] #[test]
fn test_simple_values() { fn test_simple_values() {
// null or 0 => EXIT_VALUE == 1 // null or 0 => EXIT_VALUE == 1
new_ucmd!().args(&[""]).fails().code_is(1).stdout_only("\n"); new_ucmd!().args(&[""]).fails_with_code(1).stdout_only("\n");
new_ucmd!() new_ucmd!()
.args(&["0"]) .args(&["0"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("0\n"); .stdout_only("0\n");
new_ucmd!() new_ucmd!()
.args(&["00"]) .args(&["00"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("00\n"); .stdout_only("00\n");
new_ucmd!() new_ucmd!()
.args(&["-0"]) .args(&["-0"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("-0\n"); .stdout_only("-0\n");
// non-null and non-0 => EXIT_VALUE = 0 // non-null and non-0 => EXIT_VALUE = 0
@ -47,8 +43,7 @@ fn test_simple_arithmetic() {
new_ucmd!() new_ucmd!()
.args(&["1", "-", "1"]) .args(&["1", "-", "1"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("0\n"); .stdout_only("0\n");
new_ucmd!() new_ucmd!()
@ -111,8 +106,7 @@ fn test_parenthesis() {
new_ucmd!() new_ucmd!()
.args(&["1", "(", ")"]) .args(&["1", "(", ")"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("expr: syntax error: unexpected argument '('\n"); .stderr_only("expr: syntax error: unexpected argument '('\n");
} }
@ -208,8 +202,7 @@ fn test_and() {
fn test_index() { fn test_index() {
new_ucmd!() new_ucmd!()
.args(&["index", "αbcdef", "x"]) .args(&["index", "αbcdef", "x"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("0\n"); .stdout_only("0\n");
new_ucmd!() new_ucmd!()
.args(&["index", "αbcdef", "α"]) .args(&["index", "αbcdef", "α"])
@ -238,8 +231,7 @@ fn test_index() {
new_ucmd!() new_ucmd!()
.args(&["αbcdef", "index", "α"]) .args(&["αbcdef", "index", "α"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("expr: syntax error: unexpected argument 'index'\n"); .stderr_only("expr: syntax error: unexpected argument 'index'\n");
} }
@ -257,8 +249,7 @@ fn test_length() {
new_ucmd!() new_ucmd!()
.args(&["abcdef", "length"]) .args(&["abcdef", "length"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("expr: syntax error: unexpected argument 'length'\n"); .stderr_only("expr: syntax error: unexpected argument 'length'\n");
} }
@ -304,8 +295,7 @@ fn test_substr() {
new_ucmd!() new_ucmd!()
.args(&["abc", "substr", "1", "1"]) .args(&["abc", "substr", "1", "1"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("expr: syntax error: unexpected argument 'substr'\n"); .stderr_only("expr: syntax error: unexpected argument 'substr'\n");
} }
@ -313,20 +303,17 @@ fn test_substr() {
fn test_invalid_substr() { fn test_invalid_substr() {
new_ucmd!() new_ucmd!()
.args(&["substr", "abc", "0", "1"]) .args(&["substr", "abc", "0", "1"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("\n"); .stdout_only("\n");
new_ucmd!() new_ucmd!()
.args(&["substr", "abc", &(usize::MAX.to_string() + "0"), "1"]) .args(&["substr", "abc", &(usize::MAX.to_string() + "0"), "1"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("\n"); .stdout_only("\n");
new_ucmd!() new_ucmd!()
.args(&["substr", "abc", "0", &(usize::MAX.to_string() + "0")]) .args(&["substr", "abc", "0", &(usize::MAX.to_string() + "0")])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_only("\n"); .stdout_only("\n");
} }
@ -357,8 +344,7 @@ fn test_invalid_syntax() {
for invalid_syntax in invalid_syntaxes { for invalid_syntax in invalid_syntaxes {
new_ucmd!() new_ucmd!()
.args(&invalid_syntax) .args(&invalid_syntax)
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("syntax error"); .stderr_contains("syntax error");
} }
} }

2
tests/by-util/test_factor.rs
View file

@ -22,7 +22,7 @@ const NUM_TESTS: usize = 100;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

37
tests/by-util/test_fmt.rs
View file

@ -6,12 +6,12 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_invalid_input() { fn test_invalid_input() {
new_ucmd!().arg(".").fails().code_is(1); new_ucmd!().arg(".").fails_with_code(1);
} }
#[test] #[test]
@ -50,8 +50,7 @@ fn test_fmt_width() {
fn test_fmt_width_invalid() { fn test_fmt_width_invalid() {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", "-w", "apple"]) .args(&["one-word-per-line.txt", "-w", "apple"])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout() .no_stdout()
.stderr_is("fmt: invalid width: 'apple'\n"); .stderr_is("fmt: invalid width: 'apple'\n");
// an invalid width can be successfully overwritten later: // an invalid width can be successfully overwritten later:
@ -86,8 +85,7 @@ fn test_fmt_width_too_big() {
for param in ["-w", "--width"] { for param in ["-w", "--width"] {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", param, "2501"]) .args(&["one-word-per-line.txt", param, "2501"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("fmt: invalid width: '2501': Numerical result out of range\n"); .stderr_is("fmt: invalid width: '2501': Numerical result out of range\n");
} }
// However, as a temporary value it is okay: // However, as a temporary value it is okay:
@ -102,8 +100,7 @@ fn test_fmt_invalid_width() {
for param in ["-w", "--width"] { for param in ["-w", "--width"] {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", param, "invalid"]) .args(&["one-word-per-line.txt", param, "invalid"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("invalid width: 'invalid'"); .stderr_contains("invalid width: 'invalid'");
} }
} }
@ -112,8 +109,7 @@ fn test_fmt_invalid_width() {
fn test_fmt_positional_width_not_first() { fn test_fmt_positional_width_not_first() {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", "-10"]) .args(&["one-word-per-line.txt", "-10"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("fmt: invalid option -- 1; -WIDTH is recognized only when it is the first\noption; use -w N instead"); .stderr_contains("fmt: invalid option -- 1; -WIDTH is recognized only when it is the first\noption; use -w N instead");
} }
@ -121,8 +117,7 @@ fn test_fmt_positional_width_not_first() {
fn test_fmt_width_not_valid_number() { fn test_fmt_width_not_valid_number() {
new_ucmd!() new_ucmd!()
.args(&["-25x", "one-word-per-line.txt"]) .args(&["-25x", "one-word-per-line.txt"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("fmt: invalid width: '25x'"); .stderr_contains("fmt: invalid width: '25x'");
} }
@ -146,8 +141,7 @@ fn test_fmt_goal_too_big() {
for param in ["-g", "--goal"] { for param in ["-g", "--goal"] {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", "--width=75", param, "76"]) .args(&["one-word-per-line.txt", "--width=75", param, "76"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("fmt: GOAL cannot be greater than WIDTH.\n"); .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
} }
} }
@ -157,8 +151,7 @@ fn test_fmt_goal_bigger_than_default_width_of_75() {
for param in ["-g", "--goal"] { for param in ["-g", "--goal"] {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", param, "76"]) .args(&["one-word-per-line.txt", param, "76"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("fmt: GOAL cannot be greater than WIDTH.\n"); .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
} }
} }
@ -190,8 +183,7 @@ fn test_fmt_goal_too_small_to_check_negative_minlength() {
fn test_fmt_non_existent_file() { fn test_fmt_non_existent_file() {
new_ucmd!() new_ucmd!()
.args(&["non-existing"]) .args(&["non-existing"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("fmt: cannot open 'non-existing' for reading: No such file or directory\n"); .stderr_is("fmt: cannot open 'non-existing' for reading: No such file or directory\n");
} }
@ -200,8 +192,7 @@ fn test_fmt_invalid_goal() {
for param in ["-g", "--goal"] { for param in ["-g", "--goal"] {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", param, "invalid"]) .args(&["one-word-per-line.txt", param, "invalid"])
.fails() .fails_with_code(1)
.code_is(1)
// GNU complains about "invalid width", which is confusing. // GNU complains about "invalid width", which is confusing.
// We intentionally deviate from GNU, and show a more helpful message: // We intentionally deviate from GNU, and show a more helpful message:
.stderr_contains("invalid goal: 'invalid'"); .stderr_contains("invalid goal: 'invalid'");
@ -220,14 +211,12 @@ fn test_fmt_invalid_goal_override() {
fn test_fmt_invalid_goal_width_priority() { fn test_fmt_invalid_goal_width_priority() {
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", "-g", "apple", "-w", "banana"]) .args(&["one-word-per-line.txt", "-g", "apple", "-w", "banana"])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout() .no_stdout()
.stderr_is("fmt: invalid width: 'banana'\n"); .stderr_is("fmt: invalid width: 'banana'\n");
new_ucmd!() new_ucmd!()
.args(&["one-word-per-line.txt", "-w", "banana", "-g", "apple"]) .args(&["one-word-per-line.txt", "-w", "banana", "-g", "apple"])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout() .no_stdout()
.stderr_is("fmt: invalid width: 'banana'\n"); .stderr_is("fmt: invalid width: 'banana'\n");
} }

2
tests/by-util/test_fold.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_groups.rs
View file

@ -12,7 +12,7 @@ const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced
#[test] #[test]
#[cfg(unix)] #[cfg(unix)]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

17
tests/by-util/test_hashsum.rs
View file

@ -228,8 +228,7 @@ fn test_invalid_b2sum_length_option_not_multiple_of_8() {
.ccmd("b2sum") .ccmd("b2sum")
.arg("--length=9") .arg("--length=9")
.arg(at.subdir.join("testf")) .arg(at.subdir.join("testf"))
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -243,8 +242,7 @@ fn test_invalid_b2sum_length_option_too_large() {
.ccmd("b2sum") .ccmd("b2sum")
.arg("--length=513") .arg("--length=513")
.arg(at.subdir.join("testf")) .arg(at.subdir.join("testf"))
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -473,13 +471,12 @@ fn test_check_md5sum_mixed_format() {
.arg("--strict") .arg("--strict")
.arg("-c") .arg("-c")
.arg("check.md5sum") .arg("check.md5sum")
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -488,14 +485,12 @@ fn test_conflicting_arg() {
.arg("--tag") .arg("--tag")
.arg("--check") .arg("--check")
.arg("--md5") .arg("--md5")
.fails() .fails_with_code(1);
.code_is(1);
new_ucmd!() new_ucmd!()
.arg("--tag") .arg("--tag")
.arg("--text") .arg("--text")
.arg("--md5") .arg("--md5")
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]

2
tests/by-util/test_head.rs
View file

@ -20,7 +20,7 @@ static INPUT: &str = "lorem_ipsum.txt";
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

5
tests/by-util/test_hostid.rs
View file

@ -15,7 +15,6 @@ fn test_normal() {
fn test_invalid_flag() { fn test_invalid_flag() {
new_ucmd!() new_ucmd!()
.arg("--invalid-argument") .arg("--invalid-argument")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout();
.code_is(1);
} }

2
tests/by-util/test_hostname.rs
View file

@ -35,5 +35,5 @@ fn test_hostname_full() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }

2
tests/by-util/test_id.rs
View file

@ -11,7 +11,7 @@ const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

20
tests/by-util/test_install.rs
View file

@ -17,7 +17,7 @@ use uucore::process::{getegid, geteuid};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -490,8 +490,7 @@ fn test_install_failing_omitting_directory() {
.arg(file1) .arg(file1)
.arg(dir1) .arg(dir1)
.arg(dir3) .arg(dir3)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("omitting directory"); .stderr_contains("omitting directory");
assert!(at.file_exists(format!("{dir3}/{file1}"))); assert!(at.file_exists(format!("{dir3}/{file1}")));
@ -500,8 +499,7 @@ fn test_install_failing_omitting_directory() {
.ucmd() .ucmd()
.arg(dir1) .arg(dir1)
.arg(dir3) .arg(dir3)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("omitting directory"); .stderr_contains("omitting directory");
} }
@ -518,8 +516,7 @@ fn test_install_failing_no_such_file() {
ucmd.arg(file1) ucmd.arg(file1)
.arg(file2) .arg(file2)
.arg(dir1) .arg(dir1)
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("No such file or directory"); .stderr_contains("No such file or directory");
} }
@ -1391,8 +1388,7 @@ fn test_install_missing_arguments() {
scene scene
.ucmd() .ucmd()
.fails() .fails_with_code(1)
.code_is(1)
.usage_error("missing file operand"); .usage_error("missing file operand");
scene scene
@ -1630,14 +1626,12 @@ fn test_install_compare_option() {
scene scene
.ucmd() .ucmd()
.args(&["-C", "--preserve-timestamps", first, second]) .args(&["-C", "--preserve-timestamps", first, second])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Options --compare and --preserve-timestamps are mutually exclusive"); .stderr_contains("Options --compare and --preserve-timestamps are mutually exclusive");
scene scene
.ucmd() .ucmd()
.args(&["-C", "--strip", "--strip-program=echo", first, second]) .args(&["-C", "--strip", "--strip-program=echo", first, second])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Options --compare and --strip are mutually exclusive"); .stderr_contains("Options --compare and --strip are mutually exclusive");
} }

2
tests/by-util/test_join.rs
View file

@ -14,7 +14,7 @@ use std::{ffi::OsString, os::windows::ffi::OsStringExt};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_kill.rs
View file

@ -51,7 +51,7 @@ impl Drop for Target {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_link.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[cfg(not(target_os = "android"))] #[cfg(not(target_os = "android"))]

5
tests/by-util/test_ln.rs
View file

@ -9,7 +9,7 @@ use std::path::PathBuf;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -776,8 +776,7 @@ fn test_symlink_remove_existing_same_src_and_dest() {
at.touch("a"); at.touch("a");
at.write("a", "sample"); at.write("a", "sample");
ucmd.args(&["-sf", "a", "a"]) ucmd.args(&["-sf", "a", "a"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("'a' and 'a' are the same file"); .stderr_contains("'a' and 'a' are the same file");
assert!(at.file_exists("a") && !at.symlink_exists("a")); assert!(at.file_exists("a") && !at.symlink_exists("a"));
assert_eq!(at.read("a"), "sample"); assert_eq!(at.read("a"), "sample");

2
tests/by-util/test_logname.rs
View file

@ -7,7 +7,7 @@ use std::env;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

62
tests/by-util/test_ls.rs
View file

@ -57,9 +57,8 @@ const COLUMN_ARGS: &[&str] = &["-C", "--format=columns", "--for=columns"];
fn test_invalid_flag() { fn test_invalid_flag() {
new_ucmd!() new_ucmd!()
.arg("--invalid-argument") .arg("--invalid-argument")
.fails() .fails_with_code(2)
.no_stdout() .no_stdout();
.code_is(2);
} }
#[test] #[test]
@ -77,9 +76,8 @@ fn test_invalid_value_returns_1() {
] { ] {
new_ucmd!() new_ucmd!()
.arg(format!("{flag}=definitely_invalid_value")) .arg(format!("{flag}=definitely_invalid_value"))
.fails() .fails_with_code(1)
.no_stdout() .no_stdout();
.code_is(1);
} }
} }
@ -89,9 +87,8 @@ fn test_invalid_value_returns_2() {
for flag in ["--block-size", "--width", "--tab-size"] { for flag in ["--block-size", "--width", "--tab-size"] {
new_ucmd!() new_ucmd!()
.arg(format!("{flag}=definitely_invalid_value")) .arg(format!("{flag}=definitely_invalid_value"))
.fails() .fails_with_code(2)
.no_stdout() .no_stdout();
.code_is(2);
} }
} }
@ -107,9 +104,8 @@ fn test_invalid_value_time_style() {
new_ucmd!() new_ucmd!()
.arg("-g") .arg("-g")
.arg("--time-style=definitely_invalid_value") .arg("--time-style=definitely_invalid_value")
.fails() .fails_with_code(2)
.no_stdout() .no_stdout();
.code_is(2);
// If it only looks temporarily like it might be used, no error: // If it only looks temporarily like it might be used, no error:
new_ucmd!() new_ucmd!()
.arg("-l") .arg("-l")
@ -505,8 +501,7 @@ fn test_ls_io_errors() {
.ucmd() .ucmd()
.arg("-1") .arg("-1")
.arg("some-dir1") .arg("some-dir1")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("cannot open directory") .stderr_contains("cannot open directory")
.stderr_contains("Permission denied"); .stderr_contains("Permission denied");
@ -514,8 +509,7 @@ fn test_ls_io_errors() {
.ucmd() .ucmd()
.arg("-Li") .arg("-Li")
.arg("some-dir2") .arg("some-dir2")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("cannot access") .stderr_contains("cannot access")
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" }); .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@ -530,8 +524,7 @@ fn test_ls_io_errors() {
.ucmd() .ucmd()
.arg("-laR") .arg("-laR")
.arg("some-dir3") .arg("some-dir3")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("some-dir4") .stderr_contains("some-dir4")
.stderr_contains("cannot open directory") .stderr_contains("cannot open directory")
.stderr_contains("Permission denied") .stderr_contains("Permission denied")
@ -1980,8 +1973,7 @@ fn test_ls_styles() {
.ucmd() .ucmd()
.arg("-l") .arg("-l")
.arg("--time-style=invalid") .arg("--time-style=invalid")
.fails() .fails_with_code(2);
.code_is(2);
//Overwrite options tests //Overwrite options tests
scene scene
@ -4075,14 +4067,12 @@ fn test_ls_dangling_symlinks() {
.ucmd() .ucmd()
.arg("-L") .arg("-L")
.arg("temp_dir/dangle") .arg("temp_dir/dangle")
.fails() .fails_with_code(2);
.code_is(2);
scene scene
.ucmd() .ucmd()
.arg("-H") .arg("-H")
.arg("temp_dir/dangle") .arg("temp_dir/dangle")
.fails() .fails_with_code(2);
.code_is(2);
scene scene
.ucmd() .ucmd()
@ -4094,8 +4084,7 @@ fn test_ls_dangling_symlinks() {
.ucmd() .ucmd()
.arg("-Li") .arg("-Li")
.arg("temp_dir") .arg("temp_dir")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("cannot access") .stderr_contains("cannot access")
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" }); .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@ -4104,8 +4093,7 @@ fn test_ls_dangling_symlinks() {
.ucmd() .ucmd()
.arg("-LZ") .arg("-LZ")
.arg("temp_dir") .arg("temp_dir")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("cannot access") .stderr_contains("cannot access")
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" }); .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@ -4114,8 +4102,7 @@ fn test_ls_dangling_symlinks() {
.ucmd() .ucmd()
.arg("-Ll") .arg("-Ll")
.arg("temp_dir") .arg("temp_dir")
.fails() .fails_with_code(1)
.code_is(1)
.stdout_contains("l?????????"); .stdout_contains("l?????????");
#[cfg(unix)] #[cfg(unix)]
@ -4308,8 +4295,7 @@ fn test_ls_dereference_looped_symlinks_recursive() {
at.relative_symlink_dir("../loop", "loop/sub"); at.relative_symlink_dir("../loop", "loop/sub");
ucmd.args(&["-RL", "loop"]) ucmd.args(&["-RL", "loop"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("not listing already-listed directory"); .stderr_contains("not listing already-listed directory");
} }
@ -4322,8 +4308,7 @@ fn test_dereference_dangling_color() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
at.relative_symlink_file("wat", "nonexistent"); at.relative_symlink_file("wat", "nonexistent");
ucmd.args(&["-L", "--color"]) ucmd.args(&["-L", "--color"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.stdout_is(out_exp); .stdout_is(out_exp);
} }
@ -4458,8 +4443,7 @@ fn test_ls_perm_io_errors() {
.ucmd() .ucmd()
.arg("-l") .arg("-l")
.arg("d") .arg("d")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Permission denied"); .stderr_contains("Permission denied");
} }
@ -4537,8 +4521,7 @@ fn test_ls_dired_and_zero_are_incompatible() {
.arg("--dired") .arg("--dired")
.arg("-l") .arg("-l")
.arg("--zero") .arg("--zero")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("--dired and --zero are incompatible"); .stderr_contains("--dired and --zero are incompatible");
} }
@ -4917,8 +4900,7 @@ fn test_posixly_correct_and_block_size_env_vars_with_k() {
fn test_ls_invalid_block_size() { fn test_ls_invalid_block_size() {
new_ucmd!() new_ucmd!()
.arg("--block-size=invalid") .arg("--block-size=invalid")
.fails() .fails_with_code(2)
.code_is(2)
.no_stdout() .no_stdout()
.stderr_is("ls: invalid --block-size argument 'invalid'\n"); .stderr_is("ls: invalid --block-size argument 'invalid'\n");
} }

5
tests/by-util/test_mkdir.rs
View file

@ -15,14 +15,13 @@ use std::os::unix::fs::PermissionsExt;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_no_arg() { fn test_no_arg() {
new_ucmd!() new_ucmd!()
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("error: the following required arguments were not provided:"); .stderr_contains("error: the following required arguments were not provided:");
} }

2
tests/by-util/test_mkfifo.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

8
tests/by-util/test_mknod.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
#[cfg(not(windows))] #[cfg(not(windows))]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[cfg(not(windows))] #[cfg(not(windows))]
@ -80,15 +80,13 @@ fn test_mknod_character_device_requires_major_and_minor() {
new_ucmd!() new_ucmd!()
.arg("test_file") .arg("test_file")
.arg("c") .arg("c")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Special files require major and minor device numbers."); .stderr_contains("Special files require major and minor device numbers.");
new_ucmd!() new_ucmd!()
.arg("test_file") .arg("test_file")
.arg("c") .arg("c")
.arg("1") .arg("1")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Special files require major and minor device numbers."); .stderr_contains("Special files require major and minor device numbers.");
new_ucmd!() new_ucmd!()
.arg("test_file") .arg("test_file")

3
tests/by-util/test_mktemp.rs
View file

@ -644,8 +644,7 @@ fn test_too_few_xs_suffix_directory() {
fn test_too_many_arguments() { fn test_too_many_arguments() {
new_ucmd!() new_ucmd!()
.args(&["-q", "a", "b"]) .args(&["-q", "a", "b"])
.fails() .fails_with_code(1)
.code_is(1)
.usage_error("too many templates"); .usage_error("too many templates");
} }

2
tests/by-util/test_mv.rs
View file

@ -11,7 +11,7 @@ use std::io::Write;
#[test] #[test]
fn test_mv_invalid_arg() { fn test_mv_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_nice.rs
View file

@ -68,7 +68,7 @@ fn test_command_where_command_takes_n_flag() {
#[test] #[test]
fn test_invalid_argument() { fn test_invalid_argument() {
new_ucmd!().arg("--invalid").fails().code_is(125); new_ucmd!().arg("--invalid").fails_with_code(125);
} }
#[test] #[test]

2
tests/by-util/test_nl.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_nohup.rs
View file

@ -13,7 +13,7 @@ use std::thread::sleep;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(125); new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
} }
#[test] #[test]

2
tests/by-util/test_nproc.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

60
tests/by-util/test_numfmt.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -58,8 +58,7 @@ fn test_from_iec_i() {
fn test_from_iec_i_requires_suffix() { fn test_from_iec_i_requires_suffix() {
new_ucmd!() new_ucmd!()
.args(&["--from=iec-i", "10M"]) .args(&["--from=iec-i", "10M"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_is("numfmt: missing 'i' suffix in input: '10M' (e.g Ki/Mi/Gi)\n"); .stderr_is("numfmt: missing 'i' suffix in input: '10M' (e.g Ki/Mi/Gi)\n");
} }
@ -257,8 +256,7 @@ fn test_suffixes() {
} else { } else {
new_ucmd!() new_ucmd!()
.args(&args) .args(&args)
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only(format!("numfmt: invalid suffix in input: '1{c}'\n")); .stderr_only(format!("numfmt: invalid suffix in input: '1{c}'\n"));
} }
} }
@ -683,7 +681,7 @@ fn test_suffix_with_padding() {
#[test] #[test]
fn test_invalid_stdin_number_returns_status_2() { fn test_invalid_stdin_number_returns_status_2() {
new_ucmd!().pipe_in("hello").fails().code_is(2); new_ucmd!().pipe_in("hello").fails_with_code(2);
} }
#[test] #[test]
@ -691,9 +689,8 @@ fn test_invalid_stdin_number_in_middle_of_input() {
new_ucmd!() new_ucmd!()
.pipe_in("100\nhello\n200") .pipe_in("100\nhello\n200")
.ignore_stdin_write_error() .ignore_stdin_write_error()
.fails() .fails_with_code(2)
.stdout_is("100\n") .stdout_is("100\n");
.code_is(2);
} }
#[test] #[test]
@ -720,8 +717,7 @@ fn test_invalid_stdin_number_with_abort_returns_status_2() {
new_ucmd!() new_ucmd!()
.args(&["--invalid=abort"]) .args(&["--invalid=abort"])
.pipe_in("4Q") .pipe_in("4Q")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("numfmt: invalid suffix in input: '4Q'\n"); .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
} }
@ -730,8 +726,7 @@ fn test_invalid_stdin_number_with_fail_returns_status_2() {
new_ucmd!() new_ucmd!()
.args(&["--invalid=fail"]) .args(&["--invalid=fail"])
.pipe_in("4Q") .pipe_in("4Q")
.fails() .fails_with_code(2)
.code_is(2)
.stdout_is("4Q\n") .stdout_is("4Q\n")
.stderr_is("numfmt: invalid suffix in input: '4Q'\n"); .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
} }
@ -757,8 +752,7 @@ fn test_invalid_arg_number_with_ignore_returns_status_0() {
fn test_invalid_arg_number_with_abort_returns_status_2() { fn test_invalid_arg_number_with_abort_returns_status_2() {
new_ucmd!() new_ucmd!()
.args(&["--invalid=abort", "4Q"]) .args(&["--invalid=abort", "4Q"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("numfmt: invalid suffix in input: '4Q'\n"); .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
} }
@ -766,8 +760,7 @@ fn test_invalid_arg_number_with_abort_returns_status_2() {
fn test_invalid_arg_number_with_fail_returns_status_2() { fn test_invalid_arg_number_with_fail_returns_status_2() {
new_ucmd!() new_ucmd!()
.args(&["--invalid=fail", "4Q"]) .args(&["--invalid=fail", "4Q"])
.fails() .fails_with_code(2)
.code_is(2)
.stdout_is("4Q\n") .stdout_is("4Q\n")
.stderr_is("numfmt: invalid suffix in input: '4Q'\n"); .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
} }
@ -778,8 +771,7 @@ fn test_invalid_argument_returns_status_1() {
.args(&["--header=hello"]) .args(&["--header=hello"])
.pipe_in("53478") .pipe_in("53478")
.ignore_stdin_write_error() .ignore_stdin_write_error()
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -790,8 +782,7 @@ fn test_invalid_padding_value() {
new_ucmd!() new_ucmd!()
.arg(format!("--padding={padding_value}")) .arg(format!("--padding={padding_value}"))
.arg("5") .arg("5")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("invalid padding value '{padding_value}'")); .stderr_contains(format!("invalid padding value '{padding_value}'"));
} }
} }
@ -821,8 +812,7 @@ fn test_invalid_unit_size() {
for invalid_size in &invalid_sizes { for invalid_size in &invalid_sizes {
new_ucmd!() new_ucmd!()
.arg(format!("--{command}-unit={invalid_size}")) .arg(format!("--{command}-unit={invalid_size}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("invalid unit size: '{invalid_size}'")); .stderr_contains(format!("invalid unit size: '{invalid_size}'"));
} }
} }
@ -835,8 +825,7 @@ fn test_valid_but_forbidden_suffix() {
for number in numbers { for number in numbers {
new_ucmd!() new_ucmd!()
.arg(number) .arg(number)
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains(format!( .stderr_contains(format!(
"rejecting suffix in input: '{number}' (consider using --from)" "rejecting suffix in input: '{number}' (consider using --from)"
)); ));
@ -1011,8 +1000,7 @@ fn test_format_without_percentage_directive() {
for invalid_format in invalid_formats { for invalid_format in invalid_formats {
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("format '{invalid_format}' has no % directive")); .stderr_contains(format!("format '{invalid_format}' has no % directive"));
} }
} }
@ -1023,8 +1011,7 @@ fn test_format_with_percentage_directive_at_end() {
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("format '{invalid_format}' ends in %")); .stderr_contains(format!("format '{invalid_format}' ends in %"));
} }
@ -1034,8 +1021,7 @@ fn test_format_with_too_many_percentage_directives() {
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!( .stderr_contains(format!(
"format '{invalid_format}' has too many % directives" "format '{invalid_format}' has too many % directives"
)); ));
@ -1048,8 +1034,7 @@ fn test_format_with_invalid_format() {
for invalid_format in invalid_formats { for invalid_format in invalid_formats {
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!( .stderr_contains(format!(
"invalid format '{invalid_format}', directive must be %[0]['][-][N][.][N]f" "invalid format '{invalid_format}', directive must be %[0]['][-][N][.][N]f"
)); ));
@ -1061,8 +1046,7 @@ fn test_format_with_width_overflow() {
let invalid_format = "%18446744073709551616f"; let invalid_format = "%18446744073709551616f";
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!( .stderr_contains(format!(
"invalid format '{invalid_format}' (width overflow)" "invalid format '{invalid_format}' (width overflow)"
)); ));
@ -1075,8 +1059,7 @@ fn test_format_with_invalid_precision() {
for invalid_format in invalid_formats { for invalid_format in invalid_formats {
new_ucmd!() new_ucmd!()
.arg(format!("--format={invalid_format}")) .arg(format!("--format={invalid_format}"))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(format!("invalid precision in format '{invalid_format}'")); .stderr_contains(format!("invalid precision in format '{invalid_format}'"));
} }
} }
@ -1085,7 +1068,6 @@ fn test_format_with_invalid_precision() {
fn test_format_grouping_conflicts_with_to_option() { fn test_format_grouping_conflicts_with_to_option() {
new_ucmd!() new_ucmd!()
.args(&["--format=%'f", "--to=si"]) .args(&["--format=%'f", "--to=si"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("grouping cannot be combined with --to"); .stderr_contains("grouping cannot be combined with --to");
} }

11
tests/by-util/test_od.rs
View file

@ -17,7 +17,7 @@ static ALPHA_OUT: &str = "
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
// Test that od can read one file and dump with default format // Test that od can read one file and dump with default format
@ -868,15 +868,13 @@ fn test_od_invalid_bytes() {
new_ucmd!() new_ucmd!()
.arg(format!("{option}={INVALID_SIZE}")) .arg(format!("{option}={INVALID_SIZE}"))
.arg("file") .arg("file")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("od: invalid {option} argument '{INVALID_SIZE}'\n")); .stderr_only(format!("od: invalid {option} argument '{INVALID_SIZE}'\n"));
new_ucmd!() new_ucmd!()
.arg(format!("{option}={INVALID_SUFFIX}")) .arg(format!("{option}={INVALID_SUFFIX}"))
.arg("file") .arg("file")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!( .stderr_only(format!(
"od: invalid suffix in {option} argument '{INVALID_SUFFIX}'\n" "od: invalid suffix in {option} argument '{INVALID_SUFFIX}'\n"
)); ));
@ -884,8 +882,7 @@ fn test_od_invalid_bytes() {
new_ucmd!() new_ucmd!()
.arg(format!("{option}={BIG_SIZE}")) .arg(format!("{option}={BIG_SIZE}"))
.arg("file") .arg("file")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only(format!("od: {option} argument '{BIG_SIZE}' too large\n")); .stderr_only(format!("od: {option} argument '{BIG_SIZE}' too large\n"));
} }
} }

2
tests/by-util/test_paste.rs
View file

@ -137,7 +137,7 @@ const EXAMPLE_DATA: &[TestData] = &[
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_pathchk.rs
View file

@ -14,7 +14,7 @@ fn test_no_args() {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_pinky.rs
View file

@ -13,7 +13,7 @@ use uucore::entries::{Locate, Passwd};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

5
tests/by-util/test_pr.rs
View file

@ -47,9 +47,8 @@ fn valid_last_modified_template_vars(from: DateTime<Utc>) -> Vec<Vec<(String, St
fn test_invalid_flag() { fn test_invalid_flag() {
new_ucmd!() new_ucmd!()
.arg("--invalid-argument") .arg("--invalid-argument")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout();
.code_is(1);
} }
#[test] #[test]

22
tests/by-util/test_printf.rs
View file

@ -50,8 +50,7 @@ fn escaped_hex() {
fn test_missing_escaped_hex_value() { fn test_missing_escaped_hex_value() {
new_ucmd!() new_ucmd!()
.arg(r"\x") .arg(r"\x")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("printf: missing hexadecimal number in escape\n"); .stderr_only("printf: missing hexadecimal number in escape\n");
} }
@ -289,8 +288,7 @@ fn sub_num_hex_upper() {
fn sub_num_hex_non_numerical() { fn sub_num_hex_non_numerical() {
new_ucmd!() new_ucmd!()
.args(&["parameters need to be numbers %X", "%194"]) .args(&["parameters need to be numbers %X", "%194"])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -640,8 +638,7 @@ fn sub_general_round_float_leading_zeroes() {
fn partial_float() { fn partial_float() {
new_ucmd!() new_ucmd!()
.args(&["%.2f is %s", "42.03x", "a lot"]) .args(&["%.2f is %s", "42.03x", "a lot"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("42.03 is a lot") .stdout_is("42.03 is a lot")
.stderr_is("printf: '42.03x': value not completely converted\n"); .stderr_is("printf: '42.03x': value not completely converted\n");
} }
@ -650,8 +647,7 @@ fn partial_float() {
fn partial_integer() { fn partial_integer() {
new_ucmd!() new_ucmd!()
.args(&["%d is %s", "42x23", "a lot"]) .args(&["%d is %s", "42x23", "a lot"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("42 is a lot") .stdout_is("42 is a lot")
.stderr_is("printf: '42x23': value not completely converted\n"); .stderr_is("printf: '42x23': value not completely converted\n");
} }
@ -660,8 +656,7 @@ fn partial_integer() {
fn test_overflow() { fn test_overflow() {
new_ucmd!() new_ucmd!()
.args(&["%d", "36893488147419103232"]) .args(&["%d", "36893488147419103232"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("printf: '36893488147419103232': Numerical result out of range\n"); .stderr_is("printf: '36893488147419103232': Numerical result out of range\n");
} }
@ -669,8 +664,7 @@ fn test_overflow() {
fn partial_char() { fn partial_char() {
new_ucmd!() new_ucmd!()
.args(&["%d", "'abc"]) .args(&["%d", "'abc"])
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("97") .stdout_is("97")
.stderr_is( .stderr_is(
"printf: warning: bc: character(s) following character constant have been ignored\n", "printf: warning: bc: character(s) following character constant have been ignored\n",
@ -805,13 +799,13 @@ fn pad_string() {
#[test] #[test]
fn format_spec_zero_char_fails() { fn format_spec_zero_char_fails() {
// It is invalid to have the format spec '%0c' // It is invalid to have the format spec '%0c'
new_ucmd!().args(&["%0c", "3"]).fails().code_is(1); new_ucmd!().args(&["%0c", "3"]).fails_with_code(1);
} }
#[test] #[test]
fn format_spec_zero_string_fails() { fn format_spec_zero_string_fails() {
// It is invalid to have the format spec '%0s' // It is invalid to have the format spec '%0s'
new_ucmd!().args(&["%0s", "3"]).fails().code_is(1); new_ucmd!().args(&["%0s", "3"]).fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_ptx.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_pwd.rs
View file

@ -10,7 +10,7 @@ use crate::common::util::{TestScenario, UCommand};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

47
tests/by-util/test_readlink.rs
View file

@ -14,7 +14,7 @@ static NOT_A_DIRECTORY: &str = "The directory name is invalid.";
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -91,8 +91,7 @@ fn test_symlink_to_itself_verbose() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
at.relative_symlink_file("a", "a"); at.relative_symlink_file("a", "a");
ucmd.args(&["-ev", "a"]) ucmd.args(&["-ev", "a"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("Too many levels of symbolic links"); .stderr_contains("Too many levels of symbolic links");
} }
@ -104,8 +103,7 @@ fn test_trailing_slash_regular_file() {
scene scene
.ucmd() .ucmd()
.args(&["-ev", "./regfile/"]) .args(&["-ev", "./regfile/"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY) .stderr_contains(NOT_A_DIRECTORY)
.no_stdout(); .no_stdout();
scene scene
@ -124,8 +122,7 @@ fn test_trailing_slash_symlink_to_regular_file() {
scene scene
.ucmd() .ucmd()
.args(&["-ev", "./link/"]) .args(&["-ev", "./link/"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY) .stderr_contains(NOT_A_DIRECTORY)
.no_stdout(); .no_stdout();
scene scene
@ -136,8 +133,7 @@ fn test_trailing_slash_symlink_to_regular_file() {
scene scene
.ucmd() .ucmd()
.args(&["-e", "./link/more"]) .args(&["-e", "./link/more"])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
@ -171,8 +167,7 @@ fn test_trailing_slash_symlink_to_directory() {
scene scene
.ucmd() .ucmd()
.args(&["-ev", "./link/more"]) .args(&["-ev", "./link/more"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.no_stdout(); .no_stdout();
} }
@ -197,8 +192,7 @@ fn test_trailing_slash_symlink_to_missing() {
scene scene
.ucmd() .ucmd()
.args(&["-ev", query]) .args(&["-ev", query])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("No such file or directory") .stderr_contains("No such file or directory")
.no_stdout(); .no_stdout();
} }
@ -219,22 +213,19 @@ fn test_canonicalize_trailing_slash_regfile() {
scene scene
.ucmd() .ucmd()
.args(&["-fv", &format!("./{name}/")]) .args(&["-fv", &format!("./{name}/")])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY) .stderr_contains(NOT_A_DIRECTORY)
.no_stdout(); .no_stdout();
scene scene
.ucmd() .ucmd()
.args(&["-fv", &format!("{name}/more")]) .args(&["-fv", &format!("{name}/more")])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY) .stderr_contains(NOT_A_DIRECTORY)
.no_stdout(); .no_stdout();
scene scene
.ucmd() .ucmd()
.args(&["-fv", &format!("./{name}/more/")]) .args(&["-fv", &format!("./{name}/more/")])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY) .stderr_contains(NOT_A_DIRECTORY)
.no_stdout(); .no_stdout();
} }
@ -270,14 +261,12 @@ fn test_canonicalize_trailing_slash_subdir() {
scene scene
.ucmd() .ucmd()
.args(&["-f", &format!("{name}/more/more2")]) .args(&["-f", &format!("{name}/more/more2")])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
scene scene
.ucmd() .ucmd()
.args(&["-f", &format!("./{name}/more/more2/")]) .args(&["-f", &format!("./{name}/more/more2/")])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
} }
@ -301,14 +290,12 @@ fn test_canonicalize_trailing_slash_missing() {
scene scene
.ucmd() .ucmd()
.args(&["-f", &format!("{name}/more")]) .args(&["-f", &format!("{name}/more")])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
scene scene
.ucmd() .ucmd()
.args(&["-f", &format!("./{name}/more/")]) .args(&["-f", &format!("./{name}/more/")])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
} }
@ -330,8 +317,7 @@ fn test_canonicalize_trailing_slash_subdir_missing() {
scene scene
.ucmd() .ucmd()
.args(&["-f", query]) .args(&["-f", query])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
} }
@ -345,8 +331,7 @@ fn test_canonicalize_trailing_slash_symlink_loop() {
scene scene
.ucmd() .ucmd()
.args(&["-f", query]) .args(&["-f", query])
.fails() .fails_with_code(1)
.code_is(1)
.no_stdout(); .no_stdout();
} }
} }

14
tests/by-util/test_realpath.rs
View file

@ -277,8 +277,7 @@ fn test_relative_existing_require_directories() {
at.mkdir("dir1"); at.mkdir("dir1");
at.touch("dir1/f"); at.touch("dir1/f");
ucmd.args(&["-e", "--relative-base=.", "--relative-to=dir1/f", "."]) ucmd.args(&["-e", "--relative-base=.", "--relative-to=dir1/f", "."])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("directory"); .stderr_contains("directory");
} }
@ -384,7 +383,7 @@ fn test_realpath_trailing_slash() {
.arg("link_file") .arg("link_file")
.succeeds() .succeeds()
.stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR)); .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
scene.ucmd().arg("link_file/").fails().code_is(1); scene.ucmd().arg("link_file/").fails_with_code(1);
scene scene
.ucmd() .ucmd()
.arg("link_dir") .arg("link_dir")
@ -410,7 +409,7 @@ fn test_realpath_trailing_slash() {
.args(&["-e", "link_file"]) .args(&["-e", "link_file"])
.succeeds() .succeeds()
.stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR)); .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
scene.ucmd().args(&["-e", "link_file/"]).fails().code_is(1); scene.ucmd().args(&["-e", "link_file/"]).fails_with_code(1);
scene scene
.ucmd() .ucmd()
.args(&["-e", "link_dir"]) .args(&["-e", "link_dir"])
@ -421,12 +420,11 @@ fn test_realpath_trailing_slash() {
.args(&["-e", "link_dir/"]) .args(&["-e", "link_dir/"])
.succeeds() .succeeds()
.stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR)); .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
scene.ucmd().args(&["-e", "link_no_dir"]).fails().code_is(1); scene.ucmd().args(&["-e", "link_no_dir"]).fails_with_code(1);
scene scene
.ucmd() .ucmd()
.args(&["-e", "link_no_dir/"]) .args(&["-e", "link_no_dir/"])
.fails() .fails_with_code(1);
.code_is(1);
scene scene
.ucmd() .ucmd()
.args(&["-m", "link_file"]) .args(&["-m", "link_file"])
@ -461,5 +459,5 @@ fn test_realpath_trailing_slash() {
#[test] #[test]
fn test_realpath_empty() { fn test_realpath_empty() {
new_ucmd!().fails().code_is(1); new_ucmd!().fails_with_code(1);
} }

2
tests/by-util/test_rm.rs
View file

@ -10,7 +10,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

5
tests/by-util/test_rmdir.rs
View file

@ -26,14 +26,13 @@ const NOT_A_DIRECTORY: &str = "Not a directory";
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_no_arg() { fn test_no_arg() {
new_ucmd!() new_ucmd!()
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("error: the following required arguments were not provided:"); .stderr_contains("error: the following required arguments were not provided:");
} }

22
tests/by-util/test_runcon.rs
View file

@ -24,7 +24,7 @@ fn help() {
#[test] #[test]
fn invalid_input() { fn invalid_input() {
new_ucmd!().arg("-/").fails().code_is(125); new_ucmd!().arg("-/").fails_with_code(125);
} }
#[test] #[test]
@ -45,34 +45,34 @@ fn print() {
#[test] #[test]
fn invalid() { fn invalid() {
new_ucmd!().arg("invalid").fails().code_is(1); new_ucmd!().arg("invalid").fails_with_code(1);
let args = &[ let args = &[
"unconfined_u:unconfined_r:unconfined_t:s0", "unconfined_u:unconfined_r:unconfined_t:s0",
"inexistent-file", "inexistent-file",
]; ];
new_ucmd!().args(args).fails().code_is(1); new_ucmd!().args(args).fails_with_code(1);
let args = &["invalid", "/bin/true"]; let args = &["invalid", "/bin/true"];
new_ucmd!().args(args).fails().code_is(1); new_ucmd!().args(args).fails_with_code(1);
let args = &["--compute", "inexistent-file"]; let args = &["--compute", "inexistent-file"];
new_ucmd!().args(args).fails().code_is(1); new_ucmd!().args(args).fails_with_code(1);
let args = &["--compute", "--compute"]; let args = &["--compute", "--compute"];
new_ucmd!().args(args).fails().code_is(125); new_ucmd!().args(args).fails_with_code(125);
// clap has an issue that makes this test fail: https://github.com/clap-rs/clap/issues/1543 // clap has an issue that makes this test fail: https://github.com/clap-rs/clap/issues/1543
// TODO: Enable this code once the issue is fixed in the clap version we're using. // TODO: Enable this code once the issue is fixed in the clap version we're using.
//new_ucmd!().arg("--compute=example").fails().code_is(1); //new_ucmd!().arg("--compute=example").fails_with_code(1);
for flag in [ for flag in [
"-t", "--type", "-u", "--user", "-r", "--role", "-l", "--range", "-t", "--type", "-u", "--user", "-r", "--role", "-l", "--range",
] { ] {
new_ucmd!().arg(flag).fails().code_is(125); new_ucmd!().arg(flag).fails_with_code(125);
let args = &[flag, "example", flag, "example"]; let args = &[flag, "example", flag, "example"];
new_ucmd!().args(args).fails().code_is(125); new_ucmd!().args(args).fails_with_code(125);
} }
} }
@ -81,7 +81,7 @@ fn invalid() {
fn plain_context() { fn plain_context() {
let ctx = "unconfined_u:unconfined_r:unconfined_t:s0-s0"; let ctx = "unconfined_u:unconfined_r:unconfined_t:s0-s0";
new_ucmd!().args(&[ctx, "/bin/true"]).succeeds(); new_ucmd!().args(&[ctx, "/bin/true"]).succeeds();
new_ucmd!().args(&[ctx, "/bin/false"]).fails().code_is(1); new_ucmd!().args(&[ctx, "/bin/false"]).fails_with_code(1);
let output = new_ucmd!().args(&[ctx, "sestatus", "-v"]).succeeds(); let output = new_ucmd!().args(&[ctx, "sestatus", "-v"]).succeeds();
let r = get_sestatus_context(output.stdout()); let r = get_sestatus_context(output.stdout());
@ -105,7 +105,7 @@ fn custom_context() {
new_ucmd!().args(&["--compute", "/bin/true"]).succeeds(); new_ucmd!().args(&["--compute", "/bin/true"]).succeeds();
let args = &["--compute", "/bin/false"]; let args = &["--compute", "/bin/false"];
new_ucmd!().args(args).fails().code_is(1); new_ucmd!().args(args).fails_with_code(1);
let args = &["--type", t_ud, "/bin/true"]; let args = &["--type", t_ud, "/bin/true"];
new_ucmd!().args(args).succeeds(); new_ucmd!().args(args).succeeds();

5
tests/by-util/test_seq.rs
View file

@ -8,14 +8,13 @@ use std::process::Stdio;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_no_args() { fn test_no_args() {
new_ucmd!() new_ucmd!()
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("missing operand"); .stderr_contains("missing operand");
} }

6
tests/by-util/test_shred.rs
View file

@ -9,17 +9,17 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_invalid_remove_arg() { fn test_invalid_remove_arg() {
new_ucmd!().arg("--remove=unknown").fails().code_is(1); new_ucmd!().arg("--remove=unknown").fails_with_code(1);
} }
#[test] #[test]
fn test_ambiguous_remove_arg() { fn test_ambiguous_remove_arg() {
new_ucmd!().arg("--remove=wip").fails().code_is(1); new_ucmd!().arg("--remove=wip").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_shuf.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

45
tests/by-util/test_sort.rs
View file

@ -66,15 +66,13 @@ fn test_invalid_buffer_size() {
new_ucmd!() new_ucmd!()
.arg("-S") .arg("-S")
.arg("asd") .arg("asd")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("sort: invalid --buffer-size argument 'asd'\n"); .stderr_only("sort: invalid --buffer-size argument 'asd'\n");
new_ucmd!() new_ucmd!()
.arg("-S") .arg("-S")
.arg("100f") .arg("100f")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("sort: invalid suffix in --buffer-size argument '100f'\n"); .stderr_only("sort: invalid suffix in --buffer-size argument '100f'\n");
// TODO Percentage sizes are not yet supported beyond Linux. // TODO Percentage sizes are not yet supported beyond Linux.
@ -82,8 +80,7 @@ fn test_invalid_buffer_size() {
new_ucmd!() new_ucmd!()
.arg("-S") .arg("-S")
.arg("0x123%") .arg("0x123%")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("sort: invalid --buffer-size argument '0x123%'\n"); .stderr_only("sort: invalid --buffer-size argument '0x123%'\n");
new_ucmd!() new_ucmd!()
@ -91,8 +88,7 @@ fn test_invalid_buffer_size() {
.arg("-S") .arg("-S")
.arg("1Y") .arg("1Y")
.arg("ext_sort.txt") .arg("ext_sort.txt")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only("sort: --buffer-size argument '1Y' too large\n"); .stderr_only("sort: --buffer-size argument '1Y' too large\n");
#[cfg(target_pointer_width = "32")] #[cfg(target_pointer_width = "32")]
@ -104,8 +100,7 @@ fn test_invalid_buffer_size() {
.arg("-S") .arg("-S")
.arg(buffer_size) .arg(buffer_size)
.arg("ext_sort.txt") .arg("ext_sort.txt")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only(format!( .stderr_only(format!(
"sort: --buffer-size argument '{}' too large\n", "sort: --buffer-size argument '{}' too large\n",
buffer_size buffer_size
@ -881,8 +876,7 @@ fn test_check_unique() {
new_ucmd!() new_ucmd!()
.args(&["-c", "-u"]) .args(&["-c", "-u"])
.pipe_in("A\nA\n") .pipe_in("A\nA\n")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("sort: -:2: disorder: A\n"); .stderr_only("sort: -:2: disorder: A\n");
} }
@ -891,8 +885,7 @@ fn test_check_unique_combined() {
new_ucmd!() new_ucmd!()
.args(&["-cu"]) .args(&["-cu"])
.pipe_in("A\nA\n") .pipe_in("A\nA\n")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("sort: -:2: disorder: A\n"); .stderr_only("sort: -:2: disorder: A\n");
} }
@ -935,8 +928,7 @@ fn test_trailing_separator() {
fn test_nonexistent_file() { fn test_nonexistent_file() {
new_ucmd!() new_ucmd!()
.arg("nonexistent.txt") .arg("nonexistent.txt")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only( .stderr_only(
#[cfg(not(windows))] #[cfg(not(windows))]
"sort: cannot read: nonexistent.txt: No such file or directory\n", "sort: cannot read: nonexistent.txt: No such file or directory\n",
@ -1054,8 +1046,7 @@ fn test_batch_size_invalid() {
TestScenario::new(util_name!()) TestScenario::new(util_name!())
.ucmd() .ucmd()
.arg("--batch-size=0") .arg("--batch-size=0")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("sort: invalid --batch-size argument '0'") .stderr_contains("sort: invalid --batch-size argument '0'")
.stderr_contains("sort: minimum --batch-size argument is '2'"); .stderr_contains("sort: minimum --batch-size argument is '2'");
} }
@ -1066,8 +1057,7 @@ fn test_batch_size_too_large() {
TestScenario::new(util_name!()) TestScenario::new(util_name!())
.ucmd() .ucmd()
.arg(format!("--batch-size={large_batch_size}")) .arg(format!("--batch-size={large_batch_size}"))
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains(format!( .stderr_contains(format!(
"--batch-size argument '{large_batch_size}' too large" "--batch-size argument '{large_batch_size}' too large"
)); ));
@ -1075,8 +1065,7 @@ fn test_batch_size_too_large() {
TestScenario::new(util_name!()) TestScenario::new(util_name!())
.ucmd() .ucmd()
.arg(format!("--batch-size={large_batch_size}")) .arg(format!("--batch-size={large_batch_size}"))
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("maximum --batch-size argument with current rlimit is"); .stderr_contains("maximum --batch-size argument with current rlimit is");
} }
@ -1163,8 +1152,7 @@ fn test_verifies_out_file() {
.args(&["-o", "nonexistent_dir/nonexistent_file"]) .args(&["-o", "nonexistent_dir/nonexistent_file"])
.pipe_in(input) .pipe_in(input)
.ignore_stdin_write_error() .ignore_stdin_write_error()
.fails() .fails_with_code(2)
.code_is(2)
.stderr_only( .stderr_only(
#[cfg(not(windows))] #[cfg(not(windows))]
"sort: open failed: nonexistent_dir/nonexistent_file: No such file or directory\n", "sort: open failed: nonexistent_dir/nonexistent_file: No such file or directory\n",
@ -1184,8 +1172,7 @@ fn test_verifies_files_after_keys() {
"0", "0",
"nonexistent_dir/input_file", "nonexistent_dir/input_file",
]) ])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("failed to parse key"); .stderr_contains("failed to parse key");
} }
@ -1194,8 +1181,7 @@ fn test_verifies_files_after_keys() {
fn test_verifies_input_files() { fn test_verifies_input_files() {
new_ucmd!() new_ucmd!()
.args(&["/dev/random", "nonexistent_file"]) .args(&["/dev/random", "nonexistent_file"])
.fails() .fails_with_code(2)
.code_is(2)
.stderr_is("sort: cannot read: nonexistent_file: No such file or directory\n"); .stderr_is("sort: cannot read: nonexistent_file: No such file or directory\n");
} }
@ -1252,8 +1238,7 @@ fn test_no_error_for_version() {
fn test_wrong_args_exit_code() { fn test_wrong_args_exit_code() {
new_ucmd!() new_ucmd!()
.arg("--misspelled") .arg("--misspelled")
.fails() .fails_with_code(2)
.code_is(2)
.stderr_contains("--misspelled"); .stderr_contains("--misspelled");
} }

65
tests/by-util/test_split.rs
View file

@ -120,15 +120,14 @@ impl RandomFile {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_split_non_existing_file() { fn test_split_non_existing_file() {
new_ucmd!() new_ucmd!()
.arg("non-existing") .arg("non-existing")
.fails() .fails_with_code(1)
.code_is(1)
.stderr_is("split: cannot open 'non-existing' for reading: No such file or directory\n"); .stderr_is("split: cannot open 'non-existing' for reading: No such file or directory\n");
} }
@ -403,26 +402,22 @@ fn test_split_lines_number() {
scene scene
.ucmd() .ucmd()
.args(&["--lines", "0", "file"]) .args(&["--lines", "0", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("split: invalid number of lines: 0\n"); .stderr_only("split: invalid number of lines: 0\n");
scene scene
.ucmd() .ucmd()
.args(&["-0", "file"]) .args(&["-0", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("split: invalid number of lines: 0\n"); .stderr_only("split: invalid number of lines: 0\n");
scene scene
.ucmd() .ucmd()
.args(&["--lines", "2fb", "file"]) .args(&["--lines", "2fb", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("split: invalid number of lines: '2fb'\n"); .stderr_only("split: invalid number of lines: '2fb'\n");
scene scene
.ucmd() .ucmd()
.args(&["--lines", "file"]) .args(&["--lines", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("split: invalid number of lines: 'file'\n"); .stderr_only("split: invalid number of lines: 'file'\n");
} }
@ -476,8 +471,7 @@ fn test_split_obs_lines_within_invalid_combined_shorts() {
scene scene
.ucmd() .ucmd()
.args(&["-2fb", "file"]) .args(&["-2fb", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("error: unexpected argument '-f' found\n"); .stderr_contains("error: unexpected argument '-f' found\n");
} }
@ -545,14 +539,12 @@ fn test_split_both_lines_and_obs_lines_standalone() {
scene scene
.ucmd() .ucmd()
.args(&["-l", "2", "-2", "file"]) .args(&["-l", "2", "-2", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: cannot split in more than one way\n"); .stderr_contains("split: cannot split in more than one way\n");
scene scene
.ucmd() .ucmd()
.args(&["--lines", "2", "-2", "file"]) .args(&["--lines", "2", "-2", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: cannot split in more than one way\n"); .stderr_contains("split: cannot split in more than one way\n");
} }
@ -568,62 +560,52 @@ fn test_split_obs_lines_as_other_option_value() {
scene scene
.ucmd() .ucmd()
.args(&["--lines", "-200", "file"]) .args(&["--lines", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of lines: '-200'\n"); .stderr_contains("split: invalid number of lines: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["-l", "-200", "file"]) .args(&["-l", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of lines: '-200'\n"); .stderr_contains("split: invalid number of lines: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["-a", "-200", "file"]) .args(&["-a", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid suffix length: '-200'\n"); .stderr_contains("split: invalid suffix length: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["--suffix-length", "-d200e", "file"]) .args(&["--suffix-length", "-d200e", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid suffix length: '-d200e'\n"); .stderr_contains("split: invalid suffix length: '-d200e'\n");
scene scene
.ucmd() .ucmd()
.args(&["-C", "-200", "file"]) .args(&["-C", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of bytes: '-200'\n"); .stderr_contains("split: invalid number of bytes: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["--line-bytes", "-x200a4", "file"]) .args(&["--line-bytes", "-x200a4", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of bytes: '-x200a4'\n"); .stderr_contains("split: invalid number of bytes: '-x200a4'\n");
scene scene
.ucmd() .ucmd()
.args(&["-b", "-200", "file"]) .args(&["-b", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of bytes: '-200'\n"); .stderr_contains("split: invalid number of bytes: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["--bytes", "-200xd", "file"]) .args(&["--bytes", "-200xd", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of bytes: '-200xd'\n"); .stderr_contains("split: invalid number of bytes: '-200xd'\n");
scene scene
.ucmd() .ucmd()
.args(&["-n", "-200", "file"]) .args(&["-n", "-200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of chunks: '-200'\n"); .stderr_contains("split: invalid number of chunks: '-200'\n");
scene scene
.ucmd() .ucmd()
.args(&["--number", "-e200", "file"]) .args(&["--number", "-e200", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: invalid number of chunks: '-e200'\n"); .stderr_contains("split: invalid number of chunks: '-e200'\n");
} }
@ -677,14 +659,12 @@ fn test_split_obs_lines_within_combined_with_number() {
scene scene
.ucmd() .ucmd()
.args(&["-3dxen", "4", "file"]) .args(&["-3dxen", "4", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: cannot split in more than one way\n"); .stderr_contains("split: cannot split in more than one way\n");
scene scene
.ucmd() .ucmd()
.args(&["-dxe30n", "4", "file"]) .args(&["-dxe30n", "4", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("split: cannot split in more than one way\n"); .stderr_contains("split: cannot split in more than one way\n");
} }
@ -692,8 +672,7 @@ fn test_split_obs_lines_within_combined_with_number() {
fn test_split_invalid_bytes_size() { fn test_split_invalid_bytes_size() {
new_ucmd!() new_ucmd!()
.args(&["-b", "1024W"]) .args(&["-b", "1024W"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("split: invalid number of bytes: '1024W'\n"); .stderr_only("split: invalid number of bytes: '1024W'\n");
#[cfg(target_pointer_width = "32")] #[cfg(target_pointer_width = "32")]
{ {

11
tests/by-util/test_stat.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::{expected_result, TestScenario};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -375,8 +375,7 @@ fn test_stdin_with_fs_option() {
.arg("-f") .arg("-f")
.arg("-") .arg("-")
.set_stdin(std::process::Stdio::null()) .set_stdin(std::process::Stdio::null())
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("using '-' to denote standard input does not work in file system mode"); .stderr_contains("using '-' to denote standard input does not work in file system mode");
} }
@ -475,13 +474,11 @@ fn test_printf_invalid_directive() {
ts.ucmd() ts.ucmd()
.args(&["--printf=%9", "."]) .args(&["--printf=%9", "."])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("'%9': invalid directive"); .stderr_contains("'%9': invalid directive");
ts.ucmd() ts.ucmd()
.args(&["--printf=%9%", "."]) .args(&["--printf=%9%", "."])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("'%9%': invalid directive"); .stderr_contains("'%9%': invalid directive");
} }

17
tests/by-util/test_stdbuf.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn invalid_input() { fn invalid_input() {
new_ucmd!().arg("-/").fails().code_is(125); new_ucmd!().arg("-/").fails_with_code(125);
} }
#[test] #[test]
@ -15,8 +15,7 @@ fn test_permission() {
new_ucmd!() new_ucmd!()
.arg("-o1") .arg("-o1")
.arg(".") .arg(".")
.fails() .fails_with_code(126)
.code_is(126)
.stderr_contains("Permission denied"); .stderr_contains("Permission denied");
} }
@ -25,8 +24,7 @@ fn test_no_such() {
new_ucmd!() new_ucmd!()
.arg("-o1") .arg("-o1")
.arg("no_such") .arg("no_such")
.fails() .fails_with_code(127)
.code_is(127)
.stderr_contains("No such file or directory"); .stderr_contains("No such file or directory");
} }
@ -88,20 +86,17 @@ fn test_stdbuf_invalid_mode_fails() {
for option in &options { for option in &options {
new_ucmd!() new_ucmd!()
.args(&[*option, "1024R", "head"]) .args(&[*option, "1024R", "head"])
.fails() .fails_with_code(125)
.code_is(125)
.usage_error("invalid mode '1024R': Value too large for defined data type"); .usage_error("invalid mode '1024R': Value too large for defined data type");
new_ucmd!() new_ucmd!()
.args(&[*option, "1Y", "head"]) .args(&[*option, "1Y", "head"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains("stdbuf: invalid mode '1Y': Value too large for defined data type"); .stderr_contains("stdbuf: invalid mode '1Y': Value too large for defined data type");
#[cfg(target_pointer_width = "32")] #[cfg(target_pointer_width = "32")]
{ {
new_ucmd!() new_ucmd!()
.args(&[*option, "5GB", "head"]) .args(&[*option, "5GB", "head"])
.fails() .fails_with_code(125)
.code_is(125)
.stderr_contains( .stderr_contains(
"stdbuf: invalid mode '5GB': Value too large for defined data type", "stdbuf: invalid mode '5GB': Value too large for defined data type",
); );

2
tests/by-util/test_stty.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_sum.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_sync.rs
View file

@ -8,7 +8,7 @@ use tempfile::tempdir;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_tac.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

149
tests/by-util/test_tail.rs
View file

@ -67,7 +67,7 @@ const INVALID_UTF16: u16 = 0xD800;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -239,10 +239,9 @@ fn test_permission_denied() {
ts.ucmd() ts.ucmd()
.arg("unreadable") .arg("unreadable")
.fails() .fails_with_code(1)
.stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n") .stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n")
.no_stdout() .no_stdout();
.code_is(1);
} }
// TODO: Add similar test for windows // TODO: Add similar test for windows
@ -263,10 +262,9 @@ fn test_permission_denied_multiple() {
ts.ucmd() ts.ucmd()
.args(&["file1", "unreadable", "file2"]) .args(&["file1", "unreadable", "file2"])
.fails() .fails_with_code(1)
.stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n") .stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n")
.stdout_is("==> file1 <==\n\n==> file2 <==\n") .stdout_is("==> file1 <==\n\n==> file2 <==\n");
.code_is(1);
} }
#[test] #[test]
@ -284,10 +282,9 @@ fn test_follow_redirect_stdin_name_retry() {
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("f")).unwrap()) .set_stdin(File::open(at.plus("f")).unwrap())
.args(&args) .args(&args)
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: cannot follow '-' by name\n") .stderr_is("tail: cannot follow '-' by name\n");
.code_is(1);
args.pop(); args.pop();
} }
} }
@ -311,17 +308,15 @@ fn test_stdin_redirect_dir() {
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap()) .set_stdin(File::open(at.plus("dir")).unwrap())
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: error reading 'standard input': Is a directory\n") .stderr_is("tail: error reading 'standard input': Is a directory\n");
.code_is(1);
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap()) .set_stdin(File::open(at.plus("dir")).unwrap())
.arg("-") .arg("-")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: error reading 'standard input': Is a directory\n") .stderr_is("tail: error reading 'standard input': Is a directory\n");
.code_is(1);
} }
// On macOS path.is_dir() can be false for directories if it was a redirect, // On macOS path.is_dir() can be false for directories if it was a redirect,
@ -344,17 +339,15 @@ fn test_stdin_redirect_dir_when_target_os_is_macos() {
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap()) .set_stdin(File::open(at.plus("dir")).unwrap())
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n") .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n");
.code_is(1);
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap()) .set_stdin(File::open(at.plus("dir")).unwrap())
.arg("-") .arg("-")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n") .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n");
.code_is(1);
} }
#[test] #[test]
@ -604,10 +597,9 @@ fn test_follow_multiple_untailable() {
ucmd.arg("-f") ucmd.arg("-f")
.arg("DIR1") .arg("DIR1")
.arg("DIR2") .arg("DIR2")
.fails() .fails_with_code(1)
.stderr_is(expected_stderr) .stderr_is(expected_stderr)
.stdout_is(expected_stdout) .stdout_is(expected_stdout);
.code_is(1);
} }
#[test] #[test]
@ -625,7 +617,7 @@ fn test_follow_stdin_pipe() {
fn test_follow_invalid_pid() { fn test_follow_invalid_pid() {
new_ucmd!() new_ucmd!()
.args(&["-f", "--pid=-1234"]) .args(&["-f", "--pid=-1234"])
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: invalid PID: '-1234'\n"); .stderr_is("tail: invalid PID: '-1234'\n");
new_ucmd!() new_ucmd!()
@ -848,8 +840,7 @@ fn test_multiple_input_files_missing() {
.stderr_is( .stderr_is(
"tail: cannot open 'missing1' for reading: No such file or directory\n\ "tail: cannot open 'missing1' for reading: No such file or directory\n\
tail: cannot open 'missing2' for reading: No such file or directory\n", tail: cannot open 'missing2' for reading: No such file or directory\n",
) );
.code_is(1);
} }
#[test] #[test]
@ -987,9 +978,8 @@ fn test_sleep_interval() {
.arg("-s") .arg("-s")
.arg("1..1") .arg("1..1")
.arg(FOOBAR_TXT) .arg(FOOBAR_TXT)
.fails() .fails_with_code(1)
.stderr_contains("invalid number of seconds: '1..1'") .stderr_contains("invalid number of seconds: '1..1'");
.code_is(1);
} }
/// Test for reading all but the first NUM bytes: `tail -c +3`. /// Test for reading all but the first NUM bytes: `tail -c +3`.
@ -2556,10 +2546,9 @@ fn test_follow_inotify_only_regular() {
fn test_no_such_file() { fn test_no_such_file() {
new_ucmd!() new_ucmd!()
.arg("missing") .arg("missing")
.fails() .fails_with_code(1)
.stderr_is("tail: cannot open 'missing' for reading: No such file or directory\n") .stderr_is("tail: cannot open 'missing' for reading: No such file or directory\n")
.no_stdout() .no_stdout();
.code_is(1);
} }
#[test] #[test]
@ -3471,9 +3460,8 @@ fn test_when_follow_retry_given_redirected_stdin_from_directory_then_correct_err
ts.ucmd() ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap()) .set_stdin(File::open(at.plus("dir")).unwrap())
.args(&["-f", "--retry"]) .args(&["-f", "--retry"])
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
} }
#[test] #[test]
@ -3485,9 +3473,8 @@ fn test_when_argument_file_is_a_directory() {
let expected = "tail: error reading 'dir': Is a directory\n"; let expected = "tail: error reading 'dir': Is a directory\n";
ts.ucmd() ts.ucmd()
.arg("dir") .arg("dir")
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
} }
// TODO: make this work on windows // TODO: make this work on windows
@ -3523,9 +3510,8 @@ fn test_when_argument_file_is_a_symlink() {
let expected = "tail: error reading 'dir_link': Is a directory\n"; let expected = "tail: error reading 'dir_link': Is a directory\n";
ts.ucmd() ts.ucmd()
.arg("dir_link") .arg("dir_link")
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
} }
// TODO: make this work on windows // TODO: make this work on windows
@ -3541,9 +3527,8 @@ fn test_when_argument_file_is_a_symlink_to_directory_then_error() {
let expected = "tail: error reading 'dir_link': Is a directory\n"; let expected = "tail: error reading 'dir_link': Is a directory\n";
ts.ucmd() ts.ucmd()
.arg("dir_link") .arg("dir_link")
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
} }
// TODO: make this work on windows // TODO: make this work on windows
@ -3565,18 +3550,16 @@ fn test_when_argument_file_is_a_faulty_symlink_then_error() {
ts.ucmd() ts.ucmd()
.arg("self") .arg("self")
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
at.symlink_file("missing", "broken"); at.symlink_file("missing", "broken");
let expected = "tail: cannot open 'broken' for reading: No such file or directory"; let expected = "tail: cannot open 'broken' for reading: No such file or directory";
ts.ucmd() ts.ucmd()
.arg("broken") .arg("broken")
.fails() .fails_with_code(1)
.stderr_only(expected) .stderr_only(expected);
.code_is(1);
} }
#[test] #[test]
@ -3610,9 +3593,8 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
ts.ucmd() ts.ucmd()
.arg(socket) .arg(socket)
.fails() .fails_with_code(1)
.stderr_only(&expected_stderr) .stderr_only(&expected_stderr);
.code_is(1);
let path = "file"; let path = "file";
let mut file = at.make_file(path); let mut file = at.make_file(path);
@ -3624,7 +3606,7 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
let expected_stdout = [format!("==> {path} <=="), random_string].join("\n"); let expected_stdout = [format!("==> {path} <=="), random_string].join("\n");
ts.ucmd() ts.ucmd()
.args(&["-c", "+0", path, socket]) .args(&["-c", "+0", path, socket])
.fails() .fails_with_code(1)
.stdout_is(&expected_stdout) .stdout_is(&expected_stdout)
.stderr_is(&expected_stderr); .stderr_is(&expected_stderr);
@ -4691,73 +4673,64 @@ fn test_gnu_args_err() {
scene scene
.ucmd() .ucmd()
.arg("+cl") .arg("+cl")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n") .stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n");
.code_is(1);
// err-2 // err-2
scene scene
.ucmd() .ucmd()
.arg("-cl") .arg("-cl")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: invalid number of bytes: 'l'\n") .stderr_is("tail: invalid number of bytes: 'l'\n");
.code_is(1);
// err-3 // err-3
scene scene
.ucmd() .ucmd()
.arg("+2cz") .arg("+2cz")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n") .stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n");
.code_is(1);
// err-4 // err-4
scene scene
.ucmd() .ucmd()
.arg("-2cX") .arg("-2cX")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: option used in invalid context -- 2\n") .stderr_is("tail: option used in invalid context -- 2\n");
.code_is(1);
// err-5 // err-5
scene scene
.ucmd() .ucmd()
.arg("-c99999999999999999999") .arg("-c99999999999999999999")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: invalid number of bytes: '99999999999999999999'\n") .stderr_is("tail: invalid number of bytes: '99999999999999999999'\n");
.code_is(1);
// err-6 // err-6
scene scene
.ucmd() .ucmd()
.arg("-c --") .arg("-c --")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: invalid number of bytes: '-'\n") .stderr_is("tail: invalid number of bytes: '-'\n");
.code_is(1);
scene scene
.ucmd() .ucmd()
.arg("-5cz") .arg("-5cz")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: option used in invalid context -- 5\n") .stderr_is("tail: option used in invalid context -- 5\n");
.code_is(1);
scene scene
.ucmd() .ucmd()
.arg("-9999999999999999999b") .arg("-9999999999999999999b")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: invalid number: '-9999999999999999999b'\n") .stderr_is("tail: invalid number: '-9999999999999999999b'\n");
.code_is(1);
scene scene
.ucmd() .ucmd()
.arg("-999999999999999999999b") .arg("-999999999999999999999b")
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is( .stderr_is(
"tail: invalid number: '-999999999999999999999b': Numerical result out of range\n", "tail: invalid number: '-999999999999999999999b': Numerical result out of range\n",
) );
.code_is(1);
} }
#[test] #[test]
@ -4800,10 +4773,9 @@ fn test_obsolete_encoding_unix() {
scene scene
.ucmd() .ucmd()
.arg(invalid_utf8_arg) .arg(invalid_utf8_arg)
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: bad argument encoding: '-<2D>b'\n") .stderr_is("tail: bad argument encoding: '-<2D>b'\n");
.code_is(1);
} }
#[test] #[test]
@ -4818,10 +4790,9 @@ fn test_obsolete_encoding_windows() {
scene scene
.ucmd() .ucmd()
.arg(&invalid_utf16_arg) .arg(&invalid_utf16_arg)
.fails() .fails_with_code(1)
.no_stdout() .no_stdout()
.stderr_is("tail: bad argument encoding: '-<2D>b'\n") .stderr_is("tail: bad argument encoding: '-<2D>b'\n");
.code_is(1);
} }
#[test] #[test]

2
tests/by-util/test_tee.rs
View file

@ -17,7 +17,7 @@ use std::fmt::Write;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

19
tests/by-util/test_test.rs
View file

@ -89,7 +89,7 @@ fn test_simple_or() {
fn test_errors_miss_and_or() { fn test_errors_miss_and_or() {
new_ucmd!() new_ucmd!()
.args(&["-o", "arg"]) .args(&["-o", "arg"])
.fails() .fails_with_code(2)
.stderr_contains("'-o': unary operator expected"); .stderr_contains("'-o': unary operator expected");
new_ucmd!() new_ucmd!()
.args(&["-a", "arg"]) .args(&["-a", "arg"])
@ -101,8 +101,7 @@ fn test_errors_miss_and_or() {
fn test_negated_or() { fn test_negated_or() {
new_ucmd!() new_ucmd!()
.args(&["!", "foo", "-o", "bar"]) .args(&["!", "foo", "-o", "bar"])
.run() .fails_with_code(1);
.code_is(1);
new_ucmd!().args(&["foo", "-o", "!", "bar"]).succeeds(); new_ucmd!().args(&["foo", "-o", "!", "bar"]).succeeds();
new_ucmd!() new_ucmd!()
.args(&["!", "foo", "-o", "!", "bar"]) .args(&["!", "foo", "-o", "!", "bar"])
@ -348,7 +347,7 @@ fn test_non_existing_files() {
let result = scenario let result = scenario
.ucmd() .ucmd()
.args(&["newer_file", "-nt", "regular_file"]) .args(&["newer_file", "-nt", "regular_file"])
.fails(); .fails_with_code(1);
assert!(result.stderr().is_empty()); assert!(result.stderr().is_empty());
} }
@ -1006,25 +1005,21 @@ fn test_string_lt_gt_operator() {
new_ucmd!().args(&[left, "<", right]).succeeds().no_output(); new_ucmd!().args(&[left, "<", right]).succeeds().no_output();
new_ucmd!() new_ucmd!()
.args(&[right, "<", left]) .args(&[right, "<", left])
.fails() .fails_with_code(1)
.code_is(1)
.no_output(); .no_output();
new_ucmd!().args(&[right, ">", left]).succeeds().no_output(); new_ucmd!().args(&[right, ">", left]).succeeds().no_output();
new_ucmd!() new_ucmd!()
.args(&[left, ">", right]) .args(&[left, ">", right])
.fails() .fails_with_code(1)
.code_is(1)
.no_output(); .no_output();
} }
new_ucmd!() new_ucmd!()
.args(&["", "<", ""]) .args(&["", "<", ""])
.fails() .fails_with_code(1)
.code_is(1)
.no_output(); .no_output();
new_ucmd!() new_ucmd!()
.args(&["", ">", ""]) .args(&["", ">", ""])
.fails() .fails_with_code(1)
.code_is(1)
.no_output(); .no_output();
} }

14
tests/by-util/test_timeout.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(125); new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
} }
// FIXME: this depends on the system having true and false in PATH // FIXME: this depends on the system having true and false in PATH
@ -24,8 +24,7 @@ fn test_subcommand_return_code() {
fn test_invalid_time_interval() { fn test_invalid_time_interval() {
new_ucmd!() new_ucmd!()
.args(&["xyz", "sleep", "0"]) .args(&["xyz", "sleep", "0"])
.fails() .fails_with_code(125)
.code_is(125)
.usage_error("invalid time interval 'xyz'"); .usage_error("invalid time interval 'xyz'");
} }
@ -33,8 +32,7 @@ fn test_invalid_time_interval() {
fn test_invalid_kill_after() { fn test_invalid_kill_after() {
new_ucmd!() new_ucmd!()
.args(&["-k", "xyz", "1", "sleep", "0"]) .args(&["-k", "xyz", "1", "sleep", "0"])
.fails() .fails_with_code(125)
.code_is(125)
.usage_error("invalid time interval 'xyz'"); .usage_error("invalid time interval 'xyz'");
} }
@ -85,8 +83,7 @@ fn test_foreground() {
for arg in ["-f", "--foreground"] { for arg in ["-f", "--foreground"] {
new_ucmd!() new_ucmd!()
.args(&[arg, ".1", "sleep", "10"]) .args(&[arg, ".1", "sleep", "10"])
.fails() .fails_with_code(124)
.code_is(124)
.no_output(); .no_output();
} }
} }
@ -173,8 +170,7 @@ fn test_kill_subprocess() {
"-c", "-c",
"trap 'echo inside_trap' TERM; sleep 30", "trap 'echo inside_trap' TERM; sleep 30",
]) ])
.fails() .fails_with_code(124)
.code_is(124)
.stdout_contains("inside_trap") .stdout_contains("inside_trap")
.stderr_contains("Terminated"); .stderr_contains("Terminated");
} }

8
tests/by-util/test_touch.rs
View file

@ -42,7 +42,7 @@ fn str_to_filetime(format: &str, s: &str) -> FileTime {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
@ -806,7 +806,7 @@ fn test_touch_leap_second() {
fn test_touch_trailing_slash_no_create() { fn test_touch_trailing_slash_no_create() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
at.touch("file"); at.touch("file");
ucmd.args(&["-c", "file/"]).fails().code_is(1); ucmd.args(&["-c", "file/"]).fails_with_code(1);
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["-c", "no-file/"]).succeeds(); ucmd.args(&["-c", "no-file/"]).succeeds();
@ -822,7 +822,7 @@ fn test_touch_trailing_slash_no_create() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
at.relative_symlink_file("loop", "loop"); at.relative_symlink_file("loop", "loop");
ucmd.args(&["-c", "loop/"]).fails().code_is(1); ucmd.args(&["-c", "loop/"]).fails_with_code(1);
assert!(!at.file_exists("loop")); assert!(!at.file_exists("loop"));
#[cfg(not(target_os = "macos"))] #[cfg(not(target_os = "macos"))]
@ -831,7 +831,7 @@ fn test_touch_trailing_slash_no_create() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
at.touch("file2"); at.touch("file2");
at.relative_symlink_file("file2", "link1"); at.relative_symlink_file("file2", "link1");
ucmd.args(&["-c", "link1/"]).fails().code_is(1); ucmd.args(&["-c", "link1/"]).fails_with_code(1);
assert!(at.file_exists("file2")); assert!(at.file_exists("file2"));
assert!(at.symlink_exists("link1")); assert!(at.symlink_exists("link1"));
} }

8
tests/by-util/test_tr.rs
View file

@ -10,23 +10,21 @@ use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_invalid_input() { fn test_invalid_input() {
new_ucmd!() new_ucmd!()
.args(&["1", "1", "<", "."]) .args(&["1", "1", "<", "."])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("tr: extra operand '<'"); .stderr_contains("tr: extra operand '<'");
#[cfg(unix)] #[cfg(unix)]
new_ucmd!() new_ucmd!()
.args(&["1", "1"]) .args(&["1", "1"])
// will test "tr 1 1 < ." // will test "tr 1 1 < ."
.set_stdin(std::process::Stdio::from(std::fs::File::open(".").unwrap())) .set_stdin(std::process::Stdio::from(std::fs::File::open(".").unwrap()))
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("tr: read error: Is a directory"); .stderr_contains("tr: read error: Is a directory");
} }

12
tests/by-util/test_truncate.rs
View file

@ -189,8 +189,7 @@ fn test_error_filename_only() {
// truncate: you must specify either '--size' or '--reference' // truncate: you must specify either '--size' or '--reference'
new_ucmd!() new_ucmd!()
.args(&["file"]) .args(&["file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_contains("error: the following required arguments were not provided:"); .stderr_contains("error: the following required arguments were not provided:");
} }
@ -199,8 +198,7 @@ fn test_invalid_option() {
// truncate: cli parsing error returns 1 // truncate: cli parsing error returns 1
new_ucmd!() new_ucmd!()
.args(&["--this-arg-does-not-exist"]) .args(&["--this-arg-does-not-exist"])
.fails() .fails_with_code(1);
.code_is(1);
} }
#[test] #[test]
@ -242,13 +240,11 @@ fn test_truncate_bytes_size() {
.succeeds(); .succeeds();
new_ucmd!() new_ucmd!()
.args(&["--size", "1024R", "file"]) .args(&["--size", "1024R", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("truncate: Invalid number: '1024R': Value too large for defined data type\n"); .stderr_only("truncate: Invalid number: '1024R': Value too large for defined data type\n");
new_ucmd!() new_ucmd!()
.args(&["--size", "1Y", "file"]) .args(&["--size", "1Y", "file"])
.fails() .fails_with_code(1)
.code_is(1)
.stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type\n"); .stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type\n");
} }

8
tests/by-util/test_tsort.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]
fn test_sort_call_graph() { fn test_sort_call_graph() {
@ -89,8 +89,7 @@ fn test_cycle() {
// The graph looks like: a --> b <==> c --> d // The graph looks like: a --> b <==> c --> d
new_ucmd!() new_ucmd!()
.pipe_in("a b b c c d c b") .pipe_in("a b b c c d c b")
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("a\nc\nd\nb\n") .stdout_is("a\nc\nd\nb\n")
.stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\n"); .stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\n");
} }
@ -106,8 +105,7 @@ fn test_two_cycles() {
// //
new_ucmd!() new_ucmd!()
.pipe_in("a b b c c b b d d b") .pipe_in("a b b c c b b d d b")
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("a\nc\nd\nb\n") .stdout_is("a\nc\nd\nb\n")
.stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\ntsort: -: input contains a loop:\ntsort: b\ntsort: d\n"); .stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\ntsort: -: input contains a loop:\ntsort: b\ntsort: d\n");
} }

8
tests/by-util/test_tty.rs
View file

@ -11,8 +11,7 @@ use crate::common::util::TestScenario;
fn test_dev_null() { fn test_dev_null() {
new_ucmd!() new_ucmd!()
.set_stdin(File::open("/dev/null").unwrap()) .set_stdin(File::open("/dev/null").unwrap())
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is("not a tty\n"); .stdout_is("not a tty\n");
} }
@ -22,8 +21,7 @@ fn test_dev_null_silent() {
new_ucmd!() new_ucmd!()
.args(&["-s"]) .args(&["-s"])
.set_stdin(File::open("/dev/null").unwrap()) .set_stdin(File::open("/dev/null").unwrap())
.fails() .fails_with_code(1)
.code_is(1)
.stdout_is(""); .stdout_is("");
} }
@ -57,7 +55,7 @@ fn test_close_stdin_silent_alias() {
#[test] #[test]
fn test_wrong_argument() { fn test_wrong_argument() {
new_ucmd!().args(&["a"]).fails().code_is(2); new_ucmd!().args(&["a"]).fails_with_code(2);
} }
#[test] #[test]

2
tests/by-util/test_uname.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_unexpand.rs
View file

@ -7,7 +7,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_uniq.rs
View file

@ -15,7 +15,7 @@ static SORTED_ZERO_TERMINATED: &str = "sorted-zero-terminated.txt";
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_unlink.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_uptime.rs
View file

@ -22,7 +22,7 @@ use std::{io::Write, path::PathBuf};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_users.rs
View file

@ -6,7 +6,7 @@ use crate::common::util::TestScenario;
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_wc.rs
View file

@ -8,7 +8,7 @@ use crate::common::util::{vec_of_size, TestScenario};
// spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars // spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_who.rs
View file

@ -9,7 +9,7 @@ use crate::common::util::{expected_result, TestScenario};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[cfg(unix)] #[cfg(unix)]

2
tests/by-util/test_whoami.rs
View file

@ -9,7 +9,7 @@ use crate::common::util::{is_ci, whoami, TestScenario};
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]

2
tests/by-util/test_yes.rs
View file

@ -35,7 +35,7 @@ fn run(args: &[impl AsRef<OsStr>], expected: &[u8]) {
#[test] #[test]
fn test_invalid_arg() { fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1); new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
} }
#[test] #[test]