Merge branch 'master' into pr

tests/by-util/test_arch.rs

@@ -2,17 +2,13 @@ use crate::common::util::*;
 
 #[test]
 fn test_arch() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.run();
-    assert!(result.success);
+    new_ucmd!().succeeds();
 }
 
 #[test]
 fn test_arch_help() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("--help").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("architecture name"));
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .stdout_contains("architecture name");
 }

tests/by-util/test_base32.rs

@@ -15,6 +15,21 @@ fn test_encode() {
         .pipe_in(input)
         .succeeds()
         .stdout_only("JBSWY3DPFQQFO33SNRSCC===\n");
+
+    // Using '-' as our file
+    new_ucmd!()
+        .arg("-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("JBSWY3DPFQQFO33SNRSCC===\n");
+}
+
+#[test]
+fn test_base32_encode_file() {
+    new_ucmd!()
+        .arg("input-simple.txt")
+        .succeeds()
+        .stdout_only("JBSWY3DPFQQFO33SNRSCCCQ=\n");
 }
 
 #[test]
@@ -71,8 +86,7 @@ fn test_wrap() {
 fn test_wrap_no_arg() {
     for wrap_param in vec!["-w", "--wrap"] {
         new_ucmd!().arg(wrap_param).fails().stderr_only(format!(
-            "base32: error: Argument to option '{}' missing\n",
-            if wrap_param == "-w" { "w" } else { "wrap" }
+            "error: The argument '--wrap <wrap>\' requires a value but none was supplied\n\nUSAGE:\n    base32 [OPTION]... [FILE]\n\nFor more information try --help"
         ));
     }
 }
@@ -84,6 +98,24 @@ fn test_wrap_bad_arg() {
             .arg(wrap_param)
             .arg("b")
             .fails()
-            .stderr_only("base32: error: invalid wrap size: ‘b’: invalid digit found in string\n");
+            .stderr_only("base32: Invalid wrap size: ‘b’: invalid digit found in string\n");
     }
 }
+
+#[test]
+fn test_base32_extra_operand() {
+    // Expect a failure when multiple files are specified.
+    new_ucmd!()
+        .arg("a.txt")
+        .arg("a.txt")
+        .fails()
+        .stderr_only("base32: extra operand ‘a.txt’");
+}
+
+#[test]
+fn test_base32_file_not_found() {
+    new_ucmd!()
+        .arg("a.txt")
+        .fails()
+        .stderr_only("base32: a.txt: No such file or directory");
+}

tests/by-util/test_base64.rs

@@ -7,6 +7,21 @@ fn test_encode() {
         .pipe_in(input)
         .succeeds()
         .stdout_only("aGVsbG8sIHdvcmxkIQ==\n");
+
+    // Using '-' as our file
+    new_ucmd!()
+        .arg("-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("aGVsbG8sIHdvcmxkIQ==\n");
+}
+
+#[test]
+fn test_base64_encode_file() {
+    new_ucmd!()
+        .arg("input-simple.txt")
+        .succeeds()
+        .stdout_only("SGVsbG8sIFdvcmxkIQo=\n");
 }
 
 #[test]
@@ -60,10 +75,9 @@ fn test_wrap() {
 #[test]
 fn test_wrap_no_arg() {
     for wrap_param in vec!["-w", "--wrap"] {
-        new_ucmd!().arg(wrap_param).fails().stderr_only(format!(
-            "base64: error: Argument to option '{}' missing\n",
-            if wrap_param == "-w" { "w" } else { "wrap" }
-        ));
+        new_ucmd!().arg(wrap_param).fails().stderr_contains(
+            &"The argument '--wrap <wrap>' requires a value but none was supplied",
+        );
     }
 }
 
@@ -74,6 +88,24 @@ fn test_wrap_bad_arg() {
             .arg(wrap_param)
             .arg("b")
             .fails()
-            .stderr_only("base64: error: invalid wrap size: ‘b’: invalid digit found in string\n");
+            .stderr_only("base64: Invalid wrap size: ‘b’: invalid digit found in string\n");
     }
 }
+
+#[test]
+fn test_base64_extra_operand() {
+    // Expect a failure when multiple files are specified.
+    new_ucmd!()
+        .arg("a.txt")
+        .arg("a.txt")
+        .fails()
+        .stderr_only("base64: extra operand ‘a.txt’");
+}
+
+#[test]
+fn test_base64_file_not_found() {
+    new_ucmd!()
+        .arg("a.txt")
+        .fails()
+        .stderr_only("base64: a.txt: No such file or directory");
+}

tests/by-util/test_basename.rs

@@ -1,4 +1,29 @@
 use crate::common::util::*;
+#[cfg(any(unix, target_os = "redox"))]
+use std::ffi::OsStr;
+
+#[test]
+fn test_help() {
+    for help_flg in vec!["-h", "--help"] {
+        new_ucmd!()
+            .arg(&help_flg)
+            .succeeds()
+            .no_stderr()
+            .stdout_contains("USAGE:");
+    }
+}
+
+#[test]
+fn test_version() {
+    for version_flg in vec!["-V", "--version"] {
+        assert!(new_ucmd!()
+            .arg(&version_flg)
+            .succeeds()
+            .no_stderr()
+            .stdout_str()
+            .starts_with("basename"));
+    }
+}
 
 #[test]
 fn test_directory() {
@@ -66,7 +91,7 @@ fn test_zero_param() {
 }
 
 fn expect_error(input: Vec<&str>) {
-    assert!(new_ucmd!().args(&input).fails().no_stdout().stderr.len() > 0);
+    assert!(new_ucmd!().args(&input).fails().no_stdout().stderr().len() > 0);
 }
 
 #[test]
@@ -80,7 +105,38 @@ fn test_no_args() {
     expect_error(vec![]);
 }
 
+#[test]
+fn test_no_args_output() {
+    new_ucmd!()
+        .fails()
+        .stderr_is("basename: missing operand\nTry 'basename --help' for more information.");
+}
+
 #[test]
 fn test_too_many_args() {
     expect_error(vec!["a", "b", "c"]);
 }
+
+#[test]
+fn test_too_many_args_output() {
+    new_ucmd!()
+        .args(&["a", "b", "c"])
+        .fails()
+        .stderr_is("basename: extra operand 'c'\nTry 'basename --help' for more information.");
+}
+
+#[cfg(any(unix, target_os = "redox"))]
+fn test_invalid_utf8_args(os_str: &OsStr) {
+    let test_vec = vec![os_str.to_os_string()];
+    new_ucmd!().args(&test_vec).succeeds().stdout_is("fo<EFBFBD>o\n");
+}
+
+#[cfg(any(unix, target_os = "redox"))]
+#[test]
+fn invalid_utf8_args_unix() {
+    use std::os::unix::ffi::OsStrExt;
+
+    let source = [0x66, 0x6f, 0x80, 0x6f];
+    let os_str = OsStr::from_bytes(&source[..]);
+    test_invalid_utf8_args(os_str);
+}

tests/by-util/test_cat.rs

@@ -1,7 +1,8 @@
-#[cfg(unix)]
-extern crate unix_socket;
-
 use crate::common::util::*;
+#[cfg(unix)]
+use std::fs::OpenOptions;
+#[cfg(unix)]
+use std::io::Read;
 
 #[test]
 fn test_output_simple() {
@@ -11,6 +12,198 @@ fn test_output_simple() {
         .stdout_only("abcde\nfghij\nklmno\npqrst\nuvwxyz\n");
 }
 
+#[test]
+fn test_no_options() {
+    for fixture in &["empty.txt", "alpha.txt", "nonewline.txt"] {
+        // Give fixture through command line file argument
+        new_ucmd!()
+            .args(&[fixture])
+            .succeeds()
+            .stdout_is_fixture(fixture);
+        // Give fixture through stdin
+        new_ucmd!()
+            .pipe_in_fixture(fixture)
+            .succeeds()
+            .stdout_is_fixture(fixture);
+    }
+}
+
+#[test]
+#[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "android"))]
+fn test_no_options_big_input() {
+    for &n in &[
+        0,
+        1,
+        42,
+        16 * 1024 - 7,
+        16 * 1024 - 1,
+        16 * 1024,
+        16 * 1024 + 1,
+        16 * 1024 + 3,
+        32 * 1024,
+        64 * 1024,
+        80 * 1024,
+        96 * 1024,
+        112 * 1024,
+        128 * 1024,
+    ] {
+        let data = vec_of_size(n);
+        let data2 = data.clone();
+        assert_eq!(data.len(), data2.len());
+        new_ucmd!().pipe_in(data).succeeds().stdout_is_bytes(&data2);
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_fifo_symlink() {
+    use std::io::Write;
+    use std::thread;
+
+    let s = TestScenario::new(util_name!());
+    s.fixtures.mkdir("dir");
+    s.fixtures.mkfifo("dir/pipe");
+    assert!(s.fixtures.is_fifo("dir/pipe"));
+
+    // Make cat read the pipe through a symlink
+    s.fixtures.symlink_file("dir/pipe", "sympipe");
+    let proc = s.ucmd().args(&["sympipe"]).run_no_wait();
+
+    let data = vec_of_size(128 * 1024);
+    let data2 = data.clone();
+
+    let pipe_path = s.fixtures.plus("dir/pipe");
+    let thread = thread::spawn(move || {
+        let mut pipe = OpenOptions::new()
+            .write(true)
+            .create(false)
+            .open(pipe_path)
+            .unwrap();
+        pipe.write_all(&data).unwrap();
+    });
+
+    let output = proc.wait_with_output().unwrap();
+    assert_eq!(&output.stdout, &data2);
+    thread.join().unwrap();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_piped_to_regular_file() {
+    use std::fs::read_to_string;
+
+    for &append in &[true, false] {
+        let s = TestScenario::new(util_name!());
+        let file_path = s.fixtures.plus("file.txt");
+
+        {
+            let file = OpenOptions::new()
+                .create_new(true)
+                .write(true)
+                .append(append)
+                .open(&file_path)
+                .unwrap();
+
+            s.ucmd()
+                .set_stdout(file)
+                .pipe_in_fixture("alpha.txt")
+                .succeeds();
+        }
+        let contents = read_to_string(&file_path).unwrap();
+        assert_eq!(contents, "abcde\nfghij\nklmno\npqrst\nuvwxyz\n");
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_piped_to_dev_null() {
+    for &append in &[true, false] {
+        let s = TestScenario::new(util_name!());
+        {
+            let dev_null = OpenOptions::new()
+                .write(true)
+                .append(append)
+                .open("/dev/null")
+                .unwrap();
+
+            s.ucmd()
+                .set_stdout(dev_null)
+                .pipe_in_fixture("alpha.txt")
+                .succeeds();
+        }
+    }
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_piped_to_dev_full() {
+    for &append in &[true, false] {
+        let s = TestScenario::new(util_name!());
+        {
+            let dev_full = OpenOptions::new()
+                .write(true)
+                .append(append)
+                .open("/dev/full")
+                .unwrap();
+
+            s.ucmd()
+                .set_stdout(dev_full)
+                .pipe_in_fixture("alpha.txt")
+                .fails()
+                .stderr_contains(&"No space left on device".to_owned());
+        }
+    }
+}
+
+#[test]
+fn test_directory() {
+    let s = TestScenario::new(util_name!());
+    s.fixtures.mkdir("test_directory");
+    s.ucmd()
+        .args(&["test_directory"])
+        .fails()
+        .stderr_is("cat: test_directory: Is a directory");
+}
+
+#[test]
+fn test_directory_and_file() {
+    let s = TestScenario::new(util_name!());
+    s.fixtures.mkdir("test_directory2");
+    for fixture in &["empty.txt", "alpha.txt", "nonewline.txt"] {
+        s.ucmd()
+            .args(&["test_directory2", fixture])
+            .fails()
+            .stderr_is("cat: test_directory2: Is a directory")
+            .stdout_is_fixture(fixture);
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_three_directories_and_file_and_stdin() {
+    let s = TestScenario::new(util_name!());
+    s.fixtures.mkdir("test_directory3");
+    s.fixtures.mkdir("test_directory3/test_directory4");
+    s.fixtures.mkdir("test_directory3/test_directory5");
+    s.ucmd()
+        .args(&[
+            "test_directory3/test_directory4",
+            "alpha.txt",
+            "-",
+            "filewhichdoesnotexist.txt",
+            "nonewline.txt",
+            "test_directory3/test_directory5",
+            "test_directory3/../test_directory3/test_directory5",
+            "test_directory3",
+        ])
+        .pipe_in("stdout bytes")
+        .fails()
+        .stderr_is_fixture("three_directories_and_file_and_stdin.stderr.expected")
+        .stdout_is(
+            "abcde\nfghij\nklmno\npqrst\nuvwxyz\nstdout bytestext without a trailing newline",
+        );
+}
+
 #[test]
 fn test_output_multi_files_print_all_chars() {
     new_ucmd!()
@@ -149,29 +342,93 @@ fn test_squeeze_blank_before_numbering() {
     }
 }
 
+/// This tests reading from Unix character devices
 #[test]
-#[cfg(foo)]
-fn test_domain_socket() {
-    use self::tempdir::TempDir;
-    use self::unix_socket::UnixListener;
-    use std::io::prelude::*;
-    use std::thread;
+#[cfg(unix)]
+fn test_dev_random() {
+    let mut buf = [0; 2048];
+    #[cfg(target_os = "linux")]
+    const DEV_RANDOM: &str = "/dev/urandom";
 
-    let dir = TempDir::new("unix_socket").expect("failed to create dir");
+    #[cfg(not(target_os = "linux"))]
+    const DEV_RANDOM: &str = "/dev/random";
+
+    let mut proc = new_ucmd!().args(&[DEV_RANDOM]).run_no_wait();
+    let mut proc_stdout = proc.stdout.take().unwrap();
+    proc_stdout.read_exact(&mut buf).unwrap();
+
+    let num_zeroes = buf.iter().fold(0, |mut acc, &n| {
+        if n == 0 {
+            acc += 1;
+        }
+        acc
+    });
+    // The probability of more than 512 zero bytes is essentially zero if the
+    // output is truly random.
+    assert!(num_zeroes < 512);
+    proc.kill().unwrap();
+}
+
+/// Reading from /dev/full should return an infinite amount of zero bytes.
+/// Wikipedia says there is support on Linux, FreeBSD, and NetBSD.
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_dev_full() {
+    let mut buf = [0; 2048];
+    let mut proc = new_ucmd!().args(&["/dev/full"]).run_no_wait();
+    let mut proc_stdout = proc.stdout.take().unwrap();
+    let expected = [0; 2048];
+    proc_stdout.read_exact(&mut buf).unwrap();
+    assert_eq!(&buf[..], &expected[..]);
+    proc.kill().unwrap();
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_dev_full_show_all() {
+    let mut buf = [0; 2048];
+    let mut proc = new_ucmd!().args(&["-A", "/dev/full"]).run_no_wait();
+    let mut proc_stdout = proc.stdout.take().unwrap();
+    proc_stdout.read_exact(&mut buf).unwrap();
+
+    let expected: Vec<u8> = (0..buf.len())
+        .map(|n| if n & 1 == 0 { b'^' } else { b'@' })
+        .collect();
+
+    assert_eq!(&buf[..], &expected[..]);
+    proc.kill().unwrap();
+}
+
+#[test]
+#[cfg(unix)]
+#[ignore]
+fn test_domain_socket() {
+    use std::io::prelude::*;
+    use std::sync::{Arc, Barrier};
+    use std::thread;
+    use unix_socket::UnixListener;
+
+    let dir = tempfile::Builder::new().prefix("unix_socket").tempdir().expect("failed to create dir");
     let socket_path = dir.path().join("sock");
     let listener = UnixListener::bind(&socket_path).expect("failed to create socket");
 
+    // use a barrier to ensure we don't run cat before the listener is setup
+    let barrier = Arc::new(Barrier::new(2));
+    let barrier2 = Arc::clone(&barrier);
+
     let thread = thread::spawn(move || {
         let mut stream = listener.accept().expect("failed to accept connection").0;
+        barrier2.wait();
         stream
             .write_all(b"a\tb")
             .expect("failed to write test data");
     });
 
-    new_ucmd!()
-        .args(&[socket_path])
-        .succeeds()
-        .stdout_only("a\tb");
+    let child = new_ucmd!().args(&[socket_path]).run_no_wait();
+    barrier.wait();
+    let stdout = &child.wait_with_output().unwrap().stdout.clone();
+    let output = String::from_utf8_lossy(&stdout);
+    assert_eq!("a\tb", output);
 
     thread.join().unwrap();
 }

tests/by-util/test_chgrp.rs

@@ -104,7 +104,7 @@ fn test_reference() {
     // skip for root or MS-WSL
     // * MS-WSL is bugged (as of 2019-12-25), allowing non-root accounts su-level privileges for `chgrp`
     // * for MS-WSL, succeeds and stdout == 'group of /etc retained as root'
-    if !(get_effective_gid() == 0 || is_wsl()) {
+    if !(get_effective_gid() == 0 || uucore::os::is_wsl_1()) {
         new_ucmd!()
             .arg("-v")
             .arg("--reference=/etc/passwd")
@@ -149,7 +149,7 @@ fn test_big_h() {
                 .arg("bin")
                 .arg("/proc/self/fd")
                 .fails()
-                .stderr
+                .stderr_str()
                 .lines()
                 .fold(0, |acc, _| acc + 1)
                 > 1

tests/by-util/test_chmod.rs

@@ -47,8 +47,8 @@ fn run_single_test(test: &TestCase, at: AtPath, mut ucmd: UCommand) {
         ucmd.arg(arg);
     }
     let r = ucmd.run();
-    if !r.success {
-        println!("{}", r.stderr);
+    if !r.succeeded() {
+        println!("{}", r.stderr_str());
         panic!("{:?}: failed", ucmd.raw);
     }
 
@@ -282,6 +282,26 @@ fn test_chmod_reference_file() {
     run_single_test(&tests[0], at, ucmd);
 }
 
+#[test]
+fn test_permission_denied() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("d/");
+    at.mkdir("d/no-x");
+    at.mkdir("d/no-x/y");
+
+    scene.ucmd().arg("u=rw").arg("d/no-x").succeeds();
+
+    scene
+        .ucmd()
+        .arg("-R")
+        .arg("o=r")
+        .arg("d")
+        .fails()
+        .stderr_is("chmod: 'd/no-x/y': Permission denied");
+}
+
 #[test]
 fn test_chmod_recursive() {
     let _guard = UMASK_MUTEX.lock();
@@ -297,13 +317,14 @@ fn test_chmod_recursive() {
     mkfile(&at.plus_as_string("a/b/c/c"), 0o100444);
     mkfile(&at.plus_as_string("z/y"), 0o100444);
 
-    let result = ucmd
-        .arg("-R")
+    ucmd.arg("-R")
         .arg("--verbose")
         .arg("-r,a+w")
         .arg("a")
         .arg("z")
-        .succeeds();
+        .succeeds()
+        .stderr_contains(&"to 333 (-wx-wx-wx)")
+        .stderr_contains(&"to 222 (-w--w--w-)");
 
     assert_eq!(at.metadata("z/y").permissions().mode(), 0o100222);
     assert_eq!(at.metadata("a/a").permissions().mode(), 0o100222);
@@ -312,8 +333,6 @@ fn test_chmod_recursive() {
     println!("mode {:o}", at.metadata("a").permissions().mode());
     assert_eq!(at.metadata("a").permissions().mode(), 0o40333);
     assert_eq!(at.metadata("z").permissions().mode(), 0o40333);
-    assert!(result.stderr.contains("to 333 (-wx-wx-wx)"));
-    assert!(result.stderr.contains("to 222 (-w--w--w-)"));
 
     unsafe {
         umask(original_umask);
@@ -322,30 +341,24 @@ fn test_chmod_recursive() {
 
 #[test]
 fn test_chmod_non_existing_file() {
-    let (_at, mut ucmd) = at_and_ucmd!();
-    let result = ucmd
+    new_ucmd!()
         .arg("-R")
         .arg("--verbose")
         .arg("-r,a+w")
         .arg("dont-exist")
-        .fails();
-    assert!(result
-        .stderr
-        .contains("cannot access 'dont-exist': No such file or directory"));
+        .fails()
+        .stderr_contains(&"cannot access 'dont-exist': No such file or directory");
 }
 
 #[test]
 fn test_chmod_preserve_root() {
-    let (_at, mut ucmd) = at_and_ucmd!();
-    let result = ucmd
+    new_ucmd!()
         .arg("-R")
         .arg("--preserve-root")
         .arg("755")
         .arg("/")
-        .fails();
-    assert!(result
-        .stderr
-        .contains("chmod: error: it is dangerous to operate recursively on '/'"));
+        .fails()
+        .stderr_contains(&"chmod: it is dangerous to operate recursively on '/'");
 }
 
 #[test]
@@ -362,33 +375,29 @@ fn test_chmod_symlink_non_existing_file() {
     let expected_stderr = &format!("cannot operate on dangling symlink '{}'", test_symlink);
 
     at.symlink_file(non_existing, test_symlink);
-    let mut result;
 
     // this cannot succeed since the symbolic link dangles
-    result = scene.ucmd().arg("755").arg("-v").arg(test_symlink).fails();
-
-    println!("stdout = {:?}", result.stdout);
-    println!("stderr = {:?}", result.stderr);
-
-    assert!(result.stdout.contains(expected_stdout));
-    assert!(result.stderr.contains(expected_stderr));
-    assert_eq!(result.code, Some(1));
+    scene
+        .ucmd()
+        .arg("755")
+        .arg("-v")
+        .arg(test_symlink)
+        .fails()
+        .code_is(1)
+        .stdout_contains(expected_stdout)
+        .stderr_contains(expected_stderr);
 
     // this should be the same than with just '-v' but without stderr
-    result = scene
+    scene
         .ucmd()
         .arg("755")
         .arg("-v")
         .arg("-f")
         .arg(test_symlink)
-        .fails();
-
-    println!("stdout = {:?}", result.stdout);
-    println!("stderr = {:?}", result.stderr);
-
-    assert!(result.stdout.contains(expected_stdout));
-    assert!(result.stderr.is_empty());
-    assert_eq!(result.code, Some(1));
+        .run()
+        .code_is(1)
+        .no_stderr()
+        .stdout_contains(expected_stdout);
 }
 
 #[test]
@@ -405,18 +414,16 @@ fn test_chmod_symlink_non_existing_file_recursive() {
         non_existing,
         &format!("{}/{}", test_directory, test_symlink),
     );
-    let mut result;
 
     // this should succeed
-    result = scene
+    scene
         .ucmd()
         .arg("-R")
         .arg("755")
         .arg(test_directory)
-        .succeeds();
-    assert_eq!(result.code, Some(0));
-    assert!(result.stdout.is_empty());
-    assert!(result.stderr.is_empty());
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
 
     let expected_stdout = &format!(
         "mode of '{}' retained as 0755 (rwxr-xr-x)\nneither symbolic link '{}/{}' nor referent has been changed",
@@ -424,37 +431,27 @@ fn test_chmod_symlink_non_existing_file_recursive() {
     );
 
     // '-v': this should succeed without stderr
-    result = scene
+    scene
         .ucmd()
         .arg("-R")
         .arg("-v")
         .arg("755")
         .arg(test_directory)
-        .succeeds();
-
-    println!("stdout = {:?}", result.stdout);
-    println!("stderr = {:?}", result.stderr);
-
-    assert!(result.stdout.contains(expected_stdout));
-    assert!(result.stderr.is_empty());
-    assert_eq!(result.code, Some(0));
+        .succeeds()
+        .stdout_contains(expected_stdout)
+        .no_stderr();
 
     // '-vf': this should be the same than with just '-v'
-    result = scene
+    scene
         .ucmd()
         .arg("-R")
         .arg("-v")
         .arg("-f")
         .arg("755")
         .arg(test_directory)
-        .succeeds();
-
-    println!("stdout = {:?}", result.stdout);
-    println!("stderr = {:?}", result.stderr);
-
-    assert!(result.stdout.contains(expected_stdout));
-    assert!(result.stderr.is_empty());
-    assert_eq!(result.code, Some(0));
+        .succeeds()
+        .stdout_contains(expected_stdout)
+        .no_stderr();
 }
 
 #[test]

tests/by-util/test_chown.rs

@@ -4,6 +4,34 @@ use rust_users::get_effective_uid;
 
 extern crate chown;
 
+// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
+// If we are running inside the CI and "needle" is in "stderr" skipping this test is
+// considered okay. If we are not inside the CI this calls assert!(result.success).
+//
+// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
+//
+// stderr: "whoami: cannot find name for user ID 1001"
+// TODO: Maybe `adduser --uid 1001 username` can put things right?
+//
+// stderr: "id: cannot find name for group ID 116"
+// stderr: "thread 'main' panicked at 'called `Result::unwrap()` on an `Err`
+//     value: Custom { kind: NotFound, error: "No such id: 1001" }',
+//     /project/src/uucore/src/lib/features/perms.rs:176:44"
+//
+fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
+    if !result.succeeded() {
+        println!("result.stdout = {}", result.stdout_str());
+        println!("result.stderr = {}", result.stderr_str());
+        if is_ci() && result.stderr_str().contains(needle) {
+            println!("test skipped:");
+            return true;
+        } else {
+            result.success();
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod test_passgrp {
     use super::chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
@@ -49,338 +77,427 @@ fn test_invalid_option() {
 }
 
 #[test]
-fn test_chown_myself() {
+fn test_chown_only_owner() {
     // test chown username file.txt
+
     let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
         return;
     }
-    println!("results {}", result.stdout);
-    let username = result.stdout.trim_end();
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
 
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let result = ucmd.arg(username).arg(file1).run();
-    println!("results stdout {}", result.stdout);
-    println!("results stderr {}", result.stderr);
-    if is_ci() && result.stderr.contains("invalid user") {
-        // In the CI, some server are failing to return id.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-    assert!(result.success);
-}
 
-#[test]
-fn test_chown_myself_second() {
-    // test chown username: file.txt
-    let scene = TestScenario::new(util_name!());
-    let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-    println!("results {}", result.stdout);
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
-
-    at.touch(file1);
-    let result = ucmd
-        .arg(result.stdout.trim_end().to_owned() + ":")
+    // since only superuser can change owner, we have to change from ourself to ourself
+    let result = scene
+        .ucmd()
+        .arg(user_name)
+        .arg("--verbose")
         .arg(file1)
         .run();
+    result.stderr_contains(&"retained as");
 
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
+    // try to change to another existing user, e.g. 'root'
+    scene
+        .ucmd()
+        .arg("root")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
-fn test_chown_myself_group() {
-    // test chown username:group file.txt
+fn test_chown_only_owner_colon() {
+    // test chown username: file.txt
+
     let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
         return;
     }
-    println!("user name = {}", result.stdout);
-    let username = result.stdout.trim_end();
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let file1 = "test_chown_file1";
+    at.touch(file1);
+
+    scene
+        .ucmd()
+        .arg(format!("{}:", user_name))
+        .arg("--verbose")
+        .arg(file1)
+        .succeeds()
+        .stderr_contains(&"retained as");
+
+    scene
+        .ucmd()
+        .arg("root:")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
+}
+
+#[test]
+fn test_chown_only_colon() {
+    // test chown : file.txt
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file1 = "test_chown_file1";
+    at.touch(file1);
+
+    // expected:
+    // $ chown -v : file.txt 2>out_err ; echo $? ; cat out_err
+    // ownership of 'file.txt' retained
+    // 0
+    let result = scene.ucmd().arg(":").arg("--verbose").arg(file1).run();
+    if skipping_test_is_okay(&result, "No such id") {
+        return;
+    }
+    result.stderr_contains(&"retained as"); // TODO: verbose is not printed to stderr in GNU chown
+
+    // test chown : file.txt
+    // expected:
+    // $ chown -v :: file.txt 2>out_err ; echo $? ; cat out_err
+    // 1
+    // chown: invalid group: ‘::’
+    scene
+        .ucmd()
+        .arg("::")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"invalid group: ‘::’");
+}
+
+#[test]
+fn test_chown_failed_stdout() {
+    // test chown root file.txt
+
+    // TODO: implement once output "failed to change" to stdout is fixed
+    // expected:
+    // $ chown -v root file.txt 2>out_err ; echo $? ; cat out_err
+    // failed to change ownership of 'file.txt' from jhs to root
+    // 1
+    // chown: changing ownership of 'file.txt': Operation not permitted
+}
+
+#[test]
+fn test_chown_owner_group() {
+    // test chown username:group file.txt
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let file1 = "test_chown_file1";
+    at.touch(file1);
 
     let result = scene.cmd("id").arg("-gn").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("group name = {}", result.stdout);
-    let group = result.stdout.trim_end();
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
 
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
-    let perm = username.to_owned() + ":" + group;
-    at.touch(file1);
-    let result = ucmd.arg(perm).arg(file1).run();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("chown: invalid group:") {
-        // With some Ubuntu into the CI, we can get this answer
+    let result = scene
+        .ucmd()
+        .arg(format!("{}:{}", user_name, group_name))
+        .arg("--verbose")
+        .arg(file1)
+        .run();
+    if skipping_test_is_okay(&result, "chown: invalid group:") {
         return;
     }
-    assert!(result.success);
+    result.stderr_contains(&"retained as");
+
+    // TODO: on macos group name is not recognized correctly: "chown: invalid group: 'root:root'
+    #[cfg(any(windows, all(unix, not(target_os = "macos"))))]
+    scene
+        .ucmd()
+        .arg("root:root")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
+// TODO: on macos group name is not recognized correctly: "chown: invalid group: ':groupname'
+#[cfg(any(windows, all(unix, not(target_os = "macos"))))]
 fn test_chown_only_group() {
     // test chown :group file.txt
+
     let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
         return;
     }
-    println!("results {}", result.stdout);
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
 
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
-    let perm = ":".to_owned() + result.stdout.trim_end();
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let result = ucmd.arg(perm).arg(file1).run();
 
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-
-    if is_ci() && result.stderr.contains("Operation not permitted") {
+    let result = scene
+        .ucmd()
+        .arg(format!(":{}", user_name))
+        .arg("--verbose")
+        .arg(file1)
+        .run();
+    if is_ci() && result.stderr_str().contains("Operation not permitted") {
         // With ubuntu with old Rust in the CI, we can get an error
         return;
     }
-    if is_ci() && result.stderr.contains("chown: invalid group:") {
+    if is_ci() && result.stderr_str().contains("chown: invalid group:") {
         // With mac into the CI, we can get this answer
         return;
     }
-    assert!(result.success);
+    result.stderr_contains(&"retained as");
+    result.success();
+
+    scene
+        .ucmd()
+        .arg(":root")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
-fn test_chown_only_id() {
+fn test_chown_only_user_id() {
     // test chown 1111 file.txt
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-u").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd_keepenv("id").arg("-u").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let id = String::from(result.stdout.trim());
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
+    let user_id = String::from(result.stdout_str().trim());
+    assert!(!user_id.is_empty());
 
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let result = ucmd.arg(id).arg(file1).run();
 
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("chown: invalid user:") {
-        // With some Ubuntu into the CI, we can get this answer
+    let result = scene.ucmd().arg(user_id).arg("--verbose").arg(file1).run();
+    if skipping_test_is_okay(&result, "invalid user") {
+        // From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
+        // stderr: "chown: invalid user: '1001'
         return;
     }
-    assert!(result.success);
+    result.stderr_contains(&"retained as");
+
+    scene
+        .ucmd()
+        .arg("0")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
 fn test_chown_only_group_id() {
     // test chown :1111 file.txt
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-g").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd_keepenv("id").arg("-g").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let id = String::from(result.stdout.trim());
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
+    let group_id = String::from(result.stdout_str().trim());
+    assert!(!group_id.is_empty());
 
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let perm = ":".to_owned() + &id;
 
-    let result = ucmd.arg(perm).arg(file1).run();
-
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("chown: invalid group:") {
+    let result = scene
+        .ucmd()
+        .arg(format!(":{}", group_id))
+        .arg("--verbose")
+        .arg(file1)
+        .run();
+    if skipping_test_is_okay(&result, "chown: invalid group:") {
         // With mac into the CI, we can get this answer
         return;
     }
-    assert!(result.success);
+    result.stderr_contains(&"retained as");
+
+    // Apparently on CI "macos-latest, x86_64-apple-darwin, feat_os_macos"
+    // the process has the rights to change from runner:staff to runner:wheel
+    #[cfg(any(windows, all(unix, not(target_os = "macos"))))]
+    scene
+        .ucmd()
+        .arg(":0")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
-fn test_chown_both_id() {
+fn test_chown_owner_group_id() {
     // test chown 1111:1111 file.txt
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-u").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd_keepenv("id").arg("-u").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let id_user = String::from(result.stdout.trim());
+    let user_id = String::from(result.stdout_str().trim());
+    assert!(!user_id.is_empty());
 
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-g").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let result = scene.cmd_keepenv("id").arg("-g").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let id_group = String::from(result.stdout.trim());
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
+    let group_id = String::from(result.stdout_str().trim());
+    assert!(!group_id.is_empty());
 
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let perm = id_user + &":".to_owned() + &id_group;
 
-    let result = ucmd.arg(perm).arg(file1).run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-
-    if is_ci() && result.stderr.contains("invalid user") {
-        // In the CI, some server are failing to return id.
-        // As seems to be a configuration issue, ignoring it
+    let result = scene
+        .ucmd()
+        .arg(format!("{}:{}", user_id, group_id))
+        .arg("--verbose")
+        .arg(file1)
+        .run();
+    if skipping_test_is_okay(&result, "invalid user") {
+        // From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
+        // stderr: "chown: invalid user: '1001:116'
         return;
     }
+    result.stderr_contains(&"retained as");
 
-    assert!(result.success);
+    scene
+        .ucmd()
+        .arg("0:0")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
-fn test_chown_both_mix() {
-    // test chown 1111:1111 file.txt
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-u").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+fn test_chown_owner_group_mix() {
+    // test chown 1111:group file.txt
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd_keepenv("id").arg("-u").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let id_user = String::from(result.stdout.trim());
+    let user_id = String::from(result.stdout_str().trim());
+    assert!(!user_id.is_empty());
 
-    let result = TestScenario::new("id").ucmd_keepenv().arg("-gn").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let result = scene.cmd_keepenv("id").arg("-gn").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let group_name = String::from(result.stdout.trim());
-
-    let (at, mut ucmd) = at_and_ucmd!();
-    let file1 = "test_install_target_dir_file_a1";
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
 
+    let file1 = "test_chown_file1";
     at.touch(file1);
-    let perm = id_user + &":".to_owned() + &group_name;
 
-    let result = ucmd.arg(perm).arg(file1).run();
+    let result = scene
+        .ucmd()
+        .arg(format!("{}:{}", user_id, group_name))
+        .arg("--verbose")
+        .arg(file1)
+        .run();
+    result.stderr_contains(&"retained as");
 
-    if is_ci() && result.stderr.contains("invalid user") {
-        // In the CI, some server are failing to return id.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-    assert!(result.success);
+    // TODO: on macos group name is not recognized correctly: "chown: invalid group: '0:root'
+    #[cfg(any(windows, all(unix, not(target_os = "macos"))))]
+    scene
+        .ucmd()
+        .arg("0:root")
+        .arg("--verbose")
+        .arg(file1)
+        .fails()
+        .stderr_contains(&"failed to change");
 }
 
 #[test]
 fn test_chown_recursive() {
     let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let username = result.stdout.trim_end();
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
 
-    let (at, mut ucmd) = at_and_ucmd!();
-    at.mkdir("a");
-    at.mkdir("a/b");
-    at.mkdir("a/b/c");
+    at.mkdir_all("a/b/c");
     at.mkdir("z");
     at.touch(&at.plus_as_string("a/a"));
     at.touch(&at.plus_as_string("a/b/b"));
     at.touch(&at.plus_as_string("a/b/c/c"));
     at.touch(&at.plus_as_string("z/y"));
 
-    let result = ucmd
+    let result = scene
+        .ucmd()
         .arg("-R")
         .arg("--verbose")
-        .arg(username)
+        .arg(user_name)
         .arg("a")
         .arg("z")
         .run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("invalid user") {
-        // In the CI, some server are failing to return id.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-
-    assert!(result.stderr.contains("ownership of 'a/a' retained as"));
-    assert!(result.stderr.contains("ownership of 'z/y' retained as"));
-    assert!(result.success);
+    result.stderr_contains(&"ownership of 'a/a' retained as");
+    result.stderr_contains(&"ownership of 'z/y' retained as");
 }
 
 #[test]
 fn test_root_preserve() {
     let scene = TestScenario::new(util_name!());
+
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let username = result.stdout.trim_end();
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
 
-    let result = new_ucmd!()
+    let result = scene
+        .ucmd()
         .arg("--preserve-root")
         .arg("-R")
-        .arg(username)
+        .arg(user_name)
         .arg("/")
         .fails();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("invalid user") {
-        // In the CI, some server are failing to return id.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-    assert!(result
-        .stderr
-        .contains("chown: it is dangerous to operate recursively"));
+    result.stderr_contains(&"chown: it is dangerous to operate recursively");
 }
 
 #[cfg(target_os = "linux")]
@@ -392,8 +509,34 @@ fn test_big_p() {
             .arg("bin")
             .arg("/proc/self/cwd")
             .fails()
-            .stderr_is(
-                "chown: changing ownership of '/proc/self/cwd': Operation not permitted (os error 1)\n",
+            .stderr_contains(
+                "chown: changing ownership of '/proc/self/cwd': Operation not permitted (os error 1)",
             );
     }
 }
+
+#[test]
+fn test_chown_file_notexisting() {
+    // test chown username not_existing
+
+    let scene = TestScenario::new(util_name!());
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let _result = scene
+        .ucmd()
+        .arg(user_name)
+        .arg("--verbose")
+        .arg("not_existing")
+        .fails();
+
+    // TODO: uncomment once "failed to change ownership of '{}' to {}" added to stdout
+    // result.stderr_contains(&"retained as");
+    // TODO: uncomment once message changed from "cannot dereference" to "cannot access"
+    // result.stderr_contains(&"cannot access 'not_existing': No such file or directory");
+}

tests/by-util/test_chroot.rs

@@ -4,14 +4,11 @@ use crate::common::util::*;
 fn test_missing_operand() {
     let result = new_ucmd!().run();
 
-    assert_eq!(
-        true,
-        result
-            .stderr
-            .starts_with("error: The following required arguments were not provided")
-    );
+    assert!(result
+        .stderr_str()
+        .starts_with("error: The following required arguments were not provided"));
 
-    assert_eq!(true, result.stderr.contains("<newroot>"));
+    assert!(result.stderr_str().contains("<newroot>"));
 }
 
 #[test]
@@ -20,14 +17,11 @@ fn test_enter_chroot_fails() {
 
     at.mkdir("jail");
 
-    let result = ucmd.arg("jail").run();
+    let result = ucmd.arg("jail").fails();
 
-    assert_eq!(
-        true,
-        result.stderr.starts_with(
-            "chroot: error: cannot chroot to jail: Operation not permitted (os error 1)"
-        )
-    )
+    assert!(result
+        .stderr_str()
+        .starts_with("chroot: cannot chroot to jail: Operation not permitted (os error 1)"));
 }
 
 #[test]
@@ -38,7 +32,7 @@ fn test_no_such_directory() {
 
     ucmd.arg("a")
         .fails()
-        .stderr_is("chroot: error: cannot change root directory to `a`: no such directory");
+        .stderr_is("chroot: cannot change root directory to `a`: no such directory");
 }
 
 #[test]
@@ -47,39 +41,36 @@ fn test_invalid_user_spec() {
 
     at.mkdir("a");
 
-    let result = ucmd.arg("a").arg("--userspec=ARABA:").run();
+    let result = ucmd.arg("a").arg("--userspec=ARABA:").fails();
 
-    assert_eq!(
-        true,
-        result.stderr.starts_with("chroot: error: invalid userspec")
-    );
+    assert!(result.stderr_str().starts_with("chroot: invalid userspec"));
 }
 
 #[test]
 fn test_preference_of_userspec() {
     let scene = TestScenario::new(util_name!());
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("No such user/group") {
+    if is_ci() && result.stderr_str().contains("No such user/group") {
         // In the CI, some server are failing to return whoami.
         // As seems to be a configuration issue, ignoring it
         return;
     }
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let username = result.stdout.trim_end();
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
+    let username = result.stdout_str().trim_end();
 
     let ts = TestScenario::new("id");
     let result = ts.cmd("id").arg("-g").arg("-n").run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
 
-    if is_ci() && result.stderr.contains("cannot find name for user ID") {
+    if is_ci() && result.stderr_str().contains("cannot find name for user ID") {
         // In the CI, some server are failing to return id.
         // As seems to be a configuration issue, ignoring it
         return;
     }
 
-    let group_name = result.stdout.trim_end();
+    let group_name = result.stdout_str().trim_end();
     let (at, mut ucmd) = at_and_ucmd!();
 
     at.mkdir("a");
@@ -93,6 +84,6 @@ fn test_preference_of_userspec() {
         .arg(format!("--userspec={}:{}", username, group_name))
         .run();
 
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
 }

tests/by-util/test_cksum.rs

@@ -31,41 +31,50 @@ fn test_empty() {
 
     at.touch("a");
 
-    ucmd.arg("a").succeeds().stdout.ends_with("0 a");
+    ucmd.arg("a")
+        .succeeds()
+        .no_stderr()
+        .normalized_newlines_stdout_is("4294967295 0 a\n");
 }
 
 #[test]
-#[ignore]
 fn test_arg_overrides_stdin() {
     let (at, mut ucmd) = at_and_ucmd!();
     let input = "foobarfoobar";
 
     at.touch("a");
 
-    let result = ucmd.arg("a").pipe_in(input.as_bytes()).run();
-
-    println!("{}, {}", result.stdout, result.stderr);
-
-    assert!(result.stdout.ends_with("0 a\n"))
+    ucmd.arg("a")
+        .pipe_in(input.as_bytes())
+        // the command might have exited before all bytes have been pipe in.
+        // in that case, we don't care about the error (broken pipe)
+        .ignore_stdin_write_error()
+        .succeeds()
+        .no_stderr()
+        .normalized_newlines_stdout_is("4294967295 0 a\n");
 }
 
 #[test]
 fn test_invalid_file() {
-    let (_, mut ucmd) = at_and_ucmd!();
+    let ts = TestScenario::new(util_name!());
+    let at = ts.fixtures.clone();
 
-    let ls = TestScenario::new("ls");
-    let files = ls.cmd("ls").arg("-l").run();
-    println!("{:?}", files.stdout);
-    println!("{:?}", files.stderr);
+    let folder_name = "asdf";
 
-    let folder_name = "asdf".to_string();
+    // First check when file doesn't exist
+    ts.ucmd()
+        .arg(folder_name)
+        .fails()
+        .no_stdout()
+        .stderr_contains("cksum: 'asdf' No such file or directory");
 
-    let result = ucmd.arg(&folder_name).run();
-
-    println!("stdout: {:?}", result.stdout);
-    println!("stderr: {:?}", result.stderr);
-    assert!(result.stderr.contains("cksum: error: 'asdf'"));
-    assert!(!result.success);
+    // Then check when the file is of an invalid type
+    at.mkdir(folder_name);
+    ts.ucmd()
+        .arg(folder_name)
+        .fails()
+        .no_stdout()
+        .stderr_contains("cksum: 'asdf' Is a directory");
 }
 
 // Make sure crc is correct for files larger than 32 bytes
@@ -74,14 +83,13 @@ fn test_invalid_file() {
 fn test_crc_for_bigger_than_32_bytes() {
     let (_, mut ucmd) = at_and_ucmd!();
 
-    let result = ucmd.arg("chars.txt").run();
+    let result = ucmd.arg("chars.txt").succeeds();
 
-    let mut stdout_splitted = result.stdout.split(" ");
+    let mut stdout_splitted = result.stdout_str().split(" ");
 
     let cksum: i64 = stdout_splitted.next().unwrap().parse().unwrap();
     let bytes_cnt: i64 = stdout_splitted.next().unwrap().parse().unwrap();
 
-    assert!(result.success);
     assert_eq!(cksum, 586047089);
     assert_eq!(bytes_cnt, 16);
 }
@@ -90,14 +98,13 @@ fn test_crc_for_bigger_than_32_bytes() {
 fn test_stdin_larger_than_128_bytes() {
     let (_, mut ucmd) = at_and_ucmd!();
 
-    let result = ucmd.arg("larger_than_2056_bytes.txt").run();
+    let result = ucmd.arg("larger_than_2056_bytes.txt").succeeds();
 
-    let mut stdout_splitted = result.stdout.split(" ");
+    let mut stdout_splitted = result.stdout_str().split(" ");
 
     let cksum: i64 = stdout_splitted.next().unwrap().parse().unwrap();
     let bytes_cnt: i64 = stdout_splitted.next().unwrap().parse().unwrap();
 
-    assert!(result.success);
     assert_eq!(cksum, 945881979);
     assert_eq!(bytes_cnt, 2058);
 }

tests/by-util/test_csplit.rs

@@ -208,7 +208,7 @@ fn test_up_to_match_repeat_over() {
     ucmd.args(&["numbers50.txt", "/9$/", "{50}"])
         .fails()
         .stdout_is("16\n29\n30\n30\n30\n6\n")
-        .stderr_is("csplit: error: '/9$/': match not found on repetition 5");
+        .stderr_is("csplit: '/9$/': match not found on repetition 5");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -219,7 +219,7 @@ fn test_up_to_match_repeat_over() {
     ucmd.args(&["numbers50.txt", "/9$/", "{50}", "-k"])
         .fails()
         .stdout_is("16\n29\n30\n30\n30\n6\n")
-        .stderr_is("csplit: error: '/9$/': match not found on repetition 5");
+        .stderr_is("csplit: '/9$/': match not found on repetition 5");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -365,7 +365,7 @@ fn test_option_keep() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-k", "numbers50.txt", "/20/", "/nope/"])
         .fails()
-        .stderr_is("csplit: error: '/nope/': match not found")
+        .stderr_is("csplit: '/nope/': match not found")
         .stdout_is("48\n93\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -541,7 +541,7 @@ fn test_up_to_match_context_overflow() {
     ucmd.args(&["numbers50.txt", "/45/+10"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/45/+10': line number out of range");
+        .stderr_is("csplit: '/45/+10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -552,7 +552,7 @@ fn test_up_to_match_context_overflow() {
     ucmd.args(&["numbers50.txt", "/45/+10", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/45/+10': line number out of range");
+        .stderr_is("csplit: '/45/+10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -567,7 +567,7 @@ fn test_skip_to_match_context_underflow() {
     ucmd.args(&["numbers50.txt", "%5%-10"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '%5%-10': line number out of range");
+        .stderr_is("csplit: '%5%-10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -578,7 +578,7 @@ fn test_skip_to_match_context_underflow() {
     ucmd.args(&["numbers50.txt", "%5%-10", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '%5%-10': line number out of range");
+        .stderr_is("csplit: '%5%-10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -592,7 +592,7 @@ fn test_skip_to_match_context_overflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%45%+10"])
         .fails()
-        .stderr_only("csplit: error: '%45%+10': line number out of range");
+        .stderr_only("csplit: '%45%+10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -602,7 +602,7 @@ fn test_skip_to_match_context_overflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%45%+10", "-k"])
         .fails()
-        .stderr_only("csplit: error: '%45%+10': line number out of range");
+        .stderr_only("csplit: '%45%+10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -616,7 +616,7 @@ fn test_up_to_no_match1() {
     ucmd.args(&["numbers50.txt", "/4/", "/nope/"])
         .fails()
         .stdout_is("6\n135\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -627,7 +627,7 @@ fn test_up_to_no_match1() {
     ucmd.args(&["numbers50.txt", "/4/", "/nope/", "-k"])
         .fails()
         .stdout_is("6\n135\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -643,7 +643,7 @@ fn test_up_to_no_match2() {
     ucmd.args(&["numbers50.txt", "/4/", "/nope/", "{50}"])
         .fails()
         .stdout_is("6\n135\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -654,7 +654,7 @@ fn test_up_to_no_match2() {
     ucmd.args(&["numbers50.txt", "/4/", "/nope/", "{50}", "-k"])
         .fails()
         .stdout_is("6\n135\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -670,7 +670,7 @@ fn test_up_to_no_match3() {
     ucmd.args(&["numbers50.txt", "/0$/", "{50}"])
         .fails()
         .stdout_is("18\n30\n30\n30\n30\n3\n")
-        .stderr_is("csplit: error: '/0$/': match not found on repetition 5");
+        .stderr_is("csplit: '/0$/': match not found on repetition 5");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -681,7 +681,7 @@ fn test_up_to_no_match3() {
     ucmd.args(&["numbers50.txt", "/0$/", "{50}", "-k"])
         .fails()
         .stdout_is("18\n30\n30\n30\n30\n3\n")
-        .stderr_is("csplit: error: '/0$/': match not found on repetition 5");
+        .stderr_is("csplit: '/0$/': match not found on repetition 5");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -701,7 +701,7 @@ fn test_up_to_no_match4() {
     ucmd.args(&["numbers50.txt", "/nope/", "/4/"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -712,7 +712,7 @@ fn test_up_to_no_match4() {
     ucmd.args(&["numbers50.txt", "/nope/", "/4/", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -741,7 +741,7 @@ fn test_up_to_no_match6() {
     ucmd.args(&["numbers50.txt", "/nope/-5"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/-5': match not found");
+        .stderr_is("csplit: '/nope/-5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -752,7 +752,7 @@ fn test_up_to_no_match6() {
     ucmd.args(&["numbers50.txt", "/nope/-5", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/-5': match not found");
+        .stderr_is("csplit: '/nope/-5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -767,7 +767,7 @@ fn test_up_to_no_match7() {
     ucmd.args(&["numbers50.txt", "/nope/+5"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/+5': match not found");
+        .stderr_is("csplit: '/nope/+5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -778,7 +778,7 @@ fn test_up_to_no_match7() {
     ucmd.args(&["numbers50.txt", "/nope/+5", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/+5': match not found");
+        .stderr_is("csplit: '/nope/+5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -792,7 +792,7 @@ fn test_skip_to_no_match1() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%"])
         .fails()
-        .stderr_only("csplit: error: '%nope%': match not found");
+        .stderr_only("csplit: '%nope%': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -805,7 +805,7 @@ fn test_skip_to_no_match2() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%", "{50}"])
         .fails()
-        .stderr_only("csplit: error: '%nope%': match not found");
+        .stderr_only("csplit: '%nope%': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -818,7 +818,7 @@ fn test_skip_to_no_match3() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%0$%", "{50}"])
         .fails()
-        .stderr_only("csplit: error: '%0$%': match not found on repetition 5");
+        .stderr_only("csplit: '%0$%': match not found on repetition 5");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -831,7 +831,7 @@ fn test_skip_to_no_match4() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%", "/4/"])
         .fails()
-        .stderr_only("csplit: error: '%nope%': match not found");
+        .stderr_only("csplit: '%nope%': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -858,7 +858,7 @@ fn test_skip_to_no_match6() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%-5"])
         .fails()
-        .stderr_only("csplit: error: '%nope%-5': match not found");
+        .stderr_only("csplit: '%nope%-5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -871,7 +871,7 @@ fn test_skip_to_no_match7() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%+5"])
         .fails()
-        .stderr_only("csplit: error: '%nope%+5': match not found");
+        .stderr_only("csplit: '%nope%+5': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -884,7 +884,7 @@ fn test_no_match() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%nope%"])
         .fails()
-        .stderr_only("csplit: error: '%nope%': match not found");
+        .stderr_only("csplit: '%nope%': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -895,7 +895,7 @@ fn test_no_match() {
     ucmd.args(&["numbers50.txt", "/nope/"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '/nope/': match not found");
+        .stderr_is("csplit: '/nope/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -992,7 +992,7 @@ fn test_too_small_linenum_repeat() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/20/", "10", "{*}"])
         .fails()
-        .stderr_is("csplit: error: '10': line number out of range on repetition 5")
+        .stderr_is("csplit: '10': line number out of range on repetition 5")
         .stdout_is("48\n0\n0\n30\n30\n30\n3\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1003,7 +1003,7 @@ fn test_too_small_linenum_repeat() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/20/", "10", "{*}", "-k"])
         .fails()
-        .stderr_is("csplit: error: '10': line number out of range on repetition 5")
+        .stderr_is("csplit: '10': line number out of range on repetition 5")
         .stdout_is("48\n0\n0\n30\n30\n30\n3\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1025,7 +1025,7 @@ fn test_linenum_out_of_range1() {
     ucmd.args(&["numbers50.txt", "100"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '100': line number out of range");
+        .stderr_is("csplit: '100': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1036,7 +1036,7 @@ fn test_linenum_out_of_range1() {
     ucmd.args(&["numbers50.txt", "100", "-k"])
         .fails()
         .stdout_is("141\n")
-        .stderr_is("csplit: error: '100': line number out of range");
+        .stderr_is("csplit: '100': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1051,7 +1051,7 @@ fn test_linenum_out_of_range2() {
     ucmd.args(&["numbers50.txt", "10", "100"])
         .fails()
         .stdout_is("18\n123\n")
-        .stderr_is("csplit: error: '100': line number out of range");
+        .stderr_is("csplit: '100': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1062,7 +1062,7 @@ fn test_linenum_out_of_range2() {
     ucmd.args(&["numbers50.txt", "10", "100", "-k"])
         .fails()
         .stdout_is("18\n123\n")
-        .stderr_is("csplit: error: '100': line number out of range");
+        .stderr_is("csplit: '100': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1078,7 +1078,7 @@ fn test_linenum_out_of_range3() {
     ucmd.args(&["numbers50.txt", "40", "{2}"])
         .fails()
         .stdout_is("108\n33\n")
-        .stderr_is("csplit: error: '40': line number out of range on repetition 1");
+        .stderr_is("csplit: '40': line number out of range on repetition 1");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1089,7 +1089,7 @@ fn test_linenum_out_of_range3() {
     ucmd.args(&["numbers50.txt", "40", "{2}", "-k"])
         .fails()
         .stdout_is("108\n33\n")
-        .stderr_is("csplit: error: '40': line number out of range on repetition 1");
+        .stderr_is("csplit: '40': line number out of range on repetition 1");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1105,7 +1105,7 @@ fn test_linenum_out_of_range4() {
     ucmd.args(&["numbers50.txt", "40", "{*}"])
         .fails()
         .stdout_is("108\n33\n")
-        .stderr_is("csplit: error: '40': line number out of range on repetition 1");
+        .stderr_is("csplit: '40': line number out of range on repetition 1");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1116,7 +1116,7 @@ fn test_linenum_out_of_range4() {
     ucmd.args(&["numbers50.txt", "40", "{*}", "-k"])
         .fails()
         .stdout_is("108\n33\n")
-        .stderr_is("csplit: error: '40': line number out of range on repetition 1");
+        .stderr_is("csplit: '40': line number out of range on repetition 1");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1132,7 +1132,7 @@ fn test_skip_to_match_negative_offset_before_a_match() {
     ucmd.args(&["numbers50.txt", "/20/-10", "/15/"])
         .fails()
         .stdout_is("18\n123\n")
-        .stderr_is("csplit: error: '/15/': match not found");
+        .stderr_is("csplit: '/15/': match not found");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1177,7 +1177,7 @@ fn test_corner_case2() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/10/-5", "/10/"])
         .fails()
-        .stderr_is("csplit: error: '/10/': match not found")
+        .stderr_is("csplit: '/10/': match not found")
         .stdout_is("8\n133\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1191,7 +1191,7 @@ fn test_corner_case3() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/15/-3", "14", "/15/"])
         .fails()
-        .stderr_is("csplit: error: '/15/': match not found")
+        .stderr_is("csplit: '/15/': match not found")
         .stdout_is("24\n6\n111\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1223,7 +1223,7 @@ fn test_up_to_match_context_underflow() {
     ucmd.args(&["numbers50.txt", "/5/-10"])
         .fails()
         .stdout_is("0\n141\n")
-        .stderr_is("csplit: error: '/5/-10': line number out of range");
+        .stderr_is("csplit: '/5/-10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -1234,7 +1234,7 @@ fn test_up_to_match_context_underflow() {
     ucmd.args(&["numbers50.txt", "/5/-10", "-k"])
         .fails()
         .stdout_is("0\n141\n")
-        .stderr_is("csplit: error: '/5/-10': line number out of range");
+        .stderr_is("csplit: '/5/-10': line number out of range");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
@@ -1251,7 +1251,7 @@ fn test_linenum_range_with_up_to_match1() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-5"])
         .fails()
-        .stderr_is("csplit: error: '/12/-5': line number out of range")
+        .stderr_is("csplit: '/12/-5': line number out of range")
         .stdout_is("18\n0\n123\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1262,7 +1262,7 @@ fn test_linenum_range_with_up_to_match1() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-5", "-k"])
         .fails()
-        .stderr_is("csplit: error: '/12/-5': line number out of range")
+        .stderr_is("csplit: '/12/-5': line number out of range")
         .stdout_is("18\n0\n123\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1281,7 +1281,7 @@ fn test_linenum_range_with_up_to_match2() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-15"])
         .fails()
-        .stderr_is("csplit: error: '/12/-15': line number out of range")
+        .stderr_is("csplit: '/12/-15': line number out of range")
         .stdout_is("18\n0\n123\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1292,7 +1292,7 @@ fn test_linenum_range_with_up_to_match2() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-15", "-k"])
         .fails()
-        .stderr_is("csplit: error: '/12/-15': line number out of range")
+        .stderr_is("csplit: '/12/-15': line number out of range")
         .stdout_is("18\n0\n123\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1310,7 +1310,7 @@ fn test_linenum_range_with_up_to_match3() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/10/", "-k"])
         .fails()
-        .stderr_is("csplit: error: '/10/': match not found")
+        .stderr_is("csplit: '/10/': match not found")
         .stdout_is("18\n123\n");
 
     let count = glob(&at.plus_as_string("xx*"))

tests/by-util/test_cut.rs

@@ -149,11 +149,11 @@ fn test_directory_and_no_such_file() {
     ucmd.arg("-b1")
         .arg("some")
         .run()
-        .stderr_is("cut: error: some: Is a directory\n");
+        .stderr_is("cut: some: Is a directory\n");
 
     new_ucmd!()
         .arg("-b1")
         .arg("some")
         .run()
-        .stderr_is("cut: error: some: No such file or directory\n");
+        .stderr_is("cut: some: No such file or directory\n");
 }

tests/by-util/test_date.rs

@@ -7,174 +7,170 @@ use rust_users::*;
 
 #[test]
 fn test_date_email() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--rfc-email").run();
-    assert!(result.success);
+    new_ucmd!().arg("--rfc-email").succeeds();
 }
 
 #[test]
 fn test_date_email2() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("-R").run();
-    assert!(result.success);
+    new_ucmd!().arg("-R").succeeds();
 }
 
 #[test]
 fn test_date_rfc_3339() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("--rfc-3339=ns").succeeds();
+    let rfc_regexp = concat!(
+        r#"(\d+)-(0[1-9]|1[012])-(0[1-9]|[12]\d|3[01])\s([01]\d|2[0-3]):"#,
+        r#"([0-5]\d):([0-5]\d|60)(\.\d+)?(([Zz])|([\+|\-]([01]\d|2[0-3])))"#
+    );
+    let re = Regex::new(rfc_regexp).unwrap();
 
     // Check that the output matches the regexp
-    let rfc_regexp = r"(\d+)-(0[1-9]|1[012])-(0[1-9]|[12]\d|3[01])\s([01]\d|2[0-3]):([0-5]\d):([0-5]\d|60)(\.\d+)?(([Zz])|([\+|\-]([01]\d|2[0-3])))";
-    let re = Regex::new(rfc_regexp).unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene
+        .ucmd()
+        .arg("--rfc-3339=ns")
+        .succeeds()
+        .stdout_matches(&re);
 
-    result = scene.ucmd().arg("--rfc-3339=seconds").succeeds();
-
-    // Check that the output matches the regexp
-    let re = Regex::new(rfc_regexp).unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene
+        .ucmd()
+        .arg("--rfc-3339=seconds")
+        .succeeds()
+        .stdout_matches(&re);
 }
 
 #[test]
 fn test_date_rfc_8601() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--iso-8601=ns").run();
-    assert!(result.success);
+    new_ucmd!().arg("--iso-8601=ns").succeeds();
 }
 
 #[test]
 fn test_date_rfc_8601_second() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--iso-8601=second").run();
-    assert!(result.success);
+    new_ucmd!().arg("--iso-8601=second").succeeds();
 }
 
 #[test]
 fn test_date_utc() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--utc").run();
-    assert!(result.success);
+    new_ucmd!().arg("--utc").succeeds();
 }
 
 #[test]
 fn test_date_universal() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--universal").run();
-    assert!(result.success);
+    new_ucmd!().arg("--universal").succeeds();
 }
 
 #[test]
 fn test_date_format_y() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("+%Y").succeeds();
-
-    assert!(result.success);
     let mut re = Regex::new(r"^\d{4}$").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%Y").succeeds().stdout_matches(&re);
 
-    result = scene.ucmd().arg("+%y").succeeds();
-
-    assert!(result.success);
     re = Regex::new(r"^\d{2}$").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%y").succeeds().stdout_matches(&re);
 }
 
 #[test]
 fn test_date_format_m() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("+%b").succeeds();
-
-    assert!(result.success);
     let mut re = Regex::new(r"\S+").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%b").succeeds().stdout_matches(&re);
 
-    result = scene.ucmd().arg("+%m").succeeds();
-
-    assert!(result.success);
     re = Regex::new(r"^\d{2}$").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%m").succeeds().stdout_matches(&re);
 }
 
 #[test]
 fn test_date_format_day() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("+%a").succeeds();
-
-    assert!(result.success);
     let mut re = Regex::new(r"\S+").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
-
-    result = scene.ucmd().arg("+%A").succeeds();
-
-    assert!(result.success);
+    scene.ucmd().arg("+%a").succeeds().stdout_matches(&re);
 
     re = Regex::new(r"\S+").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%A").succeeds().stdout_matches(&re);
 
-    result = scene.ucmd().arg("+%u").succeeds();
-
-    assert!(result.success);
     re = Regex::new(r"^\d{1}$").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    scene.ucmd().arg("+%u").succeeds().stdout_matches(&re);
 }
 
 #[test]
 fn test_date_format_full_day() {
-    let scene = TestScenario::new(util_name!());
-
-    let result = scene.ucmd().arg("+'%a %Y-%m-%d'").succeeds();
-
-    assert!(result.success);
     let re = Regex::new(r"\S+ \d{4}-\d{2}-\d{2}").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    new_ucmd!()
+        .arg("+'%a %Y-%m-%d'")
+        .succeeds()
+        .stdout_matches(&re);
+}
+
+#[test]
+fn test_date_nano_seconds() {
+    // %N     nanoseconds (000000000..999999999)
+    let re = Regex::new(r"^\d{1,9}$").unwrap();
+    new_ucmd!().arg("+%N").succeeds().stdout_matches(&re);
+}
+
+#[test]
+fn test_date_format_without_plus() {
+    // [+FORMAT]
+    new_ucmd!()
+        .arg("%s")
+        .fails()
+        .stderr_contains("date: invalid date ‘%s’")
+        .code_is(1);
+}
+
+#[test]
+fn test_date_format_literal() {
+    new_ucmd!().arg("+%%s").succeeds().stdout_is("%s\n");
+    new_ucmd!().arg("+%%N").succeeds().stdout_is("%N\n");
 }
 
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
 fn test_date_set_valid() {
     if get_effective_uid() == 0 {
-        let (_, mut ucmd) = at_and_ucmd!();
-        let result = ucmd
+        new_ucmd!()
             .arg("--set")
             .arg("2020-03-12 13:30:00+08:00")
-            .succeeds();
-        result.no_stdout().no_stderr();
+            .succeeds()
+            .no_stdout()
+            .no_stderr();
     }
 }
 
 #[test]
 #[cfg(any(windows, all(unix, not(target_os = "macos"))))]
 fn test_date_set_invalid() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--set").arg("123abcd").fails();
-    let result = result.no_stdout();
-    assert!(result.stderr.starts_with("date: invalid date "));
+    let result = new_ucmd!().arg("--set").arg("123abcd").fails();
+    result.no_stdout();
+    assert!(result.stderr_str().starts_with("date: invalid date "));
 }
 
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
 fn test_date_set_permissions_error() {
-    if !(get_effective_uid() == 0 || is_wsl()) {
-        let (_, mut ucmd) = at_and_ucmd!();
-        let result = ucmd.arg("--set").arg("2020-03-11 21:45:00+08:00").fails();
-        let result = result.no_stdout();
-        assert!(result.stderr.starts_with("date: cannot set date: "));
+    if !(get_effective_uid() == 0 || uucore::os::is_wsl_1()) {
+        let result = new_ucmd!()
+            .arg("--set")
+            .arg("2020-03-11 21:45:00+08:00")
+            .fails();
+        result.no_stdout();
+        assert!(result.stderr_str().starts_with("date: cannot set date: "));
     }
 }
 
 #[test]
 #[cfg(target_os = "macos")]
 fn test_date_set_mac_unavailable() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--set").arg("2020-03-11 21:45:00+08:00").fails();
-    let result = result.no_stdout();
+    let result = new_ucmd!()
+        .arg("--set")
+        .arg("2020-03-11 21:45:00+08:00")
+        .fails();
+    result.no_stdout();
     assert!(result
-        .stderr
+        .stderr_str()
         .starts_with("date: setting the date is not supported by macOS"));
 }
 
@@ -183,13 +179,12 @@ fn test_date_set_mac_unavailable() {
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_2() {
     if get_effective_uid() == 0 {
-        let (_, mut ucmd) = at_and_ucmd!();
-        let result = ucmd
+        let result = new_ucmd!()
             .arg("--set")
             .arg("Sat 20 Mar 2021 14:53:01 AWST")
             .fails();
-        let result = result.no_stdout();
-        assert!(result.stderr.starts_with("date: invalid date "));
+        result.no_stdout();
+        assert!(result.stderr_str().starts_with("date: invalid date "));
     }
 }
 
@@ -198,13 +193,12 @@ fn test_date_set_valid_2() {
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_3() {
     if get_effective_uid() == 0 {
-        let (_, mut ucmd) = at_and_ucmd!();
-        let result = ucmd
+        let result = new_ucmd!()
             .arg("--set")
             .arg("Sat 20 Mar 2021 14:53:01") // Local timezone
             .fails();
-        let result = result.no_stdout();
-        assert!(result.stderr.starts_with("date: invalid date "));
+        result.no_stdout();
+        assert!(result.stderr_str().starts_with("date: invalid date "));
     }
 }
 
@@ -213,12 +207,11 @@ fn test_date_set_valid_3() {
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_4() {
     if get_effective_uid() == 0 {
-        let (_, mut ucmd) = at_and_ucmd!();
-        let result = ucmd
+        let result = new_ucmd!()
             .arg("--set")
             .arg("2020-03-11 21:45:00") // Local timezone
             .fails();
-        let result = result.no_stdout();
-        assert!(result.stderr.starts_with("date: invalid date "));
+        result.no_stdout();
+        assert!(result.stderr_str().starts_with("date: invalid date "));
     }
 }

tests/by-util/test_df.rs

@@ -2,30 +2,34 @@ use crate::common::util::*;
 
 #[test]
 fn test_df_compatible_no_size_arg() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("-a").run();
-    assert!(result.success);
+    new_ucmd!().arg("-a").succeeds();
 }
 
 #[test]
 fn test_df_compatible() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("-ah").run();
-    assert!(result.success);
+    new_ucmd!().arg("-ah").succeeds();
 }
 
 #[test]
 fn test_df_compatible_type() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("-aT").run();
-    assert!(result.success);
+    new_ucmd!().arg("-aT").succeeds();
 }
 
 #[test]
 fn test_df_compatible_si() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("-aH").run();
-    assert!(result.success);
+    new_ucmd!().arg("-aH").succeeds();
+}
+
+#[test]
+fn test_df_output() {
+    if cfg!(target_os = "macos") {
+        new_ucmd!().arg("-H").arg("-total").succeeds().
+        stdout_only("Filesystem               Size         Used    Available     Capacity  Use% Mounted on       \n");
+    } else {
+        new_ucmd!().arg("-H").arg("-total").succeeds().stdout_only(
+            "Filesystem               Size         Used    Available  Use% Mounted on       \n",
+        );
+    }
 }
 
 // ToDO: more tests...

tests/by-util/test_dirname.rs

@@ -16,6 +16,21 @@ fn test_path_without_trailing_slashes() {
         .stdout_is("/root/alpha/beta/gamma/delta/epsilon\n");
 }
 
+#[test]
+fn test_path_without_trailing_slashes_and_zero() {
+    new_ucmd!()
+        .arg("-z")
+        .arg("/root/alpha/beta/gamma/delta/epsilon/omega")
+        .succeeds()
+        .stdout_is("/root/alpha/beta/gamma/delta/epsilon\u{0}");
+
+    new_ucmd!()
+        .arg("--zero")
+        .arg("/root/alpha/beta/gamma/delta/epsilon/omega")
+        .succeeds()
+        .stdout_is("/root/alpha/beta/gamma/delta/epsilon\u{0}");
+}
+
 #[test]
 fn test_root() {
     new_ucmd!().arg("/").run().stdout_is("/\n");

tests/by-util/test_du.rs

@@ -7,13 +7,10 @@ const SUB_LINK: &str = "subdir/links/sublink.txt";
 
 #[test]
 fn test_du_basics() {
-    let (_at, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
+    new_ucmd!().succeeds().no_stderr();
 }
 #[cfg(target_vendor = "apple")]
-fn _du_basics(s: String) {
+fn _du_basics(s: &str) {
     let answer = "32\t./subdir
 8\t./subdir/deeper
 24\t./subdir/links
@@ -22,7 +19,7 @@ fn _du_basics(s: String) {
     assert_eq!(s, answer);
 }
 #[cfg(not(target_vendor = "apple"))]
-fn _du_basics(s: String) {
+fn _du_basics(s: &str) {
     let answer = "28\t./subdir
 8\t./subdir/deeper
 16\t./subdir/links
@@ -33,26 +30,41 @@ fn _du_basics(s: String) {
 
 #[test]
 fn test_du_basics_subdir() {
-    let (_at, mut ucmd) = at_and_ucmd!();
+    let scene = TestScenario::new(util_name!());
 
-    let result = ucmd.arg(SUB_DIR).run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
-    _du_basics_subdir(result.stdout);
+    let result = scene.ucmd().arg(SUB_DIR).succeeds();
+
+    #[cfg(target_os = "linux")]
+    {
+        let result_reference = scene.cmd("du").arg(SUB_DIR).run();
+        if result_reference.succeeded() {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
+    _du_basics_subdir(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_basics_subdir(s: String) {
+fn _du_basics_subdir(s: &str) {
     assert_eq!(s, "4\tsubdir/deeper\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_basics_subdir(s: String) {
+fn _du_basics_subdir(s: &str) {
     assert_eq!(s, "0\tsubdir/deeper\n");
 }
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
-fn _du_basics_subdir(s: String) {
+#[cfg(target_os = "freebsd")]
+fn _du_basics_subdir(s: &str) {
+    assert_eq!(s, "8\tsubdir/deeper\n");
+}
+#[cfg(all(
+    not(target_vendor = "apple"),
+    not(target_os = "windows"),
+    not(target_os = "freebsd")
+))]
+fn _du_basics_subdir(s: &str) {
     // MS-WSL linux has altered expected output
-    if !is_wsl() {
+    if !uucore::os::is_wsl_1() {
         assert_eq!(s, "8\tsubdir/deeper\n");
     } else {
         assert_eq!(s, "0\tsubdir/deeper\n");
@@ -61,42 +73,53 @@ fn _du_basics_subdir(s: String) {
 
 #[test]
 fn test_du_basics_bad_name() {
-    let (_at, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("bad_name").run();
-    assert_eq!(result.stdout, "");
-    assert_eq!(
-        result.stderr,
-        "du: error: bad_name: No such file or directory\n"
-    );
+    new_ucmd!()
+        .arg("bad_name")
+        .succeeds() // TODO: replace with ".fails()" once `du` is fixed
+        .stderr_only("du: bad_name: No such file or directory\n");
 }
 
 #[test]
 fn test_du_soft_link() {
-    let ts = TestScenario::new("du");
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
 
-    let link = ts.ccmd("ln").arg("-s").arg(SUB_FILE).arg(SUB_LINK).run();
-    assert!(link.success);
+    at.symlink_file(SUB_FILE, SUB_LINK);
 
-    let result = ts.ucmd().arg(SUB_DIR_LINKS).run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
-    _du_soft_link(result.stdout);
+    let result = scene.ucmd().arg(SUB_DIR_LINKS).succeeds();
+
+    #[cfg(target_os = "linux")]
+    {
+        let result_reference = scene.cmd("du").arg(SUB_DIR_LINKS).run();
+        if result_reference.succeeded() {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
+    _du_soft_link(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_soft_link(s: String) {
+fn _du_soft_link(s: &str) {
     // 'macos' host variants may have `du` output variation for soft links
     assert!((s == "12\tsubdir/links\n") || (s == "16\tsubdir/links\n"));
 }
 #[cfg(target_os = "windows")]
-fn _du_soft_link(s: String) {
+fn _du_soft_link(s: &str) {
     assert_eq!(s, "8\tsubdir/links\n");
 }
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
-fn _du_soft_link(s: String) {
+#[cfg(target_os = "freebsd")]
+fn _du_soft_link(s: &str) {
+    assert_eq!(s, "16\tsubdir/links\n");
+}
+#[cfg(all(
+    not(target_vendor = "apple"),
+    not(target_os = "windows"),
+    not(target_os = "freebsd")
+))]
+fn _du_soft_link(s: &str) {
     // MS-WSL linux has altered expected output
-    if !is_wsl() {
+    if !uucore::os::is_wsl_1() {
         assert_eq!(s, "16\tsubdir/links\n");
     } else {
         assert_eq!(s, "8\tsubdir/links\n");
@@ -105,30 +128,45 @@ fn _du_soft_link(s: String) {
 
 #[test]
 fn test_du_hard_link() {
-    let ts = TestScenario::new("du");
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
 
-    let link = ts.ccmd("ln").arg(SUB_FILE).arg(SUB_LINK).run();
-    assert!(link.success);
+    at.hard_link(SUB_FILE, SUB_LINK);
 
-    let result = ts.ucmd().arg(SUB_DIR_LINKS).run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
+    let result = scene.ucmd().arg(SUB_DIR_LINKS).succeeds();
+
+    #[cfg(target_os = "linux")]
+    {
+        let result_reference = scene.cmd("du").arg(SUB_DIR_LINKS).run();
+        if result_reference.succeeded() {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
     // We do not double count hard links as the inodes are identical
-    _du_hard_link(result.stdout);
+    _du_hard_link(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_hard_link(s: String) {
+fn _du_hard_link(s: &str) {
     assert_eq!(s, "12\tsubdir/links\n")
 }
 #[cfg(target_os = "windows")]
-fn _du_hard_link(s: String) {
+fn _du_hard_link(s: &str) {
     assert_eq!(s, "8\tsubdir/links\n")
 }
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
-fn _du_hard_link(s: String) {
+#[cfg(target_os = "freebsd")]
+fn _du_hard_link(s: &str) {
+    assert_eq!(s, "16\tsubdir/links\n")
+}
+#[cfg(all(
+    not(target_vendor = "apple"),
+    not(target_os = "windows"),
+    not(target_os = "freebsd")
+))]
+fn _du_hard_link(s: &str) {
     // MS-WSL linux has altered expected output
-    if !is_wsl() {
+    if !uucore::os::is_wsl_1() {
         assert_eq!(s, "16\tsubdir/links\n");
     } else {
         assert_eq!(s, "8\tsubdir/links\n");
@@ -137,26 +175,46 @@ fn _du_hard_link(s: String) {
 
 #[test]
 fn test_du_d_flag() {
-    let ts = TestScenario::new("du");
+    let scene = TestScenario::new(util_name!());
 
-    let result = ts.ucmd().arg("-d").arg("1").run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
-    _du_d_flag(result.stdout);
+    let result = scene.ucmd().arg("-d1").succeeds();
+
+    #[cfg(target_os = "linux")]
+    {
+        let result_reference = scene.cmd("du").arg("-d1").run();
+        if result_reference.succeeded() {
+            assert_eq!(
+                // TODO: gnu `du` doesn't use trailing "/" here
+                // result.stdout_str(), result_reference.stdout_str()
+                result.stdout_str().trim_end_matches("/\n"),
+                result_reference.stdout_str().trim_end_matches("\n")
+            );
+            return;
+        }
+    }
+    _du_d_flag(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_d_flag(s: String) {
+fn _du_d_flag(s: &str) {
     assert_eq!(s, "16\t./subdir\n20\t./\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_d_flag(s: String) {
+fn _du_d_flag(s: &str) {
     assert_eq!(s, "8\t./subdir\n8\t./\n");
 }
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
-fn _du_d_flag(s: String) {
+#[cfg(target_os = "freebsd")]
+fn _du_d_flag(s: &str) {
+    assert_eq!(s, "28\t./subdir\n36\t./\n");
+}
+#[cfg(all(
+    not(target_vendor = "apple"),
+    not(target_os = "windows"),
+    not(target_os = "freebsd")
+))]
+fn _du_d_flag(s: &str) {
     // MS-WSL linux has altered expected output
-    if !is_wsl() {
+    if !uucore::os::is_wsl_1() {
         assert_eq!(s, "28\t./subdir\n36\t./\n");
     } else {
         assert_eq!(s, "8\t./subdir\n8\t./\n");
@@ -165,28 +223,71 @@ fn _du_d_flag(s: String) {
 
 #[test]
 fn test_du_h_flag_empty_file() {
-    let ts = TestScenario::new("du");
-
-    let result = ts.ucmd().arg("-h").arg("empty.txt").run();
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
-    assert_eq!(result.stdout, "0\tempty.txt\n");
+    new_ucmd!()
+        .arg("-h")
+        .arg("empty.txt")
+        .succeeds()
+        .stdout_only("0\tempty.txt\n");
 }
 
 #[cfg(feature = "touch")]
 #[test]
 fn test_du_time() {
-    let ts = TestScenario::new("du");
+    let scene = TestScenario::new(util_name!());
 
-    let touch = ts.ccmd("touch").arg("-a").arg("-m").arg("-t").arg("201505150000").arg("date_test").run();
-    assert!(touch.success);
+    scene
+        .ccmd("touch")
+        .arg("-a")
+        .arg("-m")
+        .arg("-t")
+        .arg("201505150000")
+        .arg("date_test")
+        .succeeds();
 
-    let result = ts.ucmd().arg("--time").arg("date_test").run();
-
-    // cleanup by removing test file
-    ts.cmd("rm").arg("date_test").run();
-
-    assert!(result.success);
-    assert_eq!(result.stderr, "");
-    assert_eq!(result.stdout, "0\t2015-05-15 00:00\tdate_test\n");
+    scene
+        .ucmd()
+        .arg("--time")
+        .arg("date_test")
+        .succeeds()
+        .stdout_only("0\t2015-05-15 00:00\tdate_test\n");
+}
+
+#[cfg(not(target_os = "windows"))]
+#[cfg(feature = "chmod")]
+#[test]
+fn test_du_no_permission() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir_all(SUB_DIR_LINKS);
+
+    scene.ccmd("chmod").arg("-r").arg(SUB_DIR_LINKS).succeeds();
+
+    let result = scene.ucmd().arg(SUB_DIR_LINKS).run(); // TODO: replace with ".fails()" once `du` is fixed
+    result.stderr_contains(
+        "du: cannot read directory ‘subdir/links‘: Permission denied (os error 13)",
+    );
+
+    #[cfg(target_os = "linux")]
+    {
+        let result_reference = scene.cmd("du").arg(SUB_DIR_LINKS).fails();
+        if result_reference
+            .stderr_str()
+            .contains("du: cannot read directory 'subdir/links': Permission denied")
+        {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
+
+    _du_no_permission(result.stdout_str());
+}
+
+#[cfg(target_vendor = "apple")]
+fn _du_no_permission(s: &str) {
+    assert_eq!(s, "0\tsubdir/links\n");
+}
+#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
+fn _du_no_permission(s: &str) {
+    assert_eq!(s, "4\tsubdir/links\n");
 }

tests/by-util/test_echo.rs

@@ -2,22 +2,17 @@ use crate::common::util::*;
 
 #[test]
 fn test_default() {
-    //CmdResult.stdout_only(...) trims trailing newlines
-    assert_eq!("hi\n", new_ucmd!().arg("hi").succeeds().no_stderr().stdout);
+    new_ucmd!().arg("hi").succeeds().stdout_only("hi\n");
 }
 
 #[test]
 fn test_no_trailing_newline() {
-    //CmdResult.stdout_only(...) trims trailing newlines
-    assert_eq!(
-        "hi",
-        new_ucmd!()
-            .arg("-n")
-            .arg("hi")
-            .succeeds()
-            .no_stderr()
-            .stdout
-    );
+    new_ucmd!()
+        .arg("-n")
+        .arg("hi")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("hi");
 }
 
 #[test]
@@ -192,39 +187,38 @@ fn test_hyphen_values_inside_string() {
     new_ucmd!()
         .arg("'\"\n'CXXFLAGS=-g -O2'\n\"'")
         .succeeds()
-        .stdout
-        .contains("CXXFLAGS");
+        .stdout_contains("CXXFLAGS");
 }
 
 #[test]
 fn test_hyphen_values_at_start() {
-    let result = new_ucmd!()
+    new_ucmd!()
         .arg("-E")
         .arg("-test")
         .arg("araba")
         .arg("-merci")
-        .run();
-
-    assert!(result.success);
-    assert_eq!(false, result.stdout.contains("-E"));
-    assert_eq!(result.stdout, "-test araba -merci\n");
+        .run()
+        .success()
+        .stdout_does_not_contain("-E")
+        .stdout_is("-test araba -merci\n");
 }
 
 #[test]
 fn test_hyphen_values_between() {
-    let result = new_ucmd!().arg("test").arg("-E").arg("araba").run();
+    new_ucmd!()
+        .arg("test")
+        .arg("-E")
+        .arg("araba")
+        .run()
+        .success()
+        .stdout_is("test -E araba\n");
 
-    assert!(result.success);
-    assert_eq!(result.stdout, "test -E araba\n");
-
-    let result = new_ucmd!()
+    new_ucmd!()
         .arg("dumdum ")
         .arg("dum dum dum")
         .arg("-e")
         .arg("dum")
-        .run();
-
-    assert!(result.success);
-    assert_eq!(result.stdout, "dumdum  dum dum dum -e dum\n");
-    assert_eq!(true, result.stdout.contains("-e"));
+        .run()
+        .success()
+        .stdout_is("dumdum  dum dum dum -e dum\n");
 }

tests/by-util/test_env.rs

@@ -8,45 +8,36 @@ use tempfile::tempdir;
 
 #[test]
 fn test_env_help() {
-    assert!(new_ucmd!()
+    new_ucmd!()
         .arg("--help")
         .succeeds()
         .no_stderr()
-        .stdout
-        .contains("OPTIONS:"));
+        .stdout_contains("OPTIONS:");
 }
 
 #[test]
 fn test_env_version() {
-    assert!(new_ucmd!()
+    new_ucmd!()
         .arg("--version")
         .succeeds()
         .no_stderr()
-        .stdout
-        .contains(util_name!()));
+        .stdout_contains(util_name!());
 }
 
 #[test]
 fn test_echo() {
-    // assert!(new_ucmd!().arg("printf").arg("FOO-bar").succeeds().no_stderr().stdout.contains("FOO-bar"));
-    let mut cmd = new_ucmd!();
-    cmd.arg("echo").arg("FOO-bar");
-    println!("cmd={:?}", cmd);
+    let result = new_ucmd!().arg("echo").arg("FOO-bar").succeeds();
 
-    let result = cmd.run();
-    println!("success={:?}", result.success);
-    println!("stdout={:?}", result.stdout);
-    println!("stderr={:?}", result.stderr);
-    assert!(result.success);
-
-    let out = result.stdout.trim_end();
-
-    assert_eq!(out, "FOO-bar");
+    assert_eq!(result.stdout_str().trim(), "FOO-bar");
 }
 
 #[test]
 fn test_file_option() {
-    let out = new_ucmd!().arg("-f").arg("vars.conf.txt").run().stdout;
+    let out = new_ucmd!()
+        .arg("-f")
+        .arg("vars.conf.txt")
+        .run()
+        .stdout_move_str();
 
     assert_eq!(
         out.lines()
@@ -63,7 +54,7 @@ fn test_combined_file_set() {
         .arg("vars.conf.txt")
         .arg("FOO=bar.alt")
         .run()
-        .stdout;
+        .stdout_move_str();
 
     assert_eq!(out.lines().filter(|&line| line == "FOO=bar.alt").count(), 1);
 }
@@ -76,8 +67,8 @@ fn test_combined_file_set_unset() {
         .arg("-f")
         .arg("vars.conf.txt")
         .arg("FOO=bar.alt")
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
 
     assert_eq!(
         out.lines()
@@ -89,17 +80,18 @@ fn test_combined_file_set_unset() {
 
 #[test]
 fn test_single_name_value_pair() {
-    let out = new_ucmd!().arg("FOO=bar").run().stdout;
+    let out = new_ucmd!().arg("FOO=bar").run();
 
-    assert!(out.lines().any(|line| line == "FOO=bar"));
+    assert!(out.stdout_str().lines().any(|line| line == "FOO=bar"));
 }
 
 #[test]
 fn test_multiple_name_value_pairs() {
-    let out = new_ucmd!().arg("FOO=bar").arg("ABC=xyz").run().stdout;
+    let out = new_ucmd!().arg("FOO=bar").arg("ABC=xyz").run();
 
     assert_eq!(
-        out.lines()
+        out.stdout_str()
+            .lines()
             .filter(|&line| line == "FOO=bar" || line == "ABC=xyz")
             .count(),
         2
@@ -110,13 +102,8 @@ fn test_multiple_name_value_pairs() {
 fn test_ignore_environment() {
     let scene = TestScenario::new(util_name!());
 
-    let out = scene.ucmd().arg("-i").run().stdout;
-
-    assert_eq!(out, "");
-
-    let out = scene.ucmd().arg("-").run().stdout;
-
-    assert_eq!(out, "");
+    scene.ucmd().arg("-i").run().no_stdout();
+    scene.ucmd().arg("-").run().no_stdout();
 }
 
 #[test]
@@ -126,8 +113,8 @@ fn test_null_delimiter() {
         .arg("--null")
         .arg("FOO=bar")
         .arg("ABC=xyz")
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
 
     let mut vars: Vec<_> = out.split('\0').collect();
     assert_eq!(vars.len(), 3);
@@ -145,16 +132,19 @@ fn test_unset_variable() {
         .ucmd_keepenv()
         .arg("-u")
         .arg("HOME")
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
 
     assert_eq!(out.lines().any(|line| line.starts_with("HOME=")), false);
 }
 
 #[test]
 fn test_fail_null_with_program() {
-    let out = new_ucmd!().arg("--null").arg("cd").fails().stderr;
-    assert!(out.contains("cannot specify --null (-0) with command"));
+    new_ucmd!()
+        .arg("--null")
+        .arg("cd")
+        .fails()
+        .stderr_contains("cannot specify --null (-0) with command");
 }
 
 #[cfg(not(windows))]
@@ -173,8 +163,8 @@ fn test_change_directory() {
         .arg("--chdir")
         .arg(&temporary_path)
         .arg(pwd)
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
     assert_eq!(out.trim(), temporary_path.as_os_str())
 }
 
@@ -193,8 +183,8 @@ fn test_change_directory() {
         .ucmd()
         .arg("--chdir")
         .arg(&temporary_path)
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
     assert_eq!(
         out.lines()
             .any(|line| line.ends_with(temporary_path.file_name().unwrap().to_str().unwrap())),
@@ -214,6 +204,6 @@ fn test_fail_change_directory() {
         .arg(some_non_existing_path)
         .arg("pwd")
         .fails()
-        .stderr;
+        .stderr_move_str();
     assert!(out.contains("env: cannot change directory to "));
 }

tests/by-util/test_expand.rs

@@ -2,57 +2,54 @@ use crate::common::util::*;
 
 #[test]
 fn test_with_tab() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-tab.txt").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("        "));
-    assert!(!result.stdout.contains("\t"));
+    new_ucmd!()
+        .arg("with-tab.txt")
+        .succeeds()
+        .stdout_contains("        ")
+        .stdout_does_not_contain("\t");
 }
 
 #[test]
 fn test_with_trailing_tab() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-trailing-tab.txt").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("with tabs=>  "));
-    assert!(!result.stdout.contains("\t"));
+    new_ucmd!()
+        .arg("with-trailing-tab.txt")
+        .succeeds()
+        .stdout_contains("with tabs=>  ")
+        .stdout_does_not_contain("\t");
 }
 
 #[test]
 fn test_with_trailing_tab_i() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-trailing-tab.txt").arg("-i").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("        // with tabs=>\t"));
+    new_ucmd!()
+        .arg("with-trailing-tab.txt")
+        .arg("-i")
+        .succeeds()
+        .stdout_contains("        // with tabs=>\t");
 }
 
 #[test]
 fn test_with_tab_size() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-tab.txt").arg("--tabs=10").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("          "));
+    new_ucmd!()
+        .arg("with-tab.txt")
+        .arg("--tabs=10")
+        .succeeds()
+        .stdout_contains("          ");
 }
 
 #[test]
 fn test_with_space() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-spaces.txt").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("    return"));
+    new_ucmd!()
+        .arg("with-spaces.txt")
+        .succeeds()
+        .stdout_contains("    return");
 }
 
 #[test]
 fn test_with_multiple_files() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("with-spaces.txt").arg("with-tab.txt").run();
-    assert!(result.success);
-    assert!(result.stdout.contains("    return"));
-    assert!(result.stdout.contains("        "));
+    new_ucmd!()
+        .arg("with-spaces.txt")
+        .arg("with-tab.txt")
+        .succeeds()
+        .stdout_contains("    return")
+        .stdout_contains("        ");
 }

tests/by-util/test_expr.rs

@@ -17,11 +17,11 @@ fn test_complex_arithmetic() {
         .args(&["9223372036854775807", "+", "9223372036854775807"])
         .run();
     run.stdout_is("");
-    run.stderr_is("expr: error: +: Numerical result out of range");
+    run.stderr_is("expr: +: Numerical result out of range");
 
     let run = new_ucmd!().args(&["9", "/", "0"]).run();
     run.stdout_is("");
-    run.stderr_is("expr: error: division by zero");
+    run.stderr_is("expr: division by zero");
 }
 
 #[test]
@@ -54,3 +54,32 @@ fn test_and() {
 
     new_ucmd!().args(&["", "&", "1"]).run().stdout_is("0\n");
 }
+
+#[test]
+fn test_substr() {
+    new_ucmd!()
+        .args(&["substr", "abc", "1", "1"])
+        .succeeds()
+        .stdout_only("a\n");
+}
+
+#[test]
+fn test_invalid_substr() {
+    new_ucmd!()
+        .args(&["substr", "abc", "0", "1"])
+        .fails()
+        .status_code(1)
+        .stdout_only("\n");
+
+    new_ucmd!()
+        .args(&["substr", "abc", &(std::usize::MAX.to_string() + "0"), "1"])
+        .fails()
+        .status_code(1)
+        .stdout_only("\n");
+
+    new_ucmd!()
+        .args(&["substr", "abc", "0", &(std::usize::MAX.to_string() + "0")])
+        .fails()
+        .status_code(1)
+        .stdout_only("\n");
+}

tests/by-util/test_factor.rs

@@ -32,16 +32,25 @@ fn test_first_100000_integers() {
     }
 
     println!("STDIN='{}'", instring);
-    let result = new_ucmd!().pipe_in(instring.as_bytes()).run();
-    let stdout = result.stdout;
-
-    assert!(result.success);
+    let result = new_ucmd!().pipe_in(instring.as_bytes()).succeeds();
 
     // `seq 0 100000 | factor | sha1sum` => "4ed2d8403934fa1c76fe4b84c5d4b8850299c359"
-    let hash_check = sha1::Sha1::from(stdout.as_bytes()).hexdigest();
+    let hash_check = sha1::Sha1::from(result.stdout()).hexdigest();
     assert_eq!(hash_check, "4ed2d8403934fa1c76fe4b84c5d4b8850299c359");
 }
 
+#[test]
+fn test_cli_args() {
+    // Make sure that factor works with CLI arguments as well.
+    new_ucmd!().args(&["3"]).succeeds().stdout_contains("3: 3");
+
+    new_ucmd!()
+        .args(&["3", "6"])
+        .succeeds()
+        .stdout_contains("3: 3")
+        .stdout_contains("6: 2 3");
+}
+
 #[test]
 fn test_random() {
     use conv::prelude::*;

tests/by-util/test_fmt.rs

@@ -5,7 +5,7 @@ fn test_fmt() {
     let result = new_ucmd!().arg("one-word-per-line.txt").run();
     //.stdout_is_fixture("call_graph.expected");
     assert_eq!(
-        result.stdout.trim(),
+        result.stdout_str().trim(),
         "this is a file with one word per line"
     );
 }
@@ -15,7 +15,7 @@ fn test_fmt_q() {
     let result = new_ucmd!().arg("-q").arg("one-word-per-line.txt").run();
     //.stdout_is_fixture("call_graph.expected");
     assert_eq!(
-        result.stdout.trim(),
+        result.stdout_str().trim(),
         "this is a file with one word per line"
     );
 }
@@ -29,22 +29,20 @@ fn test_fmt_w_too_big() {
         .run();
     //.stdout_is_fixture("call_graph.expected");
     assert_eq!(
-        result.stderr.trim(),
-        "fmt: error: invalid width: '2501': Numerical result out of range"
+        result.stderr_str().trim(),
+        "fmt: invalid width: '2501': Numerical result out of range"
     );
 }
-/* #[test]
- Fails for now, see https://github.com/uutils/coreutils/issues/1501
+#[test]
 fn test_fmt_w() {
     let result = new_ucmd!()
         .arg("-w")
         .arg("10")
         .arg("one-word-per-line.txt")
         .run();
-        //.stdout_is_fixture("call_graph.expected");
-    assert_eq!(result.stdout.trim(), "this is a file with one word per line");
+    //.stdout_is_fixture("call_graph.expected");
+    assert_eq!(
+        result.stdout_str().trim(),
+        "this is\na file\nwith one\nword per\nline"
+    );
 }
-
-
-fmt is pretty broken in general, needs more works to have more tests
- */

tests/by-util/test_fold.rs

@@ -542,4 +542,4 @@ fn test_obsolete_syntax() {
         .arg("space_separated_words.txt")
         .succeeds()
         .stdout_is("test1\n \ntest2\n \ntest3\n \ntest4\n \ntest5\n \ntest6\n ");
-}
+}

tests/by-util/test_groups.rs

@@ -2,26 +2,25 @@ use crate::common::util::*;
 
 #[test]
 fn test_groups() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stdout.trim().is_empty() {
+    let result = new_ucmd!().run();
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
+    if is_ci() && result.stdout_str().trim().is_empty() {
         // In the CI, some server are failing to return the group.
         // As seems to be a configuration issue, ignoring it
         return;
     }
-    assert!(result.success);
-    assert!(!result.stdout.trim().is_empty());
+    result.success();
+    assert!(!result.stdout_str().trim().is_empty());
 }
 
 #[test]
 fn test_groups_arg() {
     // get the username with the "id -un" command
     let result = TestScenario::new("id").ucmd_keepenv().arg("-un").run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    let s1 = String::from(result.stdout.trim());
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
+    let s1 = String::from(result.stdout_str().trim());
     if is_ci() && s1.parse::<f64>().is_ok() {
         // In the CI, some server are failing to return id -un.
         // So, if we are getting a uid, just skip this test
@@ -29,18 +28,14 @@ fn test_groups_arg() {
         return;
     }
 
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    assert!(!result.stdout.is_empty());
-    let username = result.stdout.trim();
+    println!("result.stdout = {}", result.stdout_str());
+    println!("result.stderr = {}", result.stderr_str());
+    result.success();
+    assert!(!result.stdout_str().is_empty());
+    let username = result.stdout_str().trim();
 
     // call groups with the user name to check that we
     // are getting something
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg(username).run();
-    println!("result.stdout {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    assert!(!result.stdout.is_empty());
+    new_ucmd!().arg(username).succeeds();
+    assert!(!result.stdout_str().is_empty());
 }

tests/by-util/test_hashsum.rs

@@ -17,14 +17,14 @@ macro_rules! test_digest {
         fn test_single_file() {
             let ts = TestScenario::new("hashsum");
             assert_eq!(ts.fixtures.read(EXPECTED_FILE),
-                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("input.txt").succeeds().no_stderr().stdout));
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("input.txt").succeeds().no_stderr().stdout_str()));
         }
 
         #[test]
         fn test_stdin() {
             let ts = TestScenario::new("hashsum");
             assert_eq!(ts.fixtures.read(EXPECTED_FILE),
-                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).pipe_in_fixture("input.txt").succeeds().no_stderr().stdout));
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).pipe_in_fixture("input.txt").succeeds().no_stderr().stdout_str()));
         }
     }
     )*)

tests/by-util/test_head.rs

@@ -129,6 +129,15 @@ fn test_zero_terminated_syntax_2() {
         .stdout_is("x\0y");
 }
 
+#[test]
+fn test_zero_terminated_negative_lines() {
+    new_ucmd!()
+        .args(&["-z", "-n", "-1"])
+        .pipe_in("x\0y\0z\0")
+        .run()
+        .stdout_is("x\0y\0");
+}
+
 #[test]
 fn test_negative_byte_syntax() {
     new_ucmd!()
@@ -156,14 +165,22 @@ fn test_negative_zero_bytes() {
 }
 #[test]
 fn test_no_such_file_or_directory() {
-    let result = new_ucmd!().arg("no_such_file.toml").run();
+    new_ucmd!()
+        .arg("no_such_file.toml")
+        .fails()
+        .stderr_contains("cannot open 'no_such_file.toml' for reading: No such file or directory");
+}
 
-    assert_eq!(
-        true,
-        result
-            .stderr
-            .contains("cannot open 'no_such_file.toml' for reading: No such file or directory")
-    )
+/// Test that each non-existent files gets its own error message printed.
+#[test]
+fn test_multiple_nonexistent_files() {
+    new_ucmd!()
+        .args(&["bogusfile1", "bogusfile2"])
+        .fails()
+        .stdout_does_not_contain("==> bogusfile1 <==")
+        .stderr_contains("cannot open 'bogusfile1' for reading: No such file or directory")
+        .stdout_does_not_contain("==> bogusfile2 <==")
+        .stderr_contains("cannot open 'bogusfile2' for reading: No such file or directory");
 }
 
 // there was a bug not caught by previous tests
@@ -200,3 +217,28 @@ fn test_obsolete_extras() {
         .succeeds()
         .stdout_is("==> standard input <==\n1\02\03\04\05\0");
 }
+
+#[test]
+fn test_multiple_files() {
+    new_ucmd!()
+        .args(&["emptyfile.txt", "emptyfile.txt"])
+        .succeeds()
+        .stdout_is("==> emptyfile.txt <==\n\n==> emptyfile.txt <==\n");
+}
+
+#[test]
+fn test_multiple_files_with_stdin() {
+    new_ucmd!()
+        .args(&["emptyfile.txt", "-", "emptyfile.txt"])
+        .pipe_in("hello\n")
+        .succeeds()
+        .stdout_is(
+            "==> emptyfile.txt <==
+
+==> standard input <==
+hello
+
+==> emptyfile.txt <==
+",
+        );
+}

tests/by-util/test_hostid.rs

@@ -4,10 +4,6 @@ use self::regex::Regex;
 
 #[test]
 fn test_normal() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-
-    assert!(result.success);
     let re = Regex::new(r"^[0-9a-f]{8}").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+    new_ucmd!().succeeds().stdout_matches(&re);
 }

tests/by-util/test_hostname.rs

@@ -6,25 +6,25 @@ fn test_hostname() {
     let ls_short_res = new_ucmd!().arg("-s").succeeds();
     let ls_domain_res = new_ucmd!().arg("-d").succeeds();
 
-    assert!(ls_default_res.stdout.len() >= ls_short_res.stdout.len());
-    assert!(ls_default_res.stdout.len() >= ls_domain_res.stdout.len());
+    assert!(ls_default_res.stdout().len() >= ls_short_res.stdout().len());
+    assert!(ls_default_res.stdout().len() >= ls_domain_res.stdout().len());
 }
 
 // FixME: fails for "MacOS"
 #[cfg(not(target_vendor = "apple"))]
 #[test]
 fn test_hostname_ip() {
-    let result = new_ucmd!().arg("-i").run();
-    println!("{:#?}", result);
-    assert!(result.success);
-    assert!(!result.stdout.trim().is_empty());
+    let result = new_ucmd!().arg("-i").succeeds();
+    assert!(!result.stdout_str().trim().is_empty());
 }
 
 #[test]
 fn test_hostname_full() {
-    let result = new_ucmd!().arg("-f").succeeds();
-    assert!(!result.stdout.trim().is_empty());
-
     let ls_short_res = new_ucmd!().arg("-s").succeeds();
-    assert!(result.stdout.trim().contains(ls_short_res.stdout.trim()));
+    assert!(!ls_short_res.stdout_str().trim().is_empty());
+
+    new_ucmd!()
+        .arg("-f")
+        .succeeds()
+        .stdout_contains(ls_short_res.stdout_str().trim());
 }

tests/by-util/test_id.rs

@@ -1,93 +1,91 @@
 use crate::common::util::*;
 
+// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
+// If we are running inside the CI and "needle" is in "stderr" skipping this test is
+// considered okay. If we are not inside the CI this calls assert!(result.success).
+//
+// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
+// stderr: "whoami: cannot find name for user ID 1001"
+// Maybe: "adduser --uid 1001 username" can put things right?
+// stderr = id: Could not find uid 1001: No such id: 1001
+fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
+    if !result.succeeded() {
+        println!("result.stdout = {}", result.stdout_str());
+        println!("result.stderr = {}", result.stderr_str());
+        if is_ci() && result.stderr_str().contains(needle) {
+            println!("test skipped:");
+            return true;
+        } else {
+            result.success();
+        }
+    }
+    false
+}
+
 fn return_whoami_username() -> String {
     let scene = TestScenario::new("whoami");
     let result = scene.cmd("whoami").run();
-    if is_ci() && result.stderr.contains("cannot find name for user ID") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        println!("test skipped:");
         return String::from("");
     }
 
-    result.stdout.trim().to_string()
+    result.stdout_str().trim().to_string()
 }
 
 #[test]
 fn test_id() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("-u").run();
-    if result.stderr.contains("cannot find name for user ID") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
-        return;
-    }
-    assert!(result.success);
+    let result = scene.ucmd().arg("-u").succeeds();
+    let uid = result.stdout_str().trim();
 
-    let uid = String::from(result.stdout.trim());
-    result = scene.ucmd().run();
-    if is_ci() && result.stderr.contains("cannot find name for user ID") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let result = scene.ucmd().run();
+    if skipping_test_is_okay(&result, "Could not find uid") {
         return;
     }
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if !result.stderr.contains("Could not find uid") {
-        // Verify that the id found by --user/-u exists in the list
-        assert!(result.stdout.contains(&uid));
-    }
+
+    // Verify that the id found by --user/-u exists in the list
+    result.stdout_contains(uid);
 }
 
 #[test]
 fn test_id_from_name() {
     let username = return_whoami_username();
-    if username == "" {
-        // Sometimes, the CI is failing here
+    if username.is_empty() {
         return;
     }
 
     let scene = TestScenario::new(util_name!());
-    let result = scene.ucmd().arg(&username).succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let uid = String::from(result.stdout.trim());
-    let result = scene.ucmd().succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    // Verify that the id found by --user/-u exists in the list
-    assert!(result.stdout.contains(&uid));
-    // Verify that the username found by whoami exists in the list
-    assert!(result.stdout.contains(&username));
+    let result = scene.ucmd().arg(&username).run();
+    if skipping_test_is_okay(&result, "Could not find uid") {
+        return;
+    }
+
+    let uid = result.stdout_str().trim();
+
+    let result = scene.ucmd().run();
+    if skipping_test_is_okay(&result, "Could not find uid") {
+        return;
+    }
+
+    result
+        // Verify that the id found by --user/-u exists in the list
+        .stdout_contains(uid)
+        // Verify that the username found by whoami exists in the list
+        .stdout_contains(username);
 }
 
 #[test]
 fn test_id_name_from_id() {
-    let mut scene = TestScenario::new(util_name!());
-    let result = scene.ucmd().arg("-u").run();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let uid = String::from(result.stdout.trim());
+    let result = new_ucmd!().arg("-nu").run();
 
-    scene = TestScenario::new(util_name!());
-    let result = scene.ucmd().arg("-nu").arg(uid).run();
-    if is_ci() && result.stderr.contains("No such user/group") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let username_id = result.stdout_str().trim();
+
+    let username_whoami = return_whoami_username();
+    if username_whoami.is_empty() {
         return;
     }
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-
-    let username_id = String::from(result.stdout.trim());
-
-    scene = TestScenario::new("whoami");
-    let result = scene.cmd("whoami").run();
-
-    let username_whoami = result.stdout.trim();
 
     assert_eq!(username_id, username_whoami);
 }
@@ -97,17 +95,11 @@ fn test_id_group() {
     let scene = TestScenario::new(util_name!());
 
     let mut result = scene.ucmd().arg("-g").succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let s1 = String::from(result.stdout.trim());
+    let s1 = result.stdout_str().trim();
     assert!(s1.parse::<f64>().is_ok());
 
     result = scene.ucmd().arg("--group").succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let s1 = String::from(result.stdout.trim());
+    let s1 = result.stdout_str().trim();
     assert!(s1.parse::<f64>().is_ok());
 }
 
@@ -116,19 +108,13 @@ fn test_id_groups() {
     let scene = TestScenario::new(util_name!());
 
     let result = scene.ucmd().arg("-G").succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let groups = result.stdout.trim().split_whitespace();
+    let groups = result.stdout_str().trim().split_whitespace();
     for s in groups {
         assert!(s.parse::<f64>().is_ok());
     }
 
     let result = scene.ucmd().arg("--groups").succeeds();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    let groups = result.stdout.trim().split_whitespace();
+    let groups = result.stdout_str().trim().split_whitespace();
     for s in groups {
         assert!(s.parse::<f64>().is_ok());
     }
@@ -138,50 +124,46 @@ fn test_id_groups() {
 fn test_id_user() {
     let scene = TestScenario::new(util_name!());
 
-    let mut result = scene.ucmd().arg("-u").succeeds();
-    assert!(result.success);
-    let s1 = String::from(result.stdout.trim());
+    let result = scene.ucmd().arg("-u").succeeds();
+    let s1 = result.stdout_str().trim();
     assert!(s1.parse::<f64>().is_ok());
-    result = scene.ucmd().arg("--user").succeeds();
-    assert!(result.success);
-    let s1 = String::from(result.stdout.trim());
+
+    let result = scene.ucmd().arg("--user").succeeds();
+    let s1 = result.stdout_str().trim();
     assert!(s1.parse::<f64>().is_ok());
 }
 
 #[test]
 fn test_id_pretty_print() {
     let username = return_whoami_username();
-    if username == "" {
-        // Sometimes, the CI is failing here
+    if username.is_empty() {
         return;
     }
 
     let scene = TestScenario::new(util_name!());
     let result = scene.ucmd().arg("-p").run();
-    if result.stdout.trim() == "" {
-        // Sometimes, the CI is failing here with
-        // old rust versions on Linux
+    if result.stdout_str().trim().is_empty() {
+        // this fails only on: "MinRustV (ubuntu-latest, feat_os_unix)"
+        // `rustc 1.40.0 (73528e339 2019-12-16)`
+        // run: /home/runner/work/coreutils/coreutils/target/debug/coreutils id -p
+        // thread 'test_id::test_id_pretty_print' panicked at 'Command was expected to succeed.
+        // stdout =
+        // stderr = ', tests/common/util.rs:157:13
+        println!("test skipped:");
         return;
     }
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    assert!(result.stdout.contains(&username));
+
+    result.success().stdout_contains(username);
 }
 
 #[test]
 fn test_id_password_style() {
     let username = return_whoami_username();
-    if username == "" {
-        // Sometimes, the CI is failing here
+    if username.is_empty() {
         return;
     }
-    let scene = TestScenario::new(util_name!());
 
-    let result = scene.ucmd().arg("-P").succeeds();
+    let result = new_ucmd!().arg("-P").succeeds();
 
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    assert!(result.success);
-    assert!(result.stdout.starts_with(&username));
+    assert!(result.stdout_str().starts_with(&username));
 }

tests/by-util/test_install.rs

@@ -2,6 +2,8 @@ use crate::common::util::*;
 use filetime::FileTime;
 use rust_users::*;
 use std::os::unix::fs::PermissionsExt;
+#[cfg(not(windows))]
+use std::process::Command;
 #[cfg(target_os = "linux")]
 use std::thread::sleep;
 
@@ -9,12 +11,10 @@ use std::thread::sleep;
 fn test_install_help() {
     let (_, mut ucmd) = at_and_ucmd!();
 
-    assert!(ucmd
-        .arg("--help")
+    ucmd.arg("--help")
         .succeeds()
         .no_stderr()
-        .stdout
-        .contains("FLAGS:"));
+        .stdout_contains("FLAGS:");
 }
 
 #[test]
@@ -57,13 +57,11 @@ fn test_install_failing_not_dir() {
     at.touch(file1);
     at.touch(file2);
     at.touch(file3);
-    assert!(ucmd
-        .arg(file1)
+    ucmd.arg(file1)
         .arg(file2)
         .arg(file3)
         .fails()
-        .stderr
-        .contains("not a directory"));
+        .stderr_contains("not a directory");
 }
 
 #[test]
@@ -75,13 +73,11 @@ fn test_install_unimplemented_arg() {
 
     at.touch(file);
     at.mkdir(dir);
-    assert!(ucmd
-        .arg(context_arg)
+    ucmd.arg(context_arg)
         .arg(file)
         .arg(dir)
         .fails()
-        .stderr
-        .contains("Unimplemented"));
+        .stderr_contains("Unimplemented");
 
     assert!(!at.file_exists(&format!("{}/{}", dir, file)));
 }
@@ -193,12 +189,8 @@ fn test_install_mode_numeric() {
     let mode_arg = "-m 0333";
     at.mkdir(dir2);
 
-    let result = scene.ucmd().arg(mode_arg).arg(file).arg(dir2).run();
+    scene.ucmd().arg(mode_arg).arg(file).arg(dir2).succeeds();
 
-    println!("stderr = {:?}", result.stderr);
-    println!("stdout = {:?}", result.stdout);
-
-    assert!(result.success);
     let dest_file = &format!("{}/{}", dir2, file);
     assert!(at.file_exists(file));
     assert!(at.file_exists(dest_file));
@@ -233,13 +225,11 @@ fn test_install_mode_failing() {
 
     at.touch(file);
     at.mkdir(dir);
-    assert!(ucmd
-        .arg(file)
+    ucmd.arg(file)
         .arg(dir)
         .arg(mode_arg)
         .fails()
-        .stderr
-        .contains("Invalid mode string: invalid digit found in string"));
+        .stderr_contains("Invalid mode string: invalid digit found in string");
 
     let dest_file = &format!("{}/{}", dir, file);
     assert!(at.file_exists(file));
@@ -311,16 +301,13 @@ fn test_install_target_new_file_with_group() {
         .arg(format!("{}/{}", dir, file))
         .run();
 
-    println!("stderr = {:?}", result.stderr);
-    println!("stdout = {:?}", result.stdout);
-
-    if is_ci() && result.stderr.contains("error: no such group:") {
+    if is_ci() && result.stderr_str().contains("no such group:") {
         // In the CI, some server are failing to return the group.
         // As seems to be a configuration issue, ignoring it
         return;
     }
 
-    assert!(result.success);
+    result.success();
     assert!(at.file_exists(file));
     assert!(at.file_exists(&format!("{}/{}", dir, file)));
 }
@@ -341,16 +328,13 @@ fn test_install_target_new_file_with_owner() {
         .arg(format!("{}/{}", dir, file))
         .run();
 
-    println!("stderr = {:?}", result.stderr);
-    println!("stdout = {:?}", result.stdout);
-
-    if is_ci() && result.stderr.contains("error: no such user:") {
+    if is_ci() && result.stderr_str().contains("no such user:") {
         // In the CI, some server are failing to return the user id.
         // As seems to be a configuration issue, ignoring it
         return;
     }
 
-    assert!(result.success);
+    result.success();
     assert!(at.file_exists(file));
     assert!(at.file_exists(&format!("{}/{}", dir, file)));
 }
@@ -364,13 +348,10 @@ fn test_install_target_new_file_failing_nonexistent_parent() {
 
     at.touch(file1);
 
-    let err = ucmd
-        .arg(file1)
+    ucmd.arg(file1)
         .arg(format!("{}/{}", dir, file2))
         .fails()
-        .stderr;
-
-    assert!(err.contains("not a directory"))
+        .stderr_contains(&"No such file or directory");
 }
 
 #[test]
@@ -415,18 +396,12 @@ fn test_install_copy_file() {
 #[test]
 #[cfg(target_os = "linux")]
 fn test_install_target_file_dev_null() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
+    let (at, mut ucmd) = at_and_ucmd!();
 
     let file1 = "/dev/null";
     let file2 = "target_file";
 
-    let result = scene.ucmd().arg(file1).arg(file2).run();
-
-    println!("stderr = {:?}", result.stderr);
-    println!("stdout = {:?}", result.stdout);
-
-    assert!(result.success);
+    ucmd.arg(file1).arg(file2).succeeds();
 
     assert!(at.file_exists(file2));
 }
@@ -460,9 +435,12 @@ fn test_install_failing_omitting_directory() {
     at.mkdir(dir2);
     at.touch(file1);
 
-    let r = ucmd.arg(dir1).arg(file1).arg(dir2).run();
-    assert!(r.code == Some(1));
-    assert!(r.stderr.contains("omitting directory"));
+    ucmd.arg(dir1)
+        .arg(file1)
+        .arg(dir2)
+        .fails()
+        .code_is(1)
+        .stderr_contains("omitting directory");
 }
 
 #[test]
@@ -475,9 +453,12 @@ fn test_install_failing_no_such_file() {
     at.mkdir(dir1);
     at.touch(file1);
 
-    let r = ucmd.arg(file1).arg(file2).arg(dir1).run();
-    assert!(r.code == Some(1));
-    assert!(r.stderr.contains("No such file or directory"));
+    ucmd.arg(file1)
+        .arg(file2)
+        .arg(dir1)
+        .fails()
+        .code_is(1)
+        .stderr_contains("No such file or directory");
 }
 
 #[test]
@@ -566,3 +547,128 @@ fn test_install_copy_then_compare_file_with_extra_mode() {
 
     assert!(after_install_sticky != after_install_sticky_again);
 }
+
+const STRIP_TARGET_FILE: &str = "helloworld_installed";
+const SYMBOL_DUMP_PROGRAM: &str = "objdump";
+const STRIP_SOURCE_FILE_SYMBOL: &str = "main";
+
+fn strip_source_file() -> &'static str {
+    if cfg!(target_os = "macos") {
+        "helloworld_macos"
+    } else {
+        "helloworld_linux"
+    }
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_install_and_strip() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg(strip_source_file())
+        .arg(STRIP_TARGET_FILE)
+        .succeeds()
+        .no_stderr();
+
+    let output = Command::new(SYMBOL_DUMP_PROGRAM)
+        .arg("-t")
+        .arg(at.plus(STRIP_TARGET_FILE))
+        .output()
+        .unwrap();
+
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    assert!(!stdout.contains(STRIP_SOURCE_FILE_SYMBOL));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_install_and_strip_with_program() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("/usr/bin/strip")
+        .arg(strip_source_file())
+        .arg(STRIP_TARGET_FILE)
+        .succeeds()
+        .no_stderr();
+
+    let output = Command::new(SYMBOL_DUMP_PROGRAM)
+        .arg("-t")
+        .arg(at.plus(STRIP_TARGET_FILE))
+        .output()
+        .unwrap();
+
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    assert!(!stdout.contains(STRIP_SOURCE_FILE_SYMBOL));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_install_and_strip_with_invalid_program() {
+    new_ucmd!()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("/bin/date")
+        .arg(strip_source_file())
+        .arg(STRIP_TARGET_FILE)
+        .fails()
+        .stderr_contains("strip program failed");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_install_and_strip_with_non_existent_program() {
+    new_ucmd!()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("/usr/bin/non_existent_program")
+        .arg(strip_source_file())
+        .arg(STRIP_TARGET_FILE)
+        .fails()
+        .stderr_contains("No such file or directory");
+}
+
+#[test]
+fn test_install_creating_leading_dirs() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source = "create_leading_test_file";
+    let target = "dir1/dir2/dir3/test_file";
+
+    at.touch(source);
+
+    scene
+        .ucmd()
+        .arg("-D")
+        .arg(source)
+        .arg(at.plus(target))
+        .succeeds()
+        .no_stderr();
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_install_creating_leading_dir_fails_on_long_name() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source = "create_leading_test_file";
+    let target = format!("{}/test_file", "d".repeat(libc::PATH_MAX as usize + 1));
+
+    at.touch(source);
+
+    scene
+        .ucmd()
+        .arg("-D")
+        .arg(source)
+        .arg(at.plus(target.as_str()))
+        .fails()
+        .stderr_contains("failed to create");
+}

tests/by-util/test_join.rs

@@ -148,7 +148,7 @@ fn multitab_character() {
         .arg("-t")
         .arg("э")
         .fails()
-        .stderr_is("join: error: multi-character tab э");
+        .stderr_is("join: multi-character tab э");
 }
 
 #[test]
@@ -211,7 +211,7 @@ fn empty_format() {
         .arg("-o")
         .arg("")
         .fails()
-        .stderr_is("join: error: invalid file number in field spec: ''");
+        .stderr_is("join: invalid file number in field spec: ''");
 }
 
 #[test]

tests/by-util/test_kill.rs

@@ -1 +1,126 @@
-// ToDO: add tests
+use crate::common::util::*;
+use regex::Regex;
+use std::os::unix::process::ExitStatusExt;
+use std::process::{Child, Command};
+
+// A child process the tests will try to kill.
+struct Target {
+    child: Child,
+    killed: bool,
+}
+
+impl Target {
+    // Creates a target that will naturally die after some time if not killed
+    // fast enough.
+    // This timeout avoids hanging failing tests.
+    fn new() -> Target {
+        Target {
+            child: Command::new("sleep")
+                .arg("30")
+                .spawn()
+                .expect("cannot spawn target"),
+            killed: false,
+        }
+    }
+
+    // Waits for the target to complete and returns the signal it received if any.
+    fn wait_for_signal(&mut self) -> Option<i32> {
+        let sig = self.child.wait().expect("cannot wait on target").signal();
+        self.killed = true;
+        sig
+    }
+
+    fn pid(&self) -> u32 {
+        self.child.id()
+    }
+}
+
+impl Drop for Target {
+    // Terminates this target to avoid littering test boxes with zombi processes
+    // when a test fails after creating a target but before killing it.
+    fn drop(&mut self) {
+        if !self.killed {
+            self.child.kill().expect("cannot kill target");
+        }
+    }
+}
+
+#[test]
+fn test_kill_list_all_signals() {
+    // Check for a few signals.  Do not try to be comprehensive.
+    new_ucmd!()
+        .arg("-l")
+        .succeeds()
+        .stdout_contains("KILL")
+        .stdout_contains("TERM")
+        .stdout_contains("HUP");
+}
+
+#[test]
+fn test_kill_list_all_signals_as_table() {
+    // Check for a few signals.  Do not try to be comprehensive.
+    new_ucmd!()
+        .arg("-t")
+        .succeeds()
+        .stdout_contains("KILL")
+        .stdout_contains("TERM")
+        .stdout_contains("HUP");
+}
+
+#[test]
+fn test_kill_list_one_signal_from_name() {
+    // Use SIGKILL because it is 9 on all unixes.
+    new_ucmd!()
+        .arg("-l")
+        .arg("KILL")
+        .succeeds()
+        .stdout_matches(&Regex::new("\\b9\\b").unwrap());
+}
+
+#[test]
+fn test_kill_set_bad_signal_name() {
+    new_ucmd!()
+        .arg("-s")
+        .arg("IAMNOTASIGNAL")
+        .fails()
+        .stderr_contains("unknown signal");
+}
+
+#[test]
+fn test_kill_with_default_signal() {
+    let mut target = Target::new();
+    new_ucmd!().arg(format!("{}", target.pid())).succeeds();
+    assert_eq!(target.wait_for_signal(), Some(libc::SIGTERM));
+}
+
+#[test]
+fn test_kill_with_signal_number_old_form() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-9")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(9));
+}
+
+#[test]
+fn test_kill_with_signal_number_new_form() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("9")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(9));
+}
+
+#[test]
+fn test_kill_with_signal_name_new_form() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("KILL")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+}

tests/by-util/test_link.rs

@@ -23,7 +23,7 @@ fn test_link_no_circular() {
 
     ucmd.args(&[link, link])
         .fails()
-        .stderr_is("link: error: No such file or directory (os error 2)\n");
+        .stderr_is("link: No such file or directory (os error 2)\n");
     assert!(!at.file_exists(link));
 }
 
@@ -35,7 +35,29 @@ fn test_link_nonexistent_file() {
 
     ucmd.args(&[file, link])
         .fails()
-        .stderr_is("link: error: No such file or directory (os error 2)\n");
+        .stderr_is("link: No such file or directory (os error 2)\n");
     assert!(!at.file_exists(file));
     assert!(!at.file_exists(link));
 }
+
+#[test]
+fn test_link_one_argument() {
+    let (_, mut ucmd) = at_and_ucmd!();
+    let file = "test_link_argument";
+    ucmd.args(&[file]).fails().stderr_contains(
+        "error: The argument '<FILES>...' requires at least 2 values, but only 1 was provide",
+    );
+}
+
+#[test]
+fn test_link_three_arguments() {
+    let (_, mut ucmd) = at_and_ucmd!();
+    let arguments = vec![
+        "test_link_argument1",
+        "test_link_argument2",
+        "test_link_argument3",
+    ];
+    ucmd.args(&arguments[..]).fails().stderr_contains(
+        format!("error: The value '{}' was provided to '<FILES>...', but it wasn't expecting any more values", arguments[2]),
+    );
+}

tests/by-util/test_ln.rs

@@ -299,13 +299,11 @@ fn test_symlink_overwrite_dir_fail() {
     at.touch(path_a);
     at.mkdir(path_b);
 
-    assert!(
-        ucmd.args(&["-s", "-T", path_a, path_b])
-            .fails()
-            .stderr
-            .len()
-            > 0
-    );
+    assert!(!ucmd
+        .args(&["-s", "-T", path_a, path_b])
+        .fails()
+        .stderr_str()
+        .is_empty());
 }
 
 #[test]
@@ -358,7 +356,11 @@ fn test_symlink_target_only() {
 
     at.mkdir(dir);
 
-    assert!(ucmd.args(&["-s", "-t", dir]).fails().stderr.len() > 0);
+    assert!(!ucmd
+        .args(&["-s", "-t", dir])
+        .fails()
+        .stderr_str()
+        .is_empty());
 }
 
 #[test]
@@ -407,7 +409,7 @@ fn test_symlink_missing_destination() {
     at.touch(file);
 
     ucmd.args(&["-s", "-T", file]).fails().stderr_is(format!(
-        "ln: error: missing destination file operand after '{}'",
+        "ln: missing destination file operand after '{}'",
         file
     ));
 }
@@ -520,10 +522,7 @@ fn test_symlink_no_deref_dir() {
     scene.ucmd().args(&["-sn", dir1, link]).fails();
 
     // Try with the no-deref
-    let result = scene.ucmd().args(&["-sfn", dir1, link]).run();
-    println!("stdout {}", result.stdout);
-    println!("stderr {}", result.stderr);
-    assert!(result.success);
+    scene.ucmd().args(&["-sfn", dir1, link]).succeeds();
     assert!(at.dir_exists(dir1));
     assert!(at.dir_exists(dir2));
     assert!(at.is_symlink(link));
@@ -566,10 +565,7 @@ fn test_symlink_no_deref_file() {
     scene.ucmd().args(&["-sn", file1, link]).fails();
 
     // Try with the no-deref
-    let result = scene.ucmd().args(&["-sfn", file1, link]).run();
-    println!("stdout {}", result.stdout);
-    println!("stderr {}", result.stderr);
-    assert!(result.success);
+    scene.ucmd().args(&["-sfn", file1, link]).succeeds();
     assert!(at.file_exists(file1));
     assert!(at.file_exists(file2));
     assert!(at.is_symlink(link));

tests/by-util/test_logname.rs

@@ -3,23 +3,19 @@ use std::env;
 
 #[test]
 fn test_normal() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.run();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
+    let result = new_ucmd!().run();
     println!("env::var(CI).is_ok() = {}", env::var("CI").is_ok());
 
     for (key, value) in env::vars() {
         println!("{}: {}", key, value);
     }
-    if (is_ci() || is_wsl()) && result.stderr.contains("error: no login name") {
+    if (is_ci() || uucore::os::is_wsl_1()) && result.stderr_str().contains("no login name") {
         // ToDO: investigate WSL failure
         // In the CI, some server are failing to return logname.
         // As seems to be a configuration issue, ignoring it
         return;
     }
 
-    assert!(result.success);
-    assert!(!result.stdout.trim().is_empty());
+    result.success();
+    assert!(!result.stdout_str().trim().is_empty());
 }

tests/by-util/test_ls.rs

@@ -5,6 +5,8 @@ use crate::common::util::*;
 extern crate regex;
 use self::regex::Regex;
 
+use std::collections::HashMap;
+use std::path::Path;
 use std::thread::sleep;
 use std::time::Duration;
 
@@ -17,9 +19,7 @@ use std::path::PathBuf;
 #[cfg(not(windows))]
 use std::sync::Mutex;
 #[cfg(not(windows))]
-extern crate tempdir;
-#[cfg(not(windows))]
-use self::tempdir::TempDir;
+extern crate tempfile;
 
 #[cfg(not(windows))]
 lazy_static! {
@@ -42,23 +42,74 @@ fn test_ls_a() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.touch(".test-1");
+    at.mkdir("some-dir");
+    at.touch(
+        Path::new("some-dir")
+            .join(".test-2")
+            .as_os_str()
+            .to_str()
+            .unwrap(),
+    );
 
-    let result = scene.ucmd().succeeds();
-    let stdout = result.stdout_str();
-    assert!(!stdout.contains(".test-1"));
-    assert!(!stdout.contains(".."));
+    let re_pwd = Regex::new(r"^\.\n").unwrap();
+
+    // Using the present working directory
+    scene
+        .ucmd()
+        .arg("-1")
+        .succeeds()
+        .stdout_does_not_contain(".test-1")
+        .stdout_does_not_contain("..")
+        .stdout_does_not_match(&re_pwd);
 
     scene
         .ucmd()
         .arg("-a")
+        .arg("-1")
         .succeeds()
         .stdout_contains(&".test-1")
-        .stdout_contains(&"..");
+        .stdout_contains(&"..")
+        .stdout_matches(&re_pwd);
 
-    let result = scene.ucmd().arg("-A").succeeds();
-    result.stdout_contains(".test-1");
-    let stdout = result.stdout_str();
-    assert!(!stdout.contains(".."));
+    scene
+        .ucmd()
+        .arg("-A")
+        .arg("-1")
+        .succeeds()
+        .stdout_contains(".test-1")
+        .stdout_does_not_contain("..")
+        .stdout_does_not_match(&re_pwd);
+
+    // Using a subdirectory
+    scene
+        .ucmd()
+        .arg("-1")
+        .arg("some-dir")
+        .succeeds()
+        .stdout_does_not_contain(".test-2")
+        .stdout_does_not_contain("..")
+        .stdout_does_not_match(&re_pwd);
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("-1")
+        .arg("some-dir")
+        .succeeds()
+        .stdout_contains(&".test-2")
+        .stdout_contains(&"..")
+        .no_stderr()
+        .stdout_matches(&re_pwd);
+
+    scene
+        .ucmd()
+        .arg("-A")
+        .arg("-1")
+        .arg("some-dir")
+        .succeeds()
+        .stdout_contains(".test-2")
+        .stdout_does_not_contain("..")
+        .stdout_does_not_match(&re_pwd);
 }
 
 #[test]
@@ -102,6 +153,20 @@ fn test_ls_width() {
             .succeeds()
             .stdout_only("test-width-1\ntest-width-2\ntest-width-3\ntest-width-4\n");
     }
+
+    scene
+        .ucmd()
+        .arg("-w=bad")
+        .fails()
+        .stderr_contains("invalid line width");
+
+    for option in &["-w 1a", "-w=1a", "--width=1a", "--width 1a"] {
+        scene
+            .ucmd()
+            .args(&option.split(" ").collect::<Vec<_>>())
+            .fails()
+            .stderr_only("ls: invalid line width: ‘1a’");
+    }
 }
 
 #[test]
@@ -242,6 +307,50 @@ fn test_ls_long() {
     }
 }
 
+#[test]
+fn test_ls_long_total_size() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(&at.plus_as_string("test-long"));
+    at.append("test-long", "1");
+    at.touch(&at.plus_as_string("test-long2"));
+    at.append("test-long2", "2");
+
+    let expected_prints: HashMap<_, _> = if cfg!(unix) {
+        [
+            ("long_vanilla", "total 8"),
+            ("long_human_readable", "total 8.0K"),
+            ("long_si", "total 8.2k"),
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    } else {
+        [
+            ("long_vanilla", "total 2"),
+            ("long_human_readable", "total 2"),
+            ("long_si", "total 2"),
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    };
+
+    for arg in &["-l", "--long", "--format=long", "--format=verbose"] {
+        let result = scene.ucmd().arg(arg).succeeds();
+        result.stdout_contains(expected_prints["long_vanilla"]);
+
+        for arg2 in &["-h", "--human-readable", "--si"] {
+            let result = scene.ucmd().arg(arg).arg(arg2).succeeds();
+            result.stdout_contains(if *arg2 == "--si" {
+                expected_prints["long_si"]
+            } else {
+                expected_prints["long_human_readable"]
+            });
+        }
+    }
+}
+
 #[test]
 fn test_ls_long_formats() {
     let scene = TestScenario::new(util_name!());
@@ -435,6 +544,53 @@ fn test_ls_deref() {
     assert!(!re.is_match(result.stdout_str().trim()));
 }
 
+#[test]
+fn test_ls_sort_none() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("test-3");
+    at.touch("test-1");
+    at.touch("test-2");
+
+    // Order is not specified so we just check that it doesn't
+    // give any errors.
+    scene.ucmd().arg("--sort=none").succeeds();
+    scene.ucmd().arg("-U").succeeds();
+}
+
+#[test]
+fn test_ls_sort_name() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("test-3");
+    at.touch("test-1");
+    at.touch("test-2");
+
+    let sep = if cfg!(unix) { "\n" } else { "  " };
+
+    scene
+        .ucmd()
+        .arg("--sort=name")
+        .succeeds()
+        .stdout_is(["test-1", "test-2", "test-3\n"].join(sep));
+
+    let scene_dot = TestScenario::new(util_name!());
+    let at = &scene_dot.fixtures;
+    at.touch(".a");
+    at.touch("a");
+    at.touch(".b");
+    at.touch("b");
+
+    scene_dot
+        .ucmd()
+        .arg("--sort=name")
+        .arg("-A")
+        .succeeds()
+        .stdout_is([".a", ".b", "a", "b\n"].join(sep));
+}
+
 #[test]
 fn test_ls_order_size() {
     let scene = TestScenario::new(util_name!());
@@ -463,6 +619,18 @@ fn test_ls_order_size() {
     result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
     #[cfg(windows)]
     result.stdout_only("test-1  test-2  test-3  test-4\n");
+
+    let result = scene.ucmd().arg("--sort=size").succeeds();
+    #[cfg(not(windows))]
+    result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+    #[cfg(windows)]
+    result.stdout_only("test-4  test-3  test-2  test-1\n");
+
+    let result = scene.ucmd().arg("--sort=size").arg("-r").succeeds();
+    #[cfg(not(windows))]
+    result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
+    #[cfg(windows)]
+    result.stdout_only("test-1  test-2  test-3  test-4\n");
 }
 
 #[test]
@@ -471,13 +639,123 @@ fn test_ls_long_ctime() {
     let at = &scene.fixtures;
 
     at.touch("test-long-ctime-1");
-    let result = scene.ucmd().arg("-lc").succeeds();
 
-    // Should show the time on Unix, but question marks on windows.
-    #[cfg(unix)]
-    result.stdout_contains(":");
-    #[cfg(not(unix))]
-    result.stdout_contains("???");
+    for arg in &["-c", "--time=ctime", "--time=status"] {
+        let result = scene.ucmd().arg("-l").arg(arg).succeeds();
+
+        // Should show the time on Unix, but question marks on windows.
+        #[cfg(unix)]
+        result.stdout_contains(":");
+        #[cfg(not(unix))]
+        result.stdout_contains("???");
+    }
+}
+
+#[test]
+#[ignore]
+fn test_ls_order_birthtime() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    /*
+        Here we make 2 files with a timeout in between.
+        After creating the first file try to sync it.
+        This ensures the file gets created immediately instead of being saved
+        inside the OS's IO operation buffer.
+        Without this, both files might accidentally be created at the same time.
+    */
+    at.make_file("test-birthtime-1").sync_all().unwrap();
+    at.make_file("test-birthtime-2").sync_all().unwrap();
+    at.open("test-birthtime-1");
+
+    let result = scene.ucmd().arg("--time=birth").arg("-t").run();
+
+    #[cfg(not(windows))]
+    assert_eq!(result.stdout_str(), "test-birthtime-2\ntest-birthtime-1\n");
+    #[cfg(windows)]
+    assert_eq!(result.stdout_str(), "test-birthtime-2  test-birthtime-1\n");
+}
+
+#[test]
+fn test_ls_styles() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("test");
+
+    let re_full = Regex::new(
+        r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d* (\+|\-)\d{4} test\n",
+    )
+    .unwrap();
+    let re_long =
+        Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+    let re_iso = Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+    let re_locale =
+        Regex::new(r"[a-z-]* \d* \w* \w* \d* [A-Z][a-z]{2} ( |\d)\d \d{2}:\d{2} test\n").unwrap();
+
+    //full-iso
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=full-iso")
+        .succeeds();
+    assert!(re_full.is_match(&result.stdout_str()));
+    //long-iso
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=long-iso")
+        .succeeds();
+    assert!(re_long.is_match(&result.stdout_str()));
+    //iso
+    let result = scene.ucmd().arg("-l").arg("--time-style=iso").succeeds();
+    assert!(re_iso.is_match(&result.stdout_str()));
+    //locale
+    let result = scene.ucmd().arg("-l").arg("--time-style=locale").succeeds();
+    assert!(re_locale.is_match(&result.stdout_str()));
+
+    //Overwrite options tests
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=long-iso")
+        .arg("--time-style=iso")
+        .succeeds();
+    assert!(re_iso.is_match(&result.stdout_str()));
+    let result = scene
+        .ucmd()
+        .arg("--time-style=iso")
+        .arg("--full-time")
+        .succeeds();
+    assert!(re_full.is_match(&result.stdout_str()));
+    let result = scene
+        .ucmd()
+        .arg("--full-time")
+        .arg("--time-style=iso")
+        .succeeds();
+    assert!(re_iso.is_match(&result.stdout_str()));
+
+    let result = scene
+        .ucmd()
+        .arg("--full-time")
+        .arg("--time-style=iso")
+        .arg("--full-time")
+        .succeeds();
+    assert!(re_full.is_match(&result.stdout_str()));
+
+    let result = scene
+        .ucmd()
+        .arg("--full-time")
+        .arg("-x")
+        .arg("-l")
+        .succeeds();
+    assert!(re_full.is_match(&result.stdout_str()));
+
+    at.touch("test2");
+    let result = scene.ucmd().arg("--full-time").arg("-x").succeeds();
+    #[cfg(not(windows))]
+    assert_eq!(result.stdout_str(), "test\ntest2\n");
+    #[cfg(windows)]
+    assert_eq!(result.stdout_str(), "test  test2\n");
 }
 
 #[test]
@@ -518,32 +796,46 @@ fn test_ls_order_time() {
     #[cfg(windows)]
     result.stdout_only("test-4  test-3  test-2  test-1\n");
 
+    let result = scene.ucmd().arg("--sort=time").succeeds();
+    #[cfg(not(windows))]
+    result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+    #[cfg(windows)]
+    result.stdout_only("test-4  test-3  test-2  test-1\n");
+
     let result = scene.ucmd().arg("-tr").succeeds();
     #[cfg(not(windows))]
     result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
     #[cfg(windows)]
     result.stdout_only("test-1  test-2  test-3  test-4\n");
 
+    let result = scene.ucmd().arg("--sort=time").arg("-r").succeeds();
+    #[cfg(not(windows))]
+    result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
+    #[cfg(windows)]
+    result.stdout_only("test-1  test-2  test-3  test-4\n");
+
     // 3 was accessed last in the read
     // So the order should be 2 3 4 1
-    let result = scene.ucmd().arg("-tu").succeeds();
-    let file3_access = at.open("test-3").metadata().unwrap().accessed().unwrap();
-    let file4_access = at.open("test-4").metadata().unwrap().accessed().unwrap();
+    for arg in &["-u", "--time=atime", "--time=access", "--time=use"] {
+        let result = scene.ucmd().arg("-t").arg(arg).succeeds();
+        let file3_access = at.open("test-3").metadata().unwrap().accessed().unwrap();
+        let file4_access = at.open("test-4").metadata().unwrap().accessed().unwrap();
 
-    // It seems to be dependent on the platform whether the access time is actually set
-    if file3_access > file4_access {
-        if cfg!(not(windows)) {
-            result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
+        // It seems to be dependent on the platform whether the access time is actually set
+        if file3_access > file4_access {
+            if cfg!(not(windows)) {
+                result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
+            } else {
+                result.stdout_only("test-3  test-4  test-2  test-1\n");
+            }
         } else {
-            result.stdout_only("test-3  test-4  test-2  test-1\n");
-        }
-    } else {
-        // Access time does not seem to be set on Windows and some other
-        // systems so the order is 4 3 2 1
-        if cfg!(not(windows)) {
-            result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
-        } else {
-            result.stdout_only("test-4  test-3  test-2  test-1\n");
+            // Access time does not seem to be set on Windows and some other
+            // systems so the order is 4 3 2 1
+            if cfg!(not(windows)) {
+                result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+            } else {
+                result.stdout_only("test-4  test-3  test-2  test-1\n");
+            }
         }
     }
 
@@ -581,7 +873,7 @@ fn test_ls_files_dirs() {
         .ucmd()
         .arg("doesntexist")
         .fails()
-        .stderr_contains(&"error: 'doesntexist': No such file or directory");
+        .stderr_contains(&"'doesntexist': No such file or directory");
 
     // One exists, the other doesn't
     scene
@@ -589,7 +881,7 @@ fn test_ls_files_dirs() {
         .arg("a")
         .arg("doesntexist")
         .fails()
-        .stderr_contains(&"error: 'doesntexist': No such file or directory")
+        .stderr_contains(&"'doesntexist': No such file or directory")
         .stdout_contains(&"a:");
 }
 
@@ -620,20 +912,27 @@ fn test_ls_recursive() {
     result.stdout_contains(&"a\\b:\nb");
 }
 
-#[cfg(unix)]
 #[test]
-fn test_ls_ls_color() {
+fn test_ls_color() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.mkdir("a");
-    at.mkdir("a/nested_dir");
+    let nested_dir = Path::new("a")
+        .join("nested_dir")
+        .to_string_lossy()
+        .to_string();
+    at.mkdir(&nested_dir);
     at.mkdir("z");
-    at.touch(&at.plus_as_string("a/nested_file"));
+    let nested_file = Path::new("a")
+        .join("nested_file")
+        .to_string_lossy()
+        .to_string();
+    at.touch(&nested_file);
     at.touch("test-color");
 
-    let a_with_colors = "\x1b[01;34ma\x1b[0m";
-    let z_with_colors = "\x1b[01;34mz\x1b[0m";
-    let nested_dir_with_colors = "\x1b[01;34mnested_dir\x1b[0m";
+    let a_with_colors = "\x1b[1;34ma\x1b[0m";
+    let z_with_colors = "\x1b[1;34mz\x1b[0m";
+    let nested_dir_with_colors = "\x1b[1;34mnested_dir\x1b[0m";
 
     // Color is disabled by default
     let result = scene.ucmd().succeeds();
@@ -669,14 +968,6 @@ fn test_ls_ls_color() {
         .succeeds()
         .stdout_contains(nested_dir_with_colors);
 
-    // Color has no effect
-    scene
-        .ucmd()
-        .arg("--color=always")
-        .arg("a/nested_file")
-        .succeeds()
-        .stdout_contains("a/nested_file\n");
-
     // No output
     scene
         .ucmd()
@@ -684,6 +975,18 @@ fn test_ls_ls_color() {
         .arg("z")
         .succeeds()
         .stdout_only("");
+
+    // The colors must not mess up the grid layout
+    at.touch("b");
+    scene
+        .ucmd()
+        .arg("--color")
+        .arg("-w=15")
+        .succeeds()
+        .stdout_only(format!(
+            "{}  test-color\nb  {}\n",
+            a_with_colors, z_with_colors
+        ));
 }
 
 #[cfg(unix)]
@@ -782,7 +1085,7 @@ fn test_ls_indicator_style() {
     {
         use self::unix_socket::UnixListener;
 
-        let dir = TempDir::new("unix_socket").expect("failed to create dir");
+        let dir = tempfile::Builder::new().prefix("unix_socket").tempdir().expect("failed to create dir");
         let socket_path = dir.path().join("sock");
         let _listener = UnixListener::bind(&socket_path).expect("failed to create socket");
 
@@ -816,7 +1119,7 @@ fn test_ls_indicator_style() {
     let options = vec!["classify", "file-type", "slash"];
     for opt in options {
         // Verify that classify and file-type both contain indicators for symlinks.
-        let result = scene
+        scene
             .ucmd()
             .arg(format!("--indicator-style={}", opt))
             .succeeds()
@@ -826,7 +1129,7 @@ fn test_ls_indicator_style() {
     // Same test as above, but with the alternate flags.
     let options = vec!["--classify", "--file-type", "-p"];
     for opt in options {
-        let result = scene
+        scene
             .ucmd()
             .arg(format!("{}", opt))
             .succeeds()
@@ -837,7 +1140,7 @@ fn test_ls_indicator_style() {
     let options = vec!["classify", "file-type"];
     for opt in options {
         // Verify that classify and file-type both contain indicators for symlinks.
-        let result = scene
+        scene
             .ucmd()
             .arg(format!("--indicator-style={}", opt))
             .succeeds()
@@ -961,7 +1264,7 @@ fn test_ls_hidden_windows() {
 
     let result = scene.ucmd().succeeds();
     assert!(!result.stdout_str().contains(file));
-    let result = scene.ucmd().arg("-a").succeeds().stdout_contains(file);
+    scene.ucmd().arg("-a").succeeds().stdout_contains(file);
 }
 
 #[test]
@@ -1051,9 +1354,11 @@ fn test_ls_quoting_style() {
     at.touch("one");
 
     // It seems that windows doesn't allow \n in filenames.
+    // And it also doesn't like \, of course.
     #[cfg(unix)]
     {
         at.touch("one\ntwo");
+        at.touch("one\\two");
         // Default is shell-escape
         scene
             .ucmd()
@@ -1115,6 +1420,42 @@ fn test_ls_quoting_style() {
                 .succeeds()
                 .stdout_only(format!("{}\n", correct));
         }
+
+        for (arg, correct) in &[
+            ("--quoting-style=literal", "one\\two"),
+            ("-N", "one\\two"),
+            ("--quoting-style=c", "\"one\\\\two\""),
+            ("-Q", "\"one\\\\two\""),
+            ("--quote-name", "\"one\\\\two\""),
+            ("--quoting-style=escape", "one\\\\two"),
+            ("-b", "one\\\\two"),
+            ("--quoting-style=shell-escape", "'one\\two'"),
+            ("--quoting-style=shell-escape-always", "'one\\two'"),
+            ("--quoting-style=shell", "'one\\two'"),
+            ("--quoting-style=shell-always", "'one\\two'"),
+        ] {
+            scene
+                .ucmd()
+                .arg(arg)
+                .arg("one\\two")
+                .succeeds()
+                .stdout_only(format!("{}\n", correct));
+        }
+
+        // Tests for a character that forces quotation in shell-style escaping
+        // after a character in a dollar expression
+        at.touch("one\n&two");
+        for (arg, correct) in &[
+            ("--quoting-style=shell-escape", "'one'$'\\n''&two'"),
+            ("--quoting-style=shell-escape-always", "'one'$'\\n''&two'"),
+        ] {
+            scene
+                .ucmd()
+                .arg(arg)
+                .arg("one\n&two")
+                .succeeds()
+                .stdout_only(format!("{}\n", correct));
+        }
     }
 
     scene
@@ -1314,3 +1655,357 @@ fn test_ls_ignore_hide() {
         .stderr_contains(&"Invalid pattern")
         .stdout_is("CONTRIBUTING.md\nREADME.md\nREADMECAREFULLY.md\nsome_other_file\n");
 }
+
+#[test]
+fn test_ls_ignore_backups() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("somefile");
+    at.touch("somebackup~");
+    at.touch(".somehiddenfile");
+    at.touch(".somehiddenbackup~");
+
+    scene.ucmd().arg("-B").succeeds().stdout_is("somefile\n");
+    scene
+        .ucmd()
+        .arg("--ignore-backups")
+        .succeeds()
+        .stdout_is("somefile\n");
+
+    scene
+        .ucmd()
+        .arg("-aB")
+        .succeeds()
+        .stdout_contains(".somehiddenfile")
+        .stdout_contains("somefile")
+        .stdout_does_not_contain("somebackup")
+        .stdout_does_not_contain(".somehiddenbackup~");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("--ignore-backups")
+        .succeeds()
+        .stdout_contains(".somehiddenfile")
+        .stdout_contains("somefile")
+        .stdout_does_not_contain("somebackup")
+        .stdout_does_not_contain(".somehiddenbackup~");
+}
+
+#[test]
+fn test_ls_directory() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("some_dir");
+    at.symlink_dir("some_dir", "sym_dir");
+
+    at.touch(Path::new("some_dir").join("nested_file").to_str().unwrap());
+
+    scene
+        .ucmd()
+        .arg("some_dir")
+        .succeeds()
+        .stdout_is("nested_file\n");
+
+    scene
+        .ucmd()
+        .arg("--directory")
+        .arg("some_dir")
+        .succeeds()
+        .stdout_is("some_dir\n");
+
+    scene
+        .ucmd()
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_is("nested_file\n");
+}
+
+#[test]
+fn test_ls_deref_command_line() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("some_file");
+    at.symlink_file("some_file", "sym_file");
+
+    scene
+        .ucmd()
+        .arg("sym_file")
+        .succeeds()
+        .stdout_is("sym_file\n");
+
+    // -l changes the default to no dereferencing
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("sym_file")
+        .succeeds()
+        .stdout_contains("sym_file ->");
+
+    scene
+        .ucmd()
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_file")
+        .succeeds()
+        .stdout_is("sym_file\n");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_file")
+        .succeeds()
+        .stdout_contains("sym_file ->");
+
+    scene
+        .ucmd()
+        .arg("--dereference-command-line")
+        .arg("sym_file")
+        .succeeds()
+        .stdout_is("sym_file\n");
+
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line")
+        .arg("sym_file")
+        .succeeds();
+
+    assert!(!result.stdout_str().contains("->"));
+
+    let result = scene.ucmd().arg("-lH").arg("sym_file").succeeds();
+
+    assert!(!result.stdout_str().contains("sym_file ->"));
+
+    // If the symlink is not a command line argument, it must be shown normally
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line")
+        .succeeds()
+        .stdout_contains("sym_file ->");
+}
+
+#[test]
+fn test_ls_deref_command_line_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("some_dir");
+    at.symlink_dir("some_dir", "sym_dir");
+
+    at.touch(Path::new("some_dir").join("nested_file").to_str().unwrap());
+
+    scene
+        .ucmd()
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    scene
+        .ucmd()
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    scene
+        .ucmd()
+        .arg("--dereference-command-line")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    scene
+        .ucmd()
+        .arg("-lH")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("nested_file");
+
+    // If the symlink is not a command line argument, it must be shown normally
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    scene
+        .ucmd()
+        .arg("-lH")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--dereference-command-line-symlink-to-dir")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    // --directory does not dereference anything by default
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--directory")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--directory")
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_dir")
+        .succeeds();
+
+    assert!(!result.stdout_str().ends_with("sym_dir"));
+
+    // --classify does not dereference anything by default
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--directory")
+        .arg("sym_dir")
+        .succeeds()
+        .stdout_contains("sym_dir ->");
+
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--directory")
+        .arg("--dereference-command-line-symlink-to-dir")
+        .arg("sym_dir")
+        .succeeds();
+
+    assert!(!result.stdout_str().ends_with("sym_dir"));
+}
+
+#[test]
+fn test_ls_sort_extension() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    for filename in &[
+        "file1",
+        "file2",
+        "anotherFile",
+        ".hidden",
+        ".file.1",
+        ".file.2",
+        "file.1",
+        "file.2",
+        "anotherFile.1",
+        "anotherFile.2",
+        "file.ext",
+        "file.debug",
+        "anotherFile.ext",
+        "anotherFile.debug",
+    ] {
+        at.touch(filename);
+    }
+
+    let expected = vec![
+        ".",
+        "..",
+        ".hidden",
+        "anotherFile",
+        "file1",
+        "file2",
+        ".file.1",
+        "anotherFile.1",
+        "file.1",
+        ".file.2",
+        "anotherFile.2",
+        "file.2",
+        "anotherFile.debug",
+        "file.debug",
+        "anotherFile.ext",
+        "file.ext",
+        "", // because of '\n' at the end of the output
+    ];
+
+    let result = scene.ucmd().arg("-1aX").run();
+    assert_eq!(
+        result.stdout_str().split('\n').collect::<Vec<_>>(),
+        expected,
+    );
+
+    let result = scene.ucmd().arg("-1a").arg("--sort=extension").run();
+    assert_eq!(
+        result.stdout_str().split('\n').collect::<Vec<_>>(),
+        expected,
+    );
+}
+
+#[test]
+fn test_ls_path() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file1 = "file1";
+    let file2 = "file2";
+    let dir = "dir";
+    let path = &format!("{}/{}", dir, file2);
+
+    at.mkdir(dir);
+    at.touch(file1);
+    at.touch(path);
+
+    let expected_stdout = &format!("{}\n", path);
+    scene.ucmd().arg(path).run().stdout_is(expected_stdout);
+
+    let expected_stdout = &format!("./{}\n", path);
+    scene
+        .ucmd()
+        .arg(format!("./{}", path))
+        .run()
+        .stdout_is(expected_stdout);
+
+    let abs_path = format!("{}/{}", at.as_string(), path);
+    let expected_stdout = if cfg!(windows) {
+        format!("\'{}\'\n", abs_path)
+    } else {
+        format!("{}\n", abs_path)
+    };
+    scene.ucmd().arg(&abs_path).run().stdout_is(expected_stdout);
+
+    let expected_stdout = if cfg!(windows) {
+        format!("{}  {}\n", path, file1)
+    } else {
+        format!("{}\n{}\n", path, file1)
+    };
+    scene
+        .ucmd()
+        .arg(file1)
+        .arg(path)
+        .run()
+        .stdout_is(expected_stdout);
+}

tests/by-util/test_mkfifo.rs

@@ -2,9 +2,7 @@ use crate::common::util::*;
 
 #[test]
 fn test_create_fifo_missing_operand() {
-    new_ucmd!()
-        .fails()
-        .stderr_is("mkfifo: error: missing operand");
+    new_ucmd!().fails().stderr_is("mkfifo: missing operand");
 }
 
 #[test]
@@ -19,8 +17,7 @@ fn test_create_one_fifo_with_invalid_mode() {
         .arg("-m")
         .arg("invalid")
         .fails()
-        .stderr
-        .contains("invalid mode");
+        .stderr_contains("invalid mode");
 }
 
 #[test]
@@ -44,5 +41,5 @@ fn test_create_one_fifo_already_exists() {
         .arg("abcdef")
         .arg("abcdef")
         .fails()
-        .stderr_is("mkfifo: error: cannot create fifo 'abcdef': File exists");
+        .stderr_is("mkfifo: cannot create fifo 'abcdef': File exists");
 }

tests/by-util/test_mknod.rs

@@ -1 +1,124 @@
-// ToDO: add tests
+use crate::common::util::*;
+
+#[cfg(not(windows))]
+#[test]
+fn test_mknod_help() {
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("USAGE:");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_version() {
+    assert!(new_ucmd!()
+        .arg("--version")
+        .succeeds()
+        .no_stderr()
+        .stdout_str()
+        .starts_with("mknod"));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_fifo_default_writable() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd().arg("test_file").arg("p").succeeds();
+    assert!(ts.fixtures.is_fifo("test_file"));
+    assert!(!ts.fixtures.metadata("test_file").permissions().readonly());
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_fifo_mnemonic_usage() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd().arg("test_file").arg("pipe").succeeds();
+    assert!(ts.fixtures.is_fifo("test_file"));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_fifo_read_only() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("-m")
+        .arg("a=r")
+        .arg("test_file")
+        .arg("p")
+        .succeeds();
+    assert!(ts.fixtures.is_fifo("test_file"));
+    assert!(ts.fixtures.metadata("test_file").permissions().readonly());
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_fifo_invalid_extra_operand() {
+    new_ucmd!()
+        .arg("test_file")
+        .arg("p")
+        .arg("1")
+        .arg("2")
+        .fails()
+        .stderr_contains(&"Fifos do not have major and minor device numbers");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_character_device_requires_major_and_minor() {
+    new_ucmd!()
+        .arg("test_file")
+        .arg("c")
+        .fails()
+        .status_code(1)
+        .stderr_contains(&"Special files require major and minor device numbers.");
+    new_ucmd!()
+        .arg("test_file")
+        .arg("c")
+        .arg("1")
+        .fails()
+        .status_code(1)
+        .stderr_contains(&"Special files require major and minor device numbers.");
+    new_ucmd!()
+        .arg("test_file")
+        .arg("c")
+        .arg("1")
+        .arg("c")
+        .fails()
+        .status_code(1)
+        .stderr_contains(&"Invalid value for '<MINOR>'");
+    new_ucmd!()
+        .arg("test_file")
+        .arg("c")
+        .arg("c")
+        .arg("1")
+        .fails()
+        .status_code(1)
+        .stderr_contains(&"Invalid value for '<MAJOR>'");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_invalid_arg() {
+    new_ucmd!()
+        .arg("--foo")
+        .fails()
+        .status_code(1)
+        .no_stdout()
+        .stderr_contains(&"Found argument '--foo' which wasn't expected");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_mknod_invalid_mode() {
+    new_ucmd!()
+        .arg("--mode")
+        .arg("rw")
+        .arg("test_file")
+        .arg("p")
+        .fails()
+        .no_stdout()
+        .status_code(1)
+        .stderr_contains(&"invalid mode");
+}

tests/by-util/test_mktemp.rs

@@ -113,17 +113,14 @@ fn test_mktemp_mktemp_t() {
         .arg("-t")
         .arg(TEST_TEMPLATE7)
         .succeeds();
-    let result = scene
+    scene
         .ucmd()
         .env(TMPDIR, &pathname)
         .arg("-t")
         .arg(TEST_TEMPLATE8)
-        .fails();
-    println!("stdout {}", result.stdout);
-    println!("stderr {}", result.stderr);
-    assert!(result
-        .stderr
-        .contains("error: suffix cannot contain any path separators"));
+        .fails()
+        .no_stdout()
+        .stderr_contains("suffix cannot contain any path separators");
 }
 
 #[test]
@@ -391,10 +388,8 @@ fn test_mktemp_tmpdir_one_arg() {
         .arg("--tmpdir")
         .arg("apt-key-gpghome.XXXXXXXXXX")
         .succeeds();
-    println!("stdout {}", result.stdout);
-    println!("stderr {}", result.stderr);
-    assert!(result.stdout.contains("apt-key-gpghome."));
-    assert!(PathBuf::from(result.stdout.trim()).is_file());
+    result.no_stderr().stdout_contains("apt-key-gpghome.");
+    assert!(PathBuf::from(result.stdout_str().trim()).is_file());
 }
 
 #[test]
@@ -407,8 +402,6 @@ fn test_mktemp_directory_tmpdir() {
         .arg("--tmpdir")
         .arg("apt-key-gpghome.XXXXXXXXXX")
         .succeeds();
-    println!("stdout {}", result.stdout);
-    println!("stderr {}", result.stderr);
-    assert!(result.stdout.contains("apt-key-gpghome."));
-    assert!(PathBuf::from(result.stdout.trim()).is_dir());
+    result.no_stderr().stdout_contains("apt-key-gpghome.");
+    assert!(PathBuf::from(result.stdout_str().trim()).is_dir());
 }

tests/by-util/test_more.rs

@@ -2,18 +2,15 @@ use crate::common::util::*;
 
 #[test]
 fn test_more_no_arg() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    assert!(!result.success);
+    // stderr = more: Reading from stdin isn't supported yet.
+    new_ucmd!().fails();
 }
 
 #[test]
 fn test_more_dir_arg() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    ucmd.arg(".");
-    let result = ucmd.run();
-    assert!(!result.success);
+    let result = new_ucmd!().arg(".").run();
+    result.failure();
     const EXPECTED_ERROR_MESSAGE: &str =
         "more: '.' is a directory.\nTry 'more --help' for more information.";
-    assert_eq!(result.stderr.trim(), EXPECTED_ERROR_MESSAGE);
+    assert_eq!(result.stderr_str().trim(), EXPECTED_ERROR_MESSAGE);
 }

tests/by-util/test_mv.rs

@@ -251,6 +251,40 @@ fn test_mv_simple_backup() {
     assert!(at.file_exists(&format!("{}~", file_b)));
 }
 
+#[test]
+fn test_mv_simple_backup_with_file_extension() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_simple_backup_file_a.txt";
+    let file_b = "test_mv_simple_backup_file_b.txt";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("-b")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}~", file_b)));
+}
+
+#[test]
+fn test_mv_arg_backup_arg_first() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_simple_backup_file_a";
+    let file_b = "test_mv_simple_backup_file_b";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("--backup").arg(file_a).arg(file_b).succeeds();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}~", file_b)));
+}
+
 #[test]
 fn test_mv_custom_backup_suffix() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -293,7 +327,7 @@ fn test_mv_custom_backup_suffix_via_env() {
 }
 
 #[test]
-fn test_mv_backup_numbering() {
+fn test_mv_backup_numbered_with_t() {
     let (at, mut ucmd) = at_and_ucmd!();
     let file_a = "test_mv_backup_numbering_file_a";
     let file_b = "test_mv_backup_numbering_file_b";
@@ -311,6 +345,25 @@ fn test_mv_backup_numbering() {
     assert!(at.file_exists(&format!("{}.~1~", file_b)));
 }
 
+#[test]
+fn test_mv_backup_numbered() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("--backup=numbered")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}.~1~", file_b)));
+}
+
 #[test]
 fn test_mv_backup_existing() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -330,6 +383,67 @@ fn test_mv_backup_existing() {
     assert!(at.file_exists(&format!("{}~", file_b)));
 }
 
+#[test]
+fn test_mv_backup_nil() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("--backup=nil")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}~", file_b)));
+}
+
+#[test]
+fn test_mv_numbered_if_existing_backup_existing() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
+    let file_b_backup = "test_mv_backup_numbering_file_b.~1~";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    at.touch(file_b_backup);
+    ucmd.arg("--backup=existing")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(file_b_backup));
+    assert!(at.file_exists(&*format!("{}.~2~", file_b)));
+}
+
+#[test]
+fn test_mv_numbered_if_existing_backup_nil() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
+    let file_b_backup = "test_mv_backup_numbering_file_b.~1~";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    at.touch(file_b_backup);
+    ucmd.arg("--backup=nil")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(file_b_backup));
+    assert!(at.file_exists(&*format!("{}.~2~", file_b)));
+}
+
 #[test]
 fn test_mv_backup_simple() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -349,6 +463,25 @@ fn test_mv_backup_simple() {
     assert!(at.file_exists(&format!("{}~", file_b)));
 }
 
+#[test]
+fn test_mv_backup_never() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("--backup=never")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}~", file_b)));
+}
+
 #[test]
 fn test_mv_backup_none() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -369,17 +502,14 @@ fn test_mv_backup_none() {
 }
 
 #[test]
-fn test_mv_existing_backup() {
+fn test_mv_backup_off() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let file_a = "test_mv_existing_backup_file_a";
-    let file_b = "test_mv_existing_backup_file_b";
-    let file_b_backup = "test_mv_existing_backup_file_b.~1~";
-    let resulting_backup = "test_mv_existing_backup_file_b.~2~";
+    let file_a = "test_mv_backup_numbering_file_a";
+    let file_b = "test_mv_backup_numbering_file_b";
 
     at.touch(file_a);
     at.touch(file_b);
-    at.touch(file_b_backup);
-    ucmd.arg("--backup=nil")
+    ucmd.arg("--backup=off")
         .arg(file_a)
         .arg(file_b)
         .succeeds()
@@ -387,8 +517,19 @@ fn test_mv_existing_backup() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(file_b_backup));
-    assert!(at.file_exists(resulting_backup));
+    assert!(!at.file_exists(&format!("{}~", file_b)));
+}
+
+#[test]
+fn test_mv_backup_no_clobber_conflicting_options() {
+    let (_, mut ucmd) = at_and_ucmd!();
+
+    ucmd.arg("--backup")
+        .arg("--no-clobber")
+        .arg("file1")
+        .arg("file2")
+        .fails()
+        .stderr_is("mv: options --backup and --no-clobber are mutually exclusive\nTry 'mv --help' for more information.");
 }
 
 #[test]
@@ -472,20 +613,13 @@ fn test_mv_overwrite_nonempty_dir() {
     at.touch(dummy);
     // Not same error as GNU; the error message is a rust builtin
     // TODO: test (and implement) correct error message (or at least decide whether to do so)
-    // Current: "mv: error: couldn't rename path (Directory not empty; from=a; to=b)"
+    // Current: "mv: couldn't rename path (Directory not empty; from=a; to=b)"
     // GNU:     "mv: cannot move ‘a’ to ‘b’: Directory not empty"
 
     // Verbose output for the move should not be shown on failure
-    assert!(
-        ucmd.arg("-vT")
-            .arg(dir_a)
-            .arg(dir_b)
-            .fails()
-            .no_stdout()
-            .stderr
-            .len()
-            > 0
-    );
+    let result = ucmd.arg("-vT").arg(dir_a).arg(dir_b).fails();
+    result.no_stdout();
+    assert!(!result.stderr_str().is_empty());
 
     assert!(at.dir_exists(dir_a));
     assert!(at.dir_exists(dir_b));
@@ -526,15 +660,15 @@ fn test_mv_errors() {
 
     // $ mv -T -t a b
     // mv: cannot combine --target-directory (-t) and --no-target-directory (-T)
-    let result = scene
+    scene
         .ucmd()
         .arg("-T")
         .arg("-t")
         .arg(dir)
         .arg(file_a)
         .arg(file_b)
-        .fails();
-    assert!(result.stderr.contains("cannot be used with"));
+        .fails()
+        .stderr_contains("cannot be used with");
 
     // $ at.touch file && at.mkdir dir
     // $ mv -T file dir
@@ -546,14 +680,20 @@ fn test_mv_errors() {
         .arg(dir)
         .fails()
         .stderr_is(format!(
-            "mv: error: cannot overwrite directory ‘{}’ with non-directory\n",
+            "mv: cannot overwrite directory ‘{}’ with non-directory\n",
             dir
         ));
 
     // $ at.mkdir dir && at.touch file
     // $ mv dir file
     // err == mv: cannot overwrite non-directory ‘file’ with directory ‘dir’
-    assert!(scene.ucmd().arg(dir).arg(file_a).fails().stderr.len() > 0);
+    assert!(!scene
+        .ucmd()
+        .arg(dir)
+        .arg(file_a)
+        .fails()
+        .stderr_str()
+        .is_empty());
 }
 
 #[test]
@@ -588,6 +728,24 @@ fn test_mv_verbose() {
         ));
 }
 
+#[test]
+fn test_mv_permission_error() {
+    let scene = TestScenario::new("mkdir");
+    let folder1 = "bar";
+    let folder2 = "foo";
+    let folder_to_move = "bar/foo";
+    scene.ucmd().arg("-m444").arg(folder1).succeeds();
+    scene.ucmd().arg("-m777").arg(folder2).succeeds();
+
+    scene
+        .cmd_keepenv(util_name!())
+        .arg(folder2)
+        .arg(folder_to_move)
+        .run()
+        .stderr_str()
+        .ends_with("Permission denied");
+}
+
 // Todo:
 
 // $ at.touch a b

tests/by-util/test_nice.rs

@@ -16,7 +16,7 @@ fn test_negative_adjustment() {
 
     let res = new_ucmd!().args(&["-n", "-1", "true"]).run();
     assert!(res
-        .stderr
+        .stderr_str()
         .starts_with("nice: warning: setpriority: Permission denied"));
 }
 
@@ -25,7 +25,7 @@ fn test_adjustment_with_no_command_should_error() {
     new_ucmd!()
     .args(&["-n", "19"])
     .run()
-    .stderr_is("nice: error: A command must be given with an adjustment.\nTry \"nice --help\" for more information.\n");
+    .stderr_is("nice: A command must be given with an adjustment.\nTry \"nice --help\" for more information.\n");
 }
 
 #[test]

tests/by-util/test_nproc.rs

@@ -2,54 +2,46 @@ use crate::common::util::*;
 
 #[test]
 fn test_nproc() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    assert!(result.success);
-    let nproc: u8 = result.stdout.trim().parse().unwrap();
+    let nproc: u8 = new_ucmd!().succeeds().stdout_str().trim().parse().unwrap();
     assert!(nproc > 0);
 }
 
 #[test]
 fn test_nproc_all_omp() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.arg("--all").run();
-    assert!(result.success);
-    let nproc: u8 = result.stdout.trim().parse().unwrap();
+    let result = new_ucmd!().arg("--all").succeeds();
+
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
     assert!(nproc > 0);
 
     let result = TestScenario::new(util_name!())
         .ucmd_keepenv()
         .env("OMP_NUM_THREADS", "1")
-        .run();
-    assert!(result.success);
-    let nproc_omp: u8 = result.stdout.trim().parse().unwrap();
+        .succeeds();
+
+    let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
     assert!(nproc - 1 == nproc_omp);
 
     let result = TestScenario::new(util_name!())
         .ucmd_keepenv()
         .env("OMP_NUM_THREADS", "1") // Has no effect
         .arg("--all")
-        .run();
-    assert!(result.success);
-    let nproc_omp: u8 = result.stdout.trim().parse().unwrap();
+        .succeeds();
+    let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
     assert!(nproc == nproc_omp);
 }
 
 #[test]
 fn test_nproc_ignore() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    assert!(result.success);
-    let nproc: u8 = result.stdout.trim().parse().unwrap();
+    let result = new_ucmd!().succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
     if nproc > 1 {
         // Ignore all CPU but one
         let result = TestScenario::new(util_name!())
             .ucmd_keepenv()
             .arg("--ignore")
             .arg((nproc - 1).to_string())
-            .run();
-        assert!(result.success);
-        let nproc: u8 = result.stdout.trim().parse().unwrap();
+            .succeeds();
+        let nproc: u8 = result.stdout_str().trim().parse().unwrap();
         assert!(nproc == 1);
     }
 }

tests/by-util/test_numfmt.rs

@@ -281,6 +281,7 @@ fn test_leading_whitespace_in_free_argument_should_imply_padding() {
 }
 
 #[test]
+#[ignore]
 fn test_should_calculate_implicit_padding_per_free_argument() {
     new_ucmd!()
         .args(&["--from=auto", "   1Ki", "        2K"])

tests/by-util/test_pinky.rs

@@ -20,64 +20,92 @@ fn test_long_format() {
     let ulogin = "root";
     let pw: Passwd = Passwd::locate(ulogin).unwrap();
     let real_name = pw.user_info().replace("&", &pw.name().capitalize());
-    new_ucmd!().arg("-l").arg(ulogin).run().stdout_is(format!(
-        "Login name: {:<28}In real life:  {}\nDirectory: {:<29}Shell:  {}\n\n",
-        ulogin,
-        real_name,
-        pw.user_dir(),
-        pw.user_shell()
-    ));
+    new_ucmd!()
+        .arg("-l")
+        .arg(ulogin)
+        .succeeds()
+        .stdout_is(format!(
+            "Login name: {:<28}In real life:  {}\nDirectory: {:<29}Shell:  {}\n\n",
+            ulogin,
+            real_name,
+            pw.user_dir(),
+            pw.user_shell()
+        ));
 
-    new_ucmd!().arg("-lb").arg(ulogin).run().stdout_is(format!(
-        "Login name: {:<28}In real life:  {1}\n\n",
-        ulogin, real_name
-    ));
+    new_ucmd!()
+        .arg("-lb")
+        .arg(ulogin)
+        .succeeds()
+        .stdout_is(format!(
+            "Login name: {:<28}In real life:  {1}\n\n",
+            ulogin, real_name
+        ));
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_long_format_multiple_users() {
+    let args = ["-l", "root", "root", "root"];
+
+    new_ucmd!()
+        .args(&args)
+        .succeeds()
+        .stdout_is(expected_result(&args));
+}
+
+#[test]
+fn test_long_format_wo_user() {
+    // "no username specified; at least one must be specified when using -l"
+    new_ucmd!().arg("-l").fails().code_is(1);
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_short_format_i() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
     let args = ["-i"];
-    let actual = TestScenario::new(util_name!())
-        .ucmd()
-        .args(&args)
-        .run()
-        .stdout;
+    let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
     let expect = expected_result(&args);
-    println!("actual: {:?}", actual);
-    println!("expect: {:?}", expect);
     let v_actual: Vec<&str> = actual.split_whitespace().collect();
     let v_expect: Vec<&str> = expect.split_whitespace().collect();
     assert_eq!(v_actual, v_expect);
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_short_format_q() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
     let args = ["-q"];
-    let actual = TestScenario::new(util_name!())
-        .ucmd()
-        .args(&args)
-        .run()
-        .stdout;
+    let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
     let expect = expected_result(&args);
-    println!("actual: {:?}", actual);
-    println!("expect: {:?}", expect);
     let v_actual: Vec<&str> = actual.split_whitespace().collect();
     let v_expect: Vec<&str> = expect.split_whitespace().collect();
     assert_eq!(v_actual, v_expect);
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_no_flag() {
+    let actual = new_ucmd!().succeeds().stdout_move_str();
+    let expect = expected_result(&[]);
+    let v_actual: Vec<&str> = actual.split_whitespace().collect();
+    let v_expect: Vec<&str> = expect.split_whitespace().collect();
+    assert_eq!(v_actual, v_expect);
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 fn expected_result(args: &[&str]) -> String {
-    TestScenario::new(util_name!())
-        .cmd_keepenv(util_name!())
+    #[cfg(target_os = "linux")]
+    let util_name = util_name!();
+    #[cfg(target_vendor = "apple")]
+    let util_name = format!("g{}", util_name!());
+
+    TestScenario::new(&util_name)
+        .cmd_keepenv(util_name)
         .env("LANGUAGE", "C")
         .args(args)
-        .run()
-        .stdout
+        .succeeds()
+        .stdout_move_str()
 }

tests/by-util/test_printenv.rs

@@ -7,10 +7,11 @@ fn test_get_all() {
     env::set_var(key, "VALUE");
     assert_eq!(env::var(key), Ok("VALUE".to_string()));
 
-    let result = TestScenario::new(util_name!()).ucmd_keepenv().run();
-    assert!(result.success);
-    assert!(result.stdout.contains("HOME="));
-    assert!(result.stdout.contains("KEY=VALUE"));
+    TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .succeeds()
+        .stdout_contains("HOME=")
+        .stdout_contains("KEY=VALUE");
 }
 
 #[test]
@@ -22,9 +23,8 @@ fn test_get_var() {
     let result = TestScenario::new(util_name!())
         .ucmd_keepenv()
         .arg("KEY")
-        .run();
+        .succeeds();
 
-    assert!(result.success);
-    assert!(!result.stdout.is_empty());
-    assert!(result.stdout.trim() == "VALUE");
+    assert!(!result.stdout_str().is_empty());
+    assert!(result.stdout_str().trim() == "VALUE");
 }

tests/by-util/test_readlink.rs

@@ -5,7 +5,7 @@ static GIBBERISH: &'static str = "supercalifragilisticexpialidocious";
 #[test]
 fn test_canonicalize() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-f").arg(".").run().stdout;
+    let actual = ucmd.arg("-f").arg(".").run().stdout_move_str();
     let expect = at.root_dir_resolved() + "\n";
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -15,7 +15,7 @@ fn test_canonicalize() {
 #[test]
 fn test_canonicalize_existing() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-e").arg(".").run().stdout;
+    let actual = ucmd.arg("-e").arg(".").run().stdout_move_str();
     let expect = at.root_dir_resolved() + "\n";
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -25,7 +25,7 @@ fn test_canonicalize_existing() {
 #[test]
 fn test_canonicalize_missing() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-m").arg(GIBBERISH).run().stdout;
+    let actual = ucmd.arg("-m").arg(GIBBERISH).run().stdout_move_str();
     let expect = path_concat!(at.root_dir_resolved(), GIBBERISH) + "\n";
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -37,7 +37,7 @@ fn test_long_redirection_to_current_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
     // Create a 256-character path to current directory
     let dir = path_concat!(".", ..128);
-    let actual = ucmd.arg("-n").arg("-m").arg(dir).run().stdout;
+    let actual = ucmd.arg("-n").arg("-m").arg(dir).run().stdout_move_str();
     let expect = at.root_dir_resolved();
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -48,7 +48,12 @@ fn test_long_redirection_to_current_dir() {
 fn test_long_redirection_to_root() {
     // Create a 255-character path to root
     let dir = path_concat!("..", ..85);
-    let actual = new_ucmd!().arg("-n").arg("-m").arg(dir).run().stdout;
+    let actual = new_ucmd!()
+        .arg("-n")
+        .arg("-m")
+        .arg(dir)
+        .run()
+        .stdout_move_str();
     let expect = get_root_path();
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);

tests/by-util/test_relpath.rs

@@ -103,7 +103,7 @@ fn test_relpath_with_from_with_d() {
         at.mkdir_all(from);
 
         // d is part of subpath -> expect relative path
-        let mut result_stdout = scene
+        let mut _result_stdout = scene
             .ucmd()
             .arg(to)
             .arg(from)
@@ -112,17 +112,17 @@ fn test_relpath_with_from_with_d() {
             .stdout_move_str();
         // relax rules for windows test environment
         #[cfg(not(windows))]
-        assert!(Path::new(&result_stdout).is_relative());
+        assert!(Path::new(&_result_stdout).is_relative());
 
         // d is not part of subpath -> expect absolut path
-        result_stdout = scene
+        _result_stdout = scene
             .ucmd()
             .arg(to)
             .arg(from)
             .arg("-dnon_existing")
             .succeeds()
             .stdout_move_str();
-        assert!(Path::new(&result_stdout).is_absolute());
+        assert!(Path::new(&_result_stdout).is_absolute());
     }
 }
 
@@ -135,12 +135,12 @@ fn test_relpath_no_from_no_d() {
         let to: &str = &convert_path(test.to);
         at.mkdir_all(to);
 
-        let result_stdout = scene.ucmd().arg(to).succeeds().stdout_move_str();
+        let _result_stdout = scene.ucmd().arg(to).succeeds().stdout_move_str();
         #[cfg(not(windows))]
-        assert_eq!(result_stdout, format!("{}\n", to));
+        assert_eq!(_result_stdout, format!("{}\n", to));
         // relax rules for windows test environment
         #[cfg(windows)]
-        assert!(result_stdout.ends_with(&format!("{}\n", to)));
+        assert!(_result_stdout.ends_with(&format!("{}\n", to)));
     }
 }
 
@@ -155,7 +155,7 @@ fn test_relpath_no_from_with_d() {
         at.mkdir_all(to);
 
         // d is part of subpath -> expect relative path
-        let mut result_stdout = scene
+        let _result_stdout = scene
             .ucmd()
             .arg(to)
             .arg(&format!("-d{}", pwd))
@@ -163,10 +163,10 @@ fn test_relpath_no_from_with_d() {
             .stdout_move_str();
         // relax rules for windows test environment
         #[cfg(not(windows))]
-        assert!(Path::new(&result_stdout).is_relative());
+        assert!(Path::new(&_result_stdout).is_relative());
 
         // d is not part of subpath -> expect absolut path
-        result_stdout = scene
+        let result_stdout = scene
             .ucmd()
             .arg(to)
             .arg("-dnon_existing")

tests/by-util/test_rm.rs

@@ -258,7 +258,7 @@ fn test_rm_no_operand() {
     let mut ucmd = new_ucmd!();
 
     ucmd.fails()
-        .stderr_is("rm: error: missing an argument\nrm: error: for help, try 'rm --help'\n");
+        .stderr_is("rm: missing an argument\nrm: for help, try 'rm --help'\n");
 }
 
 #[test]

tests/by-util/test_rmdir.rs

@@ -39,7 +39,7 @@ fn test_rmdir_nonempty_directory_no_parents() {
     assert!(at.file_exists(file));
 
     ucmd.arg(dir).fails().stderr_is(
-        "rmdir: error: failed to remove 'test_rmdir_nonempty_no_parents': Directory not \
+        "rmdir: failed to remove 'test_rmdir_nonempty_no_parents': Directory not \
          empty\n",
     );
 
@@ -59,9 +59,9 @@ fn test_rmdir_nonempty_directory_with_parents() {
     assert!(at.file_exists(file));
 
     ucmd.arg("-p").arg(dir).fails().stderr_is(
-        "rmdir: error: failed to remove 'test_rmdir_nonempty/with/parents': Directory not \
-         empty\nrmdir: error: failed to remove 'test_rmdir_nonempty/with': Directory not \
-         empty\nrmdir: error: failed to remove 'test_rmdir_nonempty': Directory not \
+        "rmdir: failed to remove 'test_rmdir_nonempty/with/parents': Directory not \
+         empty\nrmdir: failed to remove 'test_rmdir_nonempty/with': Directory not \
+         empty\nrmdir: failed to remove 'test_rmdir_nonempty': Directory not \
          empty\n",
     );
 

tests/by-util/test_shred.rs

@@ -1 +1,49 @@
-// ToDO: add tests
+use crate::common::util::*;
+
+#[test]
+fn test_shred_remove() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_a = "test_shred_remove_a";
+    let file_b = "test_shred_remove_b";
+
+    // Create file_a and file_b.
+    at.touch(file_a);
+    at.touch(file_b);
+
+    // Shred file_a.
+    scene.ucmd().arg("-u").arg(file_a).run();
+
+    // file_a was deleted, file_b exists.
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+}
+
+#[cfg(not(target_os = "freebsd"))]
+#[test]
+fn test_shred_force() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file = "test_shred_force";
+
+    // Create file_a.
+    at.touch(file);
+    assert!(at.file_exists(file));
+
+    // Make file_a readonly.
+    at.set_readonly(file);
+
+    // Try shred -u.
+    scene.ucmd().arg("-u").arg(file).run();
+
+    // file_a was not deleted because it is readonly.
+    assert!(at.file_exists(file));
+
+    // Try shred -u -f.
+    scene.ucmd().arg("-u").arg("-f").arg(file).run();
+
+    // file_a was deleted.
+    assert!(!at.file_exists(file));
+}

tests/by-util/test_shuf.rs

@@ -9,35 +9,28 @@ fn test_output_is_random_permutation() {
         .collect::<Vec<String>>()
         .join("\n");
 
-    let result = new_ucmd!()
-        .pipe_in(input.as_bytes())
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+    let result = new_ucmd!().pipe_in(input.as_bytes()).succeeds();
+    result.no_stderr();
 
     let mut result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\n")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
         .collect();
     result_seq.sort();
-    assert_ne!(result, input, "Output is not randomised");
+    assert_ne!(result.stdout_str(), input, "Output is not randomised");
     assert_eq!(result_seq, input_seq, "Output is not a permutation");
 }
 
 #[test]
 fn test_zero_termination() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    let result = new_ucmd!()
-        .arg("-z")
-        .arg("-i1-10")
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+    let result = new_ucmd!().arg("-z").arg("-i1-10").succeeds();
+    result.no_stderr();
 
     let mut result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\0")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
@@ -57,12 +50,11 @@ fn test_echo() {
                 .map(|x| x.to_string())
                 .collect::<Vec<String>>(),
         )
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+        .succeeds();
+    result.no_stderr();
 
     let mut result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\n")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
@@ -84,12 +76,11 @@ fn test_head_count() {
     let result = new_ucmd!()
         .args(&["-n", &repeat_limit.to_string()])
         .pipe_in(input.as_bytes())
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+        .succeeds();
+    result.no_stderr();
 
     let mut result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\n")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
@@ -99,7 +90,7 @@ fn test_head_count() {
     assert!(
         result_seq.iter().all(|x| input_seq.contains(x)),
         "Output includes element not from input: {}",
-        result
+        result.stdout_str()
     )
 }
 
@@ -117,12 +108,11 @@ fn test_repeat() {
         .arg("-r")
         .args(&["-n", &repeat_limit.to_string()])
         .pipe_in(input.as_bytes())
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+        .succeeds();
+    result.no_stderr();
 
     let result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\n")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
@@ -146,14 +136,11 @@ fn test_repeat() {
 fn test_file_input() {
     let expected_seq = vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
 
-    let result = new_ucmd!()
-        .arg("file_input.txt")
-        .succeeds()
-        .no_stderr()
-        .stdout
-        .clone();
+    let result = new_ucmd!().arg("file_input.txt").succeeds();
+    result.no_stderr();
 
     let mut result_seq: Vec<i32> = result
+        .stdout_str()
         .split("\n")
         .filter(|x| !x.is_empty())
         .map(|x| x.parse().unwrap())
@@ -164,52 +151,50 @@ fn test_file_input() {
 
 #[test]
 fn test_shuf_echo_and_input_range_not_allowed() {
-    let result = new_ucmd!().args(&["-e", "0", "-i", "0-2"]).run();
-
-    assert!(!result.success);
-    assert!(result
-        .stderr
-        .contains("The argument '--input-range <LO-HI>' cannot be used with '--echo <ARG>...'"));
+    new_ucmd!()
+        .args(&["-e", "0", "-i", "0-2"])
+        .fails()
+        .stderr_contains(
+            "The argument '--input-range <LO-HI>' cannot be used with '--echo <ARG>...'",
+        );
 }
 
 #[test]
 fn test_shuf_input_range_and_file_not_allowed() {
-    let result = new_ucmd!().args(&["-i", "0-9", "file"]).run();
-
-    assert!(!result.success);
-    assert!(result
-        .stderr
-        .contains("The argument '<file>' cannot be used with '--input-range <LO-HI>'"));
+    new_ucmd!()
+        .args(&["-i", "0-9", "file"])
+        .fails()
+        .stderr_contains("The argument '<file>' cannot be used with '--input-range <LO-HI>'");
 }
 
 #[test]
 fn test_shuf_invalid_input_range_one() {
-    let result = new_ucmd!().args(&["-i", "0"]).run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("invalid input range"));
+    new_ucmd!()
+        .args(&["-i", "0"])
+        .fails()
+        .stderr_contains("invalid input range");
 }
 
 #[test]
 fn test_shuf_invalid_input_range_two() {
-    let result = new_ucmd!().args(&["-i", "a-9"]).run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("invalid input range: 'a'"));
+    new_ucmd!()
+        .args(&["-i", "a-9"])
+        .fails()
+        .stderr_contains("invalid input range: 'a'");
 }
 
 #[test]
 fn test_shuf_invalid_input_range_three() {
-    let result = new_ucmd!().args(&["-i", "0-b"]).run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("invalid input range: 'b'"));
+    new_ucmd!()
+        .args(&["-i", "0-b"])
+        .fails()
+        .stderr_contains("invalid input range: 'b'");
 }
 
 #[test]
 fn test_shuf_invalid_input_line_count() {
-    let result = new_ucmd!().args(&["-n", "a"]).run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("invalid line count: 'a'"));
+    new_ucmd!()
+        .args(&["-n", "a"])
+        .fails()
+        .stderr_contains("invalid line count: 'a'");
 }

tests/by-util/test_sort.rs

@@ -1,5 +1,126 @@
 use crate::common::util::*;
 
+fn test_helper(file_name: &str, possible_args: &[&str]) {
+    for args in possible_args {
+        new_ucmd!()
+            .arg(format!("{}.txt", file_name))
+            .args(&args.split_whitespace().collect::<Vec<&str>>())
+            .succeeds()
+            .stdout_is_fixture(format!("{}.expected", file_name));
+
+        new_ucmd!()
+            .arg(format!("{}.txt", file_name))
+            .arg("--debug")
+            .args(&args.split_whitespace().collect::<Vec<&str>>())
+            .succeeds()
+            .stdout_is_fixture(format!("{}.expected.debug", file_name));
+    }
+}
+
+#[test]
+fn test_buffer_sizes() {
+    let buffer_sizes = [
+        "0", "50K", "50k", "1M", "100M", "1000G", "10T", "500E", "1Y",
+    ];
+    for buffer_size in &buffer_sizes {
+        new_ucmd!()
+            .arg("-n")
+            .arg("-S")
+            .arg(buffer_size)
+            .arg("ext_sort.txt")
+            .succeeds()
+            .stdout_is_fixture("ext_sort.expected");
+    }
+}
+
+#[test]
+fn test_invalid_buffer_size() {
+    let buffer_sizes = ["asd", "100f"];
+    for invalid_buffer_size in &buffer_sizes {
+        new_ucmd!()
+            .arg("-S")
+            .arg(invalid_buffer_size)
+            .fails()
+            .stderr_only(format!(
+                "sort: failed to parse buffer size `{}`: invalid digit found in string",
+                invalid_buffer_size
+            ));
+    }
+}
+
+#[test]
+fn test_ext_sort_stable() {
+    new_ucmd!()
+        .arg("-n")
+        .arg("--stable")
+        .arg("-S")
+        .arg("0M")
+        .arg("ext_stable.txt")
+        .succeeds()
+        .stdout_only_fixture("ext_stable.expected");
+}
+
+#[test]
+fn test_extsort_zero_terminated() {
+    new_ucmd!()
+        .arg("-z")
+        .arg("-S")
+        .arg("10K")
+        .arg("zero-terminated.txt")
+        .succeeds()
+        .stdout_is_fixture("zero-terminated.expected");
+}
+
+#[test]
+fn test_months_whitespace() {
+    test_helper("months-whitespace", &["-M", "--month-sort", "--sort=month"]);
+}
+
+#[test]
+fn test_version_empty_lines() {
+    new_ucmd!()
+        .arg("-V")
+        .arg("version-empty-lines.txt")
+        .succeeds()
+        .stdout_is("\n\n\n\n\n\n\n1.2.3-alpha\n1.2.3-alpha2\n\t\t\t1.12.4\n11.2.3\n");
+}
+
+#[test]
+fn test_human_numeric_whitespace() {
+    test_helper(
+        "human-numeric-whitespace",
+        &["-h", "--human-numeric-sort", "--sort=human-numeric"],
+    );
+}
+
+// This tests where serde often fails when reading back JSON
+// if it finds a null value
+#[test]
+fn test_extsort_as64_bailout() {
+    new_ucmd!()
+        .arg("-g")
+        .arg("-S 5K")
+        .arg("multiple_decimals_general.txt")
+        .succeeds()
+        .stdout_is_fixture("multiple_decimals_general.expected");
+}
+
+#[test]
+fn test_multiple_decimals_general() {
+    test_helper(
+        "multiple_decimals_general",
+        &["-g", "--general-numeric-sort", "--sort=general-numeric"],
+    )
+}
+
+#[test]
+fn test_multiple_decimals_numeric() {
+    test_helper(
+        "multiple_decimals_numeric",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    )
+}
+
 #[test]
 fn test_check_zero_terminated_failure() {
     new_ucmd!()
@@ -7,7 +128,7 @@ fn test_check_zero_terminated_failure() {
         .arg("-c")
         .arg("zero-terminated.txt")
         .fails()
-        .stdout_is("sort: disorder in line 0\n");
+        .stdout_is("sort: zero-terminated.txt:2: disorder: ../../fixtures/du\n");
 }
 
 #[test]
@@ -22,9 +143,9 @@ fn test_check_zero_terminated_success() {
 #[test]
 fn test_random_shuffle_len() {
     // check whether output is the same length as the input
-    const FILE: &'static str = "default_unsorted_ints.expected";
+    const FILE: &str = "default_unsorted_ints.expected";
     let (at, _ucmd) = at_and_ucmd!();
-    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout;
+    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
     let expected = at.read(FILE);
 
     assert_ne!(result, expected);
@@ -34,26 +155,41 @@ fn test_random_shuffle_len() {
 #[test]
 fn test_random_shuffle_contains_all_lines() {
     // check whether lines of input are all in output
-    const FILE: &'static str = "default_unsorted_ints.expected";
+    const FILE: &str = "default_unsorted_ints.expected";
     let (at, _ucmd) = at_and_ucmd!();
-    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout;
+    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
     let expected = at.read(FILE);
-    let result_sorted = new_ucmd!().pipe_in(result.clone()).run().stdout;
+    let result_sorted = new_ucmd!().pipe_in(result.clone()).run().stdout_move_str();
 
     assert_ne!(result, expected);
     assert_eq!(result_sorted, expected);
 }
 
+#[test]
+fn test_random_shuffle_two_runs_not_the_same() {
+    // check to verify that two random shuffles are not equal; this has the
+    // potential to fail in the very unlikely event that the random order is the same
+    // as the starting order, or if both random sorts end up having the same order.
+    const FILE: &str = "default_unsorted_ints.expected";
+    let (at, _ucmd) = at_and_ucmd!();
+    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
+    let expected = at.read(FILE);
+    let unexpected = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
+
+    assert_ne!(result, expected);
+    assert_ne!(result, unexpected);
+}
+
 #[test]
 fn test_random_shuffle_contains_two_runs_not_the_same() {
     // check to verify that two random shuffles are not equal; this has the
     // potential to fail in the unlikely event that random order is the same
     // as the starting order, or if both random sorts end up having the same order.
-    const FILE: &'static str = "default_unsorted_ints.expected";
+    const FILE: &str = "default_unsorted_ints.expected";
     let (at, _ucmd) = at_and_ucmd!();
-    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout;
+    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
     let expected = at.read(FILE);
-    let unexpected = new_ucmd!().arg("-R").arg(FILE).run().stdout;
+    let unexpected = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
 
     assert_ne!(result, expected);
     assert_ne!(result, unexpected);
@@ -61,72 +197,93 @@ fn test_random_shuffle_contains_two_runs_not_the_same() {
 
 #[test]
 fn test_numeric_floats_and_ints() {
-    test_helper("numeric_floats_and_ints", "-n");
+    test_helper(
+        "numeric_floats_and_ints",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_numeric_floats() {
-    test_helper("numeric_floats", "-n");
+    test_helper(
+        "numeric_floats",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_numeric_floats_with_nan() {
-    test_helper("numeric_floats_with_nan", "-n");
+    test_helper(
+        "numeric_floats_with_nan",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_numeric_unfixed_floats() {
-    test_helper("numeric_unfixed_floats", "-n");
+    test_helper(
+        "numeric_unfixed_floats",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_numeric_fixed_floats() {
-    test_helper("numeric_fixed_floats", "-n");
+    test_helper(
+        "numeric_fixed_floats",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_numeric_unsorted_ints() {
-    test_helper("numeric_unsorted_ints", "-n");
+    test_helper(
+        "numeric_unsorted_ints",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_human_block_sizes() {
-    test_helper("human_block_sizes", "-h");
+    test_helper(
+        "human_block_sizes",
+        &["-h", "--human-numeric-sort", "--sort=human-numeric"],
+    );
 }
 
 #[test]
 fn test_month_default() {
-    test_helper("month_default", "-M");
+    test_helper("month_default", &["-M", "--month-sort", "--sort=month"]);
 }
 
 #[test]
 fn test_month_stable() {
-    test_helper("month_stable", "-Ms");
+    test_helper("month_stable", &["-Ms"]);
 }
 
 #[test]
 fn test_default_unsorted_ints() {
-    test_helper("default_unsorted_ints", "");
+    test_helper("default_unsorted_ints", &[""]);
 }
 
 #[test]
 fn test_numeric_unique_ints() {
-    test_helper("numeric_unsorted_ints_unique", "-nu");
+    test_helper("numeric_unsorted_ints_unique", &["-nu"]);
 }
 
 #[test]
 fn test_version() {
-    test_helper("version", "-V");
+    test_helper("version", &["-V"]);
 }
 
 #[test]
 fn test_ignore_case() {
-    test_helper("ignore_case", "-f");
+    test_helper("ignore_case", &["-f"]);
 }
 
 #[test]
 fn test_dictionary_order() {
-    test_helper("dictionary_order", "-d");
+    test_helper("dictionary_order", &["-d"]);
 }
 
 #[test]
@@ -144,52 +301,62 @@ fn test_dictionary_order2() {
 fn test_non_printing_chars() {
     for non_printing_chars_param in vec!["-i"] {
         new_ucmd!()
-            .pipe_in("a👦🏻aa	b\naaaa	b")
+            .pipe_in("a👦🏻aa\naaaa")
             .arg(non_printing_chars_param)
             .succeeds()
-            .stdout_only("aaaa	b\na👦🏻aa	b\n");
+            .stdout_only("a👦🏻aa\naaaa\n");
     }
 }
 
 #[test]
 fn test_exponents_positive_general_fixed() {
-    for exponents_positive_general_param in vec!["-g"] {
-        new_ucmd!()
-            .pipe_in("100E6\n\n50e10\n+100000\n\n10000K78\n10E\n\n\n1000EDKLD\n\n\n100E6\n\n50e10\n+100000\n\n")
-            .arg(exponents_positive_general_param)
-            .succeeds()
-            .stdout_only("\n\n\n\n\n\n\n\n10000K78\n1000EDKLD\n10E\n+100000\n+100000\n100E6\n100E6\n50e10\n50e10\n");
-    }
+    test_helper("exponents_general", &["-g"]);
 }
 
 #[test]
 fn test_exponents_positive_numeric() {
-    test_helper("exponents-positive-numeric", "-n");
+    test_helper(
+        "exponents-positive-numeric",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_months_dedup() {
-    test_helper("months-dedup", "-Mu");
+    test_helper("months-dedup", &["-Mu"]);
 }
 
 #[test]
 fn test_mixed_floats_ints_chars_numeric() {
-    test_helper("mixed_floats_ints_chars_numeric", "-n");
+    test_helper(
+        "mixed_floats_ints_chars_numeric",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_mixed_floats_ints_chars_numeric_unique() {
-    test_helper("mixed_floats_ints_chars_numeric_unique", "-nu");
+    test_helper("mixed_floats_ints_chars_numeric_unique", &["-nu"]);
+}
+
+#[test]
+fn test_words_unique() {
+    test_helper("words_unique", &["-u"]);
+}
+
+#[test]
+fn test_numeric_unique() {
+    test_helper("numeric_unique", &["-nu"]);
 }
 
 #[test]
 fn test_mixed_floats_ints_chars_numeric_reverse() {
-    test_helper("mixed_floats_ints_chars_numeric_unique_reverse", "-nur");
+    test_helper("mixed_floats_ints_chars_numeric_unique_reverse", &["-nur"]);
 }
 
 #[test]
 fn test_mixed_floats_ints_chars_numeric_stable() {
-    test_helper("mixed_floats_ints_chars_numeric_stable", "-ns");
+    test_helper("mixed_floats_ints_chars_numeric_stable", &["-ns"]);
 }
 
 #[test]
@@ -218,12 +385,15 @@ fn test_numeric_floats2() {
 
 #[test]
 fn test_numeric_floats_with_nan2() {
-    test_helper("numeric-floats-with-nan2", "-n");
+    test_helper(
+        "numeric-floats-with-nan2",
+        &["-n", "--numeric-sort", "--sort=numeric"],
+    );
 }
 
 #[test]
 fn test_human_block_sizes2() {
-    for human_numeric_sort_param in vec!["-h", "--human-numeric-sort"] {
+    for human_numeric_sort_param in &["-h", "--human-numeric-sort", "--sort=human-numeric"] {
         let input = "8981K\n909991M\n-8T\n21G\n0.8M";
         new_ucmd!()
             .arg(human_numeric_sort_param)
@@ -235,7 +405,7 @@ fn test_human_block_sizes2() {
 
 #[test]
 fn test_month_default2() {
-    for month_sort_param in vec!["-M", "--month-sort"] {
+    for month_sort_param in &["-M", "--month-sort", "--sort=month"] {
         let input = "JAn\nMAY\n000may\nJun\nFeb";
         new_ucmd!()
             .arg(month_sort_param)
@@ -266,9 +436,159 @@ fn test_numeric_unique_ints2() {
     }
 }
 
+#[test]
+fn test_keys_open_ended() {
+    test_helper("keys_open_ended", &["-k 2.3"]);
+}
+
+#[test]
+fn test_keys_closed_range() {
+    test_helper("keys_closed_range", &["-k 2.2,2.2"]);
+}
+
+#[test]
+fn test_keys_multiple_ranges() {
+    test_helper("keys_multiple_ranges", &["-k 2,2 -k 3,3"]);
+}
+
+#[test]
+fn test_keys_no_field_match() {
+    test_helper("keys_no_field_match", &["-k 4,4"]);
+}
+
+#[test]
+fn test_keys_no_char_match() {
+    test_helper("keys_no_char_match", &["-k 1.2"]);
+}
+
+#[test]
+fn test_keys_custom_separator() {
+    test_helper("keys_custom_separator", &["-k 2.2,2.2 -t x"]);
+}
+
+#[test]
+fn test_keys_invalid_field() {
+    new_ucmd!()
+        .args(&["-k", "1."])
+        .fails()
+        .stderr_only("sort: failed to parse character index for key `1.`: cannot parse integer from empty string");
+}
+
+#[test]
+fn test_keys_invalid_field_option() {
+    new_ucmd!()
+        .args(&["-k", "1.1x"])
+        .fails()
+        .stderr_only("sort: invalid option for key: `x`");
+}
+
+#[test]
+fn test_keys_invalid_field_zero() {
+    new_ucmd!()
+        .args(&["-k", "0.1"])
+        .fails()
+        .stderr_only("sort: field index was 0");
+}
+
+#[test]
+fn test_keys_invalid_char_zero() {
+    new_ucmd!()
+        .args(&["-k", "1.0"])
+        .fails()
+        .stderr_only("sort: invalid character index 0 in `1.0` for the start position of a field");
+}
+
+#[test]
+fn test_keys_with_options() {
+    let input = "aa 3 cc\ndd 1 ff\ngg 2 cc\n";
+    for param in &[
+        &["-k", "2,2n"][..],
+        &["-k", "2n,2"][..],
+        &["-k", "2,2", "-n"][..],
+    ] {
+        new_ucmd!()
+            .args(param)
+            .pipe_in(input)
+            .succeeds()
+            .stdout_only("dd 1 ff\ngg 2 cc\naa 3 cc\n");
+    }
+}
+
+#[test]
+fn test_keys_with_options_blanks_start() {
+    let input = "aa   3 cc\ndd  1 ff\ngg         2 cc\n";
+    for param in &[&["-k", "2b,2"][..], &["-k", "2,2", "-b"][..]] {
+        new_ucmd!()
+            .args(param)
+            .pipe_in(input)
+            .succeeds()
+            .stdout_only("dd  1 ff\ngg         2 cc\naa   3 cc\n");
+    }
+}
+
+#[test]
+fn test_keys_blanks_with_char_idx() {
+    test_helper("keys_blanks", &["-k 1.2b"])
+}
+
+#[test]
+fn test_keys_with_options_blanks_end() {
+    let input = "a  b
+a b
+a   b
+";
+    new_ucmd!()
+        .args(&["-k", "1,2.1b", "-s"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only(
+            "a   b
+a  b
+a b
+",
+        );
+}
+
+#[test]
+fn test_keys_stable() {
+    let input = "a  b
+a b
+a   b
+";
+    new_ucmd!()
+        .args(&["-k", "1,2.1", "-s"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only(
+            "a  b
+a b
+a   b
+",
+        );
+}
+
+#[test]
+fn test_keys_empty_match() {
+    let input = "a a a a
+aaaa
+";
+    new_ucmd!()
+        .args(&["-k", "1,1", "-t", "a"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only(input);
+}
+
+#[test]
+fn test_keys_negative_size_match() {
+    // If the end of a field is before its start, we should not crash.
+    // Debug output should report "no match for key" at the start position (i.e. the later position).
+    test_helper("keys_negative_size", &["-k 3,1"]);
+}
+
 #[test]
 fn test_zero_terminated() {
-    test_helper("zero-terminated", "-z");
+    test_helper("zero-terminated", &["-z"]);
 }
 
 #[test]
@@ -307,6 +627,18 @@ fn test_merge_unique() {
         .stdout_only_fixture("merge_ints_interleaved.expected");
 }
 
+#[test]
+fn test_merge_stable() {
+    new_ucmd!()
+        .arg("-m")
+        .arg("--stable")
+        .arg("-n")
+        .arg("merge_stable_1.txt")
+        .arg("merge_stable_2.txt")
+        .succeeds()
+        .stdout_only_fixture("merge_stable.expected");
+}
+
 #[test]
 fn test_merge_reversed() {
     new_ucmd!()
@@ -338,7 +670,7 @@ fn test_check() {
         .arg("-c")
         .arg("check_fail.txt")
         .fails()
-        .stdout_is("sort: disorder in line 4\n");
+        .stdout_is("sort: check_fail.txt:6: disorder: 5\n");
 
     new_ucmd!()
         .arg("-c")
@@ -356,10 +688,52 @@ fn test_check_silent() {
         .stdout_is("");
 }
 
-fn test_helper(file_name: &str, args: &str) {
-    new_ucmd!()
-        .arg(args)
-        .arg(format!("{}{}", file_name, ".txt"))
-        .succeeds()
-        .stdout_is_fixture(format!("{}{}", file_name, ".expected"));
+#[test]
+fn test_dictionary_and_nonprinting_conflicts() {
+    let conflicting_args = ["n", "h", "g", "M"];
+    for restricted_arg in &["d", "i"] {
+        for conflicting_arg in &conflicting_args {
+            new_ucmd!()
+                .arg(&format!("-{}{}", restricted_arg, conflicting_arg))
+                .fails();
+        }
+        for conflicting_arg in &conflicting_args {
+            new_ucmd!()
+                .args(&[
+                    format!("-{}", restricted_arg).as_str(),
+                    "-k",
+                    &format!("1,1{}", conflicting_arg),
+                ])
+                .succeeds();
+        }
+        for conflicting_arg in &conflicting_args {
+            // FIXME: this should ideally fail.
+            new_ucmd!()
+                .args(&["-k", &format!("1{},1{}", restricted_arg, conflicting_arg)])
+                .succeeds();
+        }
+    }
+}
+
+#[test]
+fn test_trailing_separator() {
+    new_ucmd!()
+        .args(&["-t", "x", "-k", "1,1"])
+        .pipe_in("aax\naaa\n")
+        .succeeds()
+        .stdout_is("aax\naaa\n");
+}
+
+#[test]
+fn test_nonexistent_file() {
+    new_ucmd!()
+        .arg("nonexistent.txt")
+        .fails()
+        .status_code(2)
+        .stderr_only(
+            #[cfg(not(windows))]
+            "sort: cannot read: \"nonexistent.txt\": No such file or directory (os error 2)",
+            #[cfg(windows)]
+            "sort: cannot read: \"nonexistent.txt\": The system cannot find the file specified. (os error 2)",
+        );
 }

tests/by-util/test_split.rs

@@ -4,11 +4,15 @@ extern crate regex;
 use self::rand::{thread_rng, Rng};
 use self::regex::Regex;
 use crate::common::util::*;
+use rand::SeedableRng;
 #[cfg(not(windows))]
 use std::env;
-use std::fs::{read_dir, File};
 use std::io::Write;
 use std::path::Path;
+use std::{
+    fs::{read_dir, File},
+    io::BufWriter,
+};
 
 fn random_chars(n: usize) -> String {
     thread_rng()
@@ -58,7 +62,7 @@ impl Glob {
         files.sort();
         let mut data: Vec<u8> = vec![];
         for name in &files {
-            data.extend(self.directory.read(name).into_bytes());
+            data.extend(self.directory.read_bytes(name));
         }
         data
     }
@@ -81,20 +85,30 @@ impl RandomFile {
     }
 
     fn add_bytes(&mut self, bytes: usize) {
-        let chunk_size: usize = if bytes >= 1024 { 1024 } else { bytes };
-        let mut n = bytes;
-        while n > chunk_size {
-            let _ = write!(self.inner, "{}", random_chars(chunk_size));
-            n -= chunk_size;
+        // Note that just writing random characters isn't enough to cover all
+        // cases. We need truly random bytes.
+        let mut writer = BufWriter::new(&self.inner);
+
+        // Seed the rng so as to avoid spurious test failures.
+        let mut rng = rand::rngs::StdRng::seed_from_u64(123);
+        let mut buffer = [0; 1024];
+        let mut remaining_size = bytes;
+
+        while remaining_size > 0 {
+            let to_write = std::cmp::min(remaining_size, buffer.len());
+            let buf = &mut buffer[..to_write];
+            rng.fill(buf);
+            writer.write(buf).unwrap();
+
+            remaining_size -= to_write;
         }
-        let _ = write!(self.inner, "{}", random_chars(n));
     }
 
     /// Add n lines each of size `RandomFile::LINESIZE`
     fn add_lines(&mut self, lines: usize) {
         let mut n = lines;
         while n > 0 {
-            let _ = writeln!(self.inner, "{}", random_chars(RandomFile::LINESIZE));
+            writeln!(self.inner, "{}", random_chars(RandomFile::LINESIZE)).unwrap();
             n -= 1;
         }
     }
@@ -104,18 +118,18 @@ impl RandomFile {
 fn test_split_default() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_default";
-    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     RandomFile::new(&at, name).add_lines(2000);
     ucmd.args(&[name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     assert_eq!(glob.count(), 2);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_numeric_prefixed_chunks_by_bytes() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_num_prefixed_chunks_by_bytes";
-    let glob = Glob::new(&at, ".", r"a\d\d$");
     RandomFile::new(&at, name).add_bytes(10000);
     ucmd.args(&[
         "-d", // --numeric-suffixes
@@ -123,52 +137,89 @@ fn test_split_numeric_prefixed_chunks_by_bytes() {
         "1000", name, "a",
     ])
     .succeeds();
+
+    let glob = Glob::new(&at, ".", r"a\d\d$");
     assert_eq!(glob.count(), 10);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    for filename in glob.collect() {
+        assert_eq!(glob.directory.metadata(&filename).len(), 1000);
+    }
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_str_prefixed_chunks_by_bytes() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_str_prefixed_chunks_by_bytes";
-    let glob = Glob::new(&at, ".", r"b[[:alpha:]][[:alpha:]]$");
     RandomFile::new(&at, name).add_bytes(10000);
+    // Important that this is less than 1024 since that's our internal buffer
+    // size. Good to test that we don't overshoot.
     ucmd.args(&["-b", "1000", name, "b"]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"b[[:alpha:]][[:alpha:]]$");
     assert_eq!(glob.count(), 10);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    for filename in glob.collect() {
+        assert_eq!(glob.directory.metadata(&filename).len(), 1000);
+    }
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+// This is designed to test what happens when the desired part size is not a
+// multiple of the buffer size and we hopefully don't overshoot the desired part
+// size.
+#[test]
+fn test_split_bytes_prime_part_size() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "test_split_bytes_prime_part_size";
+    RandomFile::new(&at, name).add_bytes(10000);
+    // 1753 is prime and greater than the buffer size, 1024.
+    ucmd.args(&["-b", "1753", name, "b"]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"b[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 6);
+    let mut fns = glob.collect();
+    // glob.collect() is not guaranteed to return in sorted order, so we sort.
+    fns.sort();
+    for i in 0..5 {
+        assert_eq!(glob.directory.metadata(&fns[i]).len(), 1753);
+    }
+    assert_eq!(glob.directory.metadata(&fns[5]).len(), 1235);
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_num_prefixed_chunks_by_lines() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_num_prefixed_chunks_by_lines";
-    let glob = Glob::new(&at, ".", r"c\d\d$");
     RandomFile::new(&at, name).add_lines(10000);
     ucmd.args(&["-d", "-l", "1000", name, "c"]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"c\d\d$");
     assert_eq!(glob.count(), 10);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_str_prefixed_chunks_by_lines() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_str_prefixed_chunks_by_lines";
-    let glob = Glob::new(&at, ".", r"d[[:alpha:]][[:alpha:]]$");
     RandomFile::new(&at, name).add_lines(10000);
     ucmd.args(&["-l", "1000", name, "d"]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"d[[:alpha:]][[:alpha:]]$");
     assert_eq!(glob.count(), 10);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_additional_suffix() {
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "split_additional_suffix";
-    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]].txt$");
     RandomFile::new(&at, name).add_lines(2000);
     ucmd.args(&["--additional-suffix", ".txt", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]].txt$");
     assert_eq!(glob.count(), 2);
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 // note: the test_filter* tests below are unix-only
@@ -182,15 +233,16 @@ fn test_filter() {
     // like `test_split_default()` but run a command before writing
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "filtered";
-    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     let n_lines = 3;
     RandomFile::new(&at, name).add_lines(n_lines);
 
     // change all characters to 'i'
     ucmd.args(&["--filter=sed s/./i/g > $FILE", name])
         .succeeds();
+
     // assert all characters are 'i' / no character is not 'i'
     // (assert that command succeded)
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     assert!(
         glob.collate().iter().find(|&&c| {
             // is not i
@@ -209,7 +261,6 @@ fn test_filter_with_env_var_set() {
     // implemented like `test_split_default()` but run a command before writing
     let (at, mut ucmd) = at_and_ucmd!();
     let name = "filtered";
-    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     let n_lines = 3;
     RandomFile::new(&at, name).add_lines(n_lines);
 
@@ -217,7 +268,9 @@ fn test_filter_with_env_var_set() {
     env::set_var("FILE", &env_var_value);
     ucmd.args(&[format!("--filter={}", "cat > $FILE").as_str(), name])
         .succeeds();
-    assert_eq!(glob.collate(), at.read(name).into_bytes());
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.collate(), at.read_bytes(name));
     assert!(env::var("FILE").unwrap_or("var was unset".to_owned()) == env_var_value);
 }
 

tests/by-util/test_stat.rs

@@ -5,69 +5,6 @@ use crate::common::util::*;
 extern crate stat;
 pub use self::stat::*;
 
-#[cfg(test)]
-mod test_fsext {
-    use super::*;
-
-    #[test]
-    fn test_access() {
-        assert_eq!("drwxr-xr-x", pretty_access(S_IFDIR | 0o755));
-        assert_eq!("-rw-r--r--", pretty_access(S_IFREG | 0o644));
-        assert_eq!("srw-r-----", pretty_access(S_IFSOCK | 0o640));
-        assert_eq!("lrw-r-xr-x", pretty_access(S_IFLNK | 0o655));
-        assert_eq!("?rw-r-xr-x", pretty_access(0o655));
-
-        assert_eq!(
-            "brwSr-xr-x",
-            pretty_access(S_IFBLK | S_ISUID as mode_t | 0o655)
-        );
-        assert_eq!(
-            "brwsr-xr-x",
-            pretty_access(S_IFBLK | S_ISUID as mode_t | 0o755)
-        );
-
-        assert_eq!(
-            "prw---sr--",
-            pretty_access(S_IFIFO | S_ISGID as mode_t | 0o614)
-        );
-        assert_eq!(
-            "prw---Sr--",
-            pretty_access(S_IFIFO | S_ISGID as mode_t | 0o604)
-        );
-
-        assert_eq!(
-            "c---r-xr-t",
-            pretty_access(S_IFCHR | S_ISVTX as mode_t | 0o055)
-        );
-        assert_eq!(
-            "c---r-xr-T",
-            pretty_access(S_IFCHR | S_ISVTX as mode_t | 0o054)
-        );
-    }
-
-    #[test]
-    fn test_file_type() {
-        assert_eq!("block special file", pretty_filetype(S_IFBLK, 0));
-        assert_eq!("character special file", pretty_filetype(S_IFCHR, 0));
-        assert_eq!("regular file", pretty_filetype(S_IFREG, 1));
-        assert_eq!("regular empty file", pretty_filetype(S_IFREG, 0));
-        assert_eq!("weird file", pretty_filetype(0, 0));
-    }
-
-    #[test]
-    fn test_fs_type() {
-        assert_eq!("ext2/ext3", pretty_fstype(0xEF53));
-        assert_eq!("tmpfs", pretty_fstype(0x01021994));
-        assert_eq!("nfs", pretty_fstype(0x6969));
-        assert_eq!("btrfs", pretty_fstype(0x9123683e));
-        assert_eq!("xfs", pretty_fstype(0x58465342));
-        assert_eq!("zfs", pretty_fstype(0x2FC12FC1));
-        assert_eq!("ntfs", pretty_fstype(0x5346544e));
-        assert_eq!("fat", pretty_fstype(0x4006));
-        assert_eq!("UNKNOWN (0x1234)", pretty_fstype(0x1234));
-    }
-}
-
 #[test]
 fn test_scanutil() {
     assert_eq!(Some((-5, 2)), "-5zxc".scan_num::<i32>());
@@ -159,10 +96,10 @@ fn test_invalid_option() {
     new_ucmd!().arg("-w").arg("-q").arg("/").fails();
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 const NORMAL_FMTSTR: &'static str =
     "%a %A %b %B %d %D %f %F %g %G %h %i %m %n %o %s %u %U %x %X %y %Y %z %Z"; // avoid "%w %W" (birth/creation) due to `stat` limitations and linux kernel & rust version capability variations
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux"))]
 const DEV_FMTSTR: &'static str =
     "%a %A %b %B %d %D %f %F %g %G %h %i %m %n %o %s (%t/%T) %u %U %w %W %x %X %y %Y %z %Z";
 #[cfg(target_os = "linux")]
@@ -188,19 +125,26 @@ fn test_fs_format() {
         .stdout_is(expected_result(&args));
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_terse_normal_format() {
     // note: contains birth/creation date which increases test fragility
     // * results may vary due to built-in `stat` limitations as well as linux kernel and rust version capability variations
     let args = ["-t", "/"];
-    let actual = new_ucmd!().args(&args).run().stdout;
+    let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
     let expect = expected_result(&args);
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
-    let v_actual: Vec<&str> = actual.split(' ').collect();
-    let v_expect: Vec<&str> = expect.split(' ').collect();
+    let v_actual: Vec<&str> = actual.trim().split(' ').collect();
+    let mut v_expect: Vec<&str> = expect.trim().split(' ').collect();
     assert!(!v_expect.is_empty());
+
+    // uu_stat does not support selinux
+    if v_actual.len() == v_expect.len() - 1 && v_expect[v_expect.len() - 1].contains(":") {
+        // assume last element contains: `SELinux security context string`
+        v_expect.pop();
+    }
+
     // * allow for inequality if `stat` (aka, expect) returns "0" (unknown value)
     assert!(
         expect == "0"
@@ -212,11 +156,11 @@ fn test_terse_normal_format() {
     );
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_format_created_time() {
-    let args = ["-c", "%w", "/boot"];
-    let actual = new_ucmd!().args(&args).run().stdout;
+    let args = ["-c", "%w", "/bin"];
+    let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
     let expect = expected_result(&args);
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -236,11 +180,11 @@ fn test_format_created_time() {
     );
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_format_created_seconds() {
-    let args = ["-c", "%W", "/boot"];
-    let actual = new_ucmd!().args(&args).run().stdout;
+    let args = ["-c", "%W", "/bin"];
+    let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
     let expect = expected_result(&args);
     println!("actual: {:?}", actual);
     println!("expect: {:?}", expect);
@@ -260,65 +204,97 @@ fn test_format_created_seconds() {
     );
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_normal_format() {
-    let args = ["-c", NORMAL_FMTSTR, "/boot"];
+    let args = ["-c", NORMAL_FMTSTR, "/bin"];
     new_ucmd!()
         .args(&args)
-        .run()
+        .succeeds()
         .stdout_is(expected_result(&args));
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
-fn test_follow_symlink() {
-    let args = ["-L", "-c", DEV_FMTSTR, "/dev/cdrom"];
-    new_ucmd!()
-        .args(&args)
-        .run()
-        .stdout_is(expected_result(&args));
+fn test_symlinks() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let mut tested: bool = false;
+    // arbitrarily chosen symlinks with hope that the CI environment provides at least one of them
+    for file in vec![
+        "/bin/sh",
+        "/bin/sudoedit",
+        "/usr/bin/ex",
+        "/etc/localtime",
+        "/etc/aliases",
+    ] {
+        if at.file_exists(file) && at.is_symlink(file) {
+            tested = true;
+            let args = ["-c", NORMAL_FMTSTR, file];
+            scene
+                .ucmd()
+                .args(&args)
+                .succeeds()
+                .stdout_is(expected_result(&args));
+            // -L, --dereference    follow links
+            let args = ["-L", "-c", NORMAL_FMTSTR, file];
+            scene
+                .ucmd()
+                .args(&args)
+                .succeeds()
+                .stdout_is(expected_result(&args));
+        }
+    }
+    if !tested {
+        panic!("No symlink found to test in this environment");
+    }
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
-fn test_symlink() {
-    let args = ["-c", DEV_FMTSTR, "/dev/cdrom"];
-    new_ucmd!()
-        .args(&args)
-        .run()
-        .stdout_is(expected_result(&args));
-}
-
-#[test]
-#[cfg(target_os = "linux")]
 fn test_char() {
-    let args = ["-c", DEV_FMTSTR, "/dev/pts/ptmx"];
+    // TODO: "(%t) (%x) (%w)" deviate from GNU stat for `character special file` on macOS
+    // Diff < left / right > :
+    // <"(f0000) (2021-05-20 23:08:03.442555000 +0200) (1970-01-01 01:00:00.000000000 +0100)\n"
+    // >"(f) (2021-05-20 23:08:03.455598000 +0200) (-)\n"
+    let args = [
+        "-c",
+        #[cfg(target_os = "linux")]
+        DEV_FMTSTR,
+        #[cfg(target_os = "linux")]
+        "/dev/pts/ptmx",
+        #[cfg(any(target_vendor = "apple"))]
+        "%a %A %b %B %d %D %f %F %g %G %h %i %m %n %o %s (/%T) %u %U %W %X %y %Y %z %Z",
+        #[cfg(any(target_vendor = "apple"))]
+        "/dev/ptmx",
+    ];
     new_ucmd!()
         .args(&args)
-        .run()
+        .succeeds()
         .stdout_is(expected_result(&args));
 }
 
+#[cfg(any(target_os = "linux", target_vendor = "apple"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_multi_files() {
     let args = [
         "-c",
         NORMAL_FMTSTR,
         "/dev",
         "/usr/lib",
+        #[cfg(target_os = "linux")]
         "/etc/fstab",
         "/var",
     ];
     new_ucmd!()
         .args(&args)
-        .run()
+        .succeeds()
         .stdout_is(expected_result(&args));
 }
 
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
-#[cfg(target_os = "linux")]
 fn test_printf() {
     let args = [
         "--printf=123%-# 15q\\r\\\"\\\\\\a\\b\\e\\f\\v%+020.23m\\x12\\167\\132\\112\\n",
@@ -326,16 +302,21 @@ fn test_printf() {
     ];
     new_ucmd!()
         .args(&args)
-        .run()
+        .succeeds()
         .stdout_is(expected_result(&args));
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 fn expected_result(args: &[&str]) -> String {
-    TestScenario::new(util_name!())
-        .cmd_keepenv(util_name!())
+    #[cfg(target_os = "linux")]
+    let util_name = util_name!();
+    #[cfg(target_vendor = "apple")]
+    let util_name = format!("g{}", util_name!());
+
+    TestScenario::new(&util_name)
+        .cmd_keepenv(util_name)
         .env("LANGUAGE", "C")
         .args(args)
-        .run()
-        .stdout
+        .succeeds()
+        .stdout_move_str()
 }

tests/by-util/test_stdbuf.rs

@@ -1,13 +1,64 @@
+#[cfg(not(target_os = "windows"))]
 use crate::common::util::*;
 
+#[cfg(not(target_os = "windows"))]
 #[test]
 fn test_stdbuf_unbuffered_stdout() {
-    if cfg!(target_os = "linux") {
-        // This is a basic smoke test
-        new_ucmd!()
-            .args(&["-o0", "head"])
-            .pipe_in("The quick brown fox jumps over the lazy dog.")
-            .run()
-            .stdout_is("The quick brown fox jumps over the lazy dog.");
-    }
+    // This is a basic smoke test
+    new_ucmd!()
+        .args(&["-o0", "head"])
+        .pipe_in("The quick brown fox jumps over the lazy dog.")
+        .run()
+        .stdout_is("The quick brown fox jumps over the lazy dog.");
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_stdbuf_line_buffered_stdout() {
+    new_ucmd!()
+        .args(&["-oL", "head"])
+        .pipe_in("The quick brown fox jumps over the lazy dog.")
+        .run()
+        .stdout_is("The quick brown fox jumps over the lazy dog.");
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_stdbuf_no_buffer_option_fails() {
+    new_ucmd!().args(&["head"]).fails().stderr_is(
+        "error: The following required arguments were not provided:\n    \
+         --error <MODE>\n    \
+         --input <MODE>\n    \
+         --output <MODE>\n\n\
+         USAGE:\n    \
+         stdbuf OPTION... COMMAND\n\n\
+         For more information try --help",
+    );
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_stdbuf_trailing_var_arg() {
+    new_ucmd!()
+        .args(&["-i", "1024", "tail", "-1"])
+        .pipe_in("The quick brown fox\njumps over the lazy dog.")
+        .run()
+        .stdout_is("jumps over the lazy dog.");
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_stdbuf_line_buffering_stdin_fails() {
+    new_ucmd!().args(&["-i", "L", "head"]).fails().stderr_is(
+        "stdbuf: line buffering stdin is meaningless\nTry 'stdbuf --help' for more information.",
+    );
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_stdbuf_invalid_mode_fails() {
+    new_ucmd!()
+        .args(&["-i", "1024R", "head"])
+        .fails()
+        .stderr_is("stdbuf: invalid mode 1024R\nTry 'stdbuf --help' for more information.");
 }

tests/by-util/test_sum.rs

@@ -59,9 +59,7 @@ fn test_invalid_file() {
 
     at.mkdir("a");
 
-    ucmd.arg("a")
-        .fails()
-        .stderr_is("sum: error: 'a' Is a directory");
+    ucmd.arg("a").fails().stderr_is("sum: 'a' Is a directory");
 }
 
 #[test]
@@ -70,5 +68,5 @@ fn test_invalid_metadata() {
 
     ucmd.arg("b")
         .fails()
-        .stderr_is("sum: error: 'b' No such file or directory");
+        .stderr_is("sum: 'b' No such file or directory");
 }

tests/by-util/test_sync.rs

@@ -5,8 +5,7 @@ use tempfile::tempdir;
 
 #[test]
 fn test_sync_default() {
-    let result = new_ucmd!().run();
-    assert!(result.success);
+    new_ucmd!().succeeds();
 }
 
 #[test]
@@ -18,8 +17,10 @@ fn test_sync_incorrect_arg() {
 fn test_sync_fs() {
     let temporary_directory = tempdir().unwrap();
     let temporary_path = fs::canonicalize(temporary_directory.path()).unwrap();
-    let result = new_ucmd!().arg("--file-system").arg(&temporary_path).run();
-    assert!(result.success);
+    new_ucmd!()
+        .arg("--file-system")
+        .arg(&temporary_path)
+        .succeeds();
 }
 
 #[test]
@@ -27,12 +28,14 @@ fn test_sync_data() {
     // Todo add a second arg
     let temporary_directory = tempdir().unwrap();
     let temporary_path = fs::canonicalize(temporary_directory.path()).unwrap();
-    let result = new_ucmd!().arg("--data").arg(&temporary_path).run();
-    assert!(result.success);
+    new_ucmd!().arg("--data").arg(&temporary_path).succeeds();
 }
 
 #[test]
 fn test_sync_no_existing_files() {
-    let result = new_ucmd!().arg("--data").arg("do-no-exist").fails();
-    assert!(result.stderr.contains("error: cannot stat"));
+    new_ucmd!()
+        .arg("--data")
+        .arg("do-no-exist")
+        .fails()
+        .stderr_contains("cannot stat");
 }

tests/by-util/test_tac.rs

@@ -52,18 +52,19 @@ fn test_single_non_newline_separator_before() {
 
 #[test]
 fn test_invalid_input() {
-    let (_, mut ucmd) = at_and_ucmd!();
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
 
-    ucmd.arg("b")
-        .run()
-        .stderr
-        .contains("tac: error: failed to open 'b' for reading");
-
-    let (at, mut ucmd) = at_and_ucmd!();
+    scene
+        .ucmd()
+        .arg("b")
+        .fails()
+        .stderr_contains("failed to open 'b' for reading: No such file or directory");
 
     at.mkdir("a");
-    ucmd.arg("a")
-        .run()
-        .stderr
-        .contains("tac: error: failed to read 'a'");
+    scene
+        .ucmd()
+        .arg("a")
+        .fails()
+        .stderr_contains("dir: read error: Invalid argument");
 }

tests/by-util/test_tail.rs

@@ -226,8 +226,8 @@ fn test_bytes_big() {
         .arg(FILE)
         .arg("-c")
         .arg(format!("{}", N_ARG))
-        .run()
-        .stdout;
+        .succeeds()
+        .stdout_move_str();
     let expected = at.read(EXPECTED_FILE);
 
     assert_eq!(result.len(), expected.len());
@@ -340,6 +340,51 @@ fn test_negative_indexing() {
 
     let negative_bytes_index = new_ucmd!().arg("-c").arg("-20").arg(FOOBAR_TXT).run();
 
-    assert_eq!(positive_lines_index.stdout, negative_lines_index.stdout);
-    assert_eq!(positive_bytes_index.stdout, negative_bytes_index.stdout);
+    assert_eq!(positive_lines_index.stdout(), negative_lines_index.stdout());
+    assert_eq!(positive_bytes_index.stdout(), negative_bytes_index.stdout());
+}
+
+#[test]
+fn test_sleep_interval() {
+    new_ucmd!().arg("-s").arg("10").arg(FOOBAR_TXT).succeeds();
+}
+
+/// Test for reading all but the first NUM bytes: `tail -c +3`.
+#[test]
+fn test_positive_bytes() {
+    new_ucmd!()
+        .args(&["-c", "+3"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("cde");
+}
+
+/// Test for reading all bytes, specified by `tail -c +0`.
+#[test]
+fn test_positive_zero_bytes() {
+    new_ucmd!()
+        .args(&["-c", "+0"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("abcde");
+}
+
+/// Test for reading all but the first NUM lines: `tail -n +3`.
+#[test]
+fn test_positive_lines() {
+    new_ucmd!()
+        .args(&["-n", "+3"])
+        .pipe_in("a\nb\nc\nd\ne\n")
+        .succeeds()
+        .stdout_is("c\nd\ne\n");
+}
+
+/// Test for reading all lines, specified by `tail -n +0`.
+#[test]
+fn test_positive_zero_lines() {
+    new_ucmd!()
+        .args(&["-n", "+0"])
+        .pipe_in("a\nb\nc\nd\ne\n")
+        .succeeds()
+        .stdout_is("a\nb\nc\nd\ne\n");
 }

tests/by-util/test_test.rs

@@ -2,6 +2,7 @@
 // This file is part of the uutils coreutils package.
 //
 // (c) mahkoh (ju.orth [at] gmail [dot] com)
+// (c) Daniel Rocco <drocco@gmail.com>
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
@@ -9,11 +10,483 @@
 
 use crate::common::util::*;
 
+#[test]
+fn test_empty_test_equivalent_to_false() {
+    new_ucmd!().run().status_code(1);
+}
+
+#[test]
+fn test_empty_string_is_false() {
+    new_ucmd!().arg("").run().status_code(1);
+}
+
+#[test]
+fn test_solo_not() {
+    new_ucmd!().arg("!").succeeds();
+}
+
+#[test]
+fn test_solo_and_or_or_is_a_literal() {
+    // /bin/test '' -a '' => 1; so test(1) must interpret `-a` by itself as
+    // a literal string
+    new_ucmd!().arg("-a").succeeds();
+    new_ucmd!().arg("-o").succeeds();
+}
+
+#[test]
+fn test_double_not_is_false() {
+    new_ucmd!().args(&["!", "!"]).run().status_code(1);
+}
+
+#[test]
+fn test_and_not_is_false() {
+    new_ucmd!().args(&["-a", "!"]).run().status_code(1);
+}
+
+#[test]
+fn test_not_and_is_false() {
+    // `-a` is a literal here & has nonzero length
+    new_ucmd!().args(&["!", "-a"]).run().status_code(1);
+}
+
+#[test]
+fn test_not_and_not_succeeds() {
+    new_ucmd!().args(&["!", "-a", "!"]).succeeds();
+}
+
+#[test]
+fn test_simple_or() {
+    new_ucmd!().args(&["foo", "-o", ""]).succeeds();
+}
+
+#[test]
+fn test_negated_or() {
+    new_ucmd!()
+        .args(&["!", "foo", "-o", "bar"])
+        .run()
+        .status_code(1);
+    new_ucmd!().args(&["foo", "-o", "!", "bar"]).succeeds();
+    new_ucmd!()
+        .args(&["!", "foo", "-o", "!", "bar"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+fn test_strlen_of_nothing() {
+    // odd but matches GNU, which must interpret -n as a literal here
+    new_ucmd!().arg("-n").succeeds();
+}
+
+#[test]
+fn test_strlen_of_empty() {
+    new_ucmd!().args(&["-n", ""]).run().status_code(1);
+
+    // STRING equivalent to -n STRING
+    new_ucmd!().arg("").run().status_code(1);
+}
+
+#[test]
+fn test_nothing_is_empty() {
+    // -z is a literal here and has nonzero length
+    new_ucmd!().arg("-z").succeeds();
+}
+
+#[test]
+fn test_zero_len_of_empty() {
+    new_ucmd!().args(&["-z", ""]).succeeds();
+}
+
+#[test]
+fn test_solo_paren_is_literal() {
+    let scenario = TestScenario::new(util_name!());
+    let tests = [["("], [")"]];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).succeeds();
+    }
+}
+
+#[test]
+fn test_solo_empty_parenthetical_is_error() {
+    new_ucmd!().args(&["(", ")"]).run().status_code(2);
+}
+
+#[test]
+fn test_zero_len_equals_zero_len() {
+    new_ucmd!().args(&["", "=", ""]).succeeds();
+}
+
+#[test]
+fn test_zero_len_not_equals_zero_len_is_false() {
+    new_ucmd!().args(&["", "!=", ""]).run().status_code(1);
+}
+
+#[test]
+fn test_double_equal_is_string_comparison_op() {
+    // undocumented but part of the GNU test suite
+    new_ucmd!().args(&["t", "==", "t"]).succeeds();
+    new_ucmd!().args(&["t", "==", "f"]).run().status_code(1);
+}
+
+#[test]
+fn test_string_comparison() {
+    let scenario = TestScenario::new(util_name!());
+    let tests = [
+        ["foo", "!=", "bar"],
+        ["contained\nnewline", "=", "contained\nnewline"],
+        ["(", "=", "("],
+        ["(", "!=", ")"],
+        ["!", "=", "!"],
+        ["=", "=", "="],
+    ];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).succeeds();
+    }
+
+    // run the inverse of all these tests
+    for test in &tests {
+        scenario
+            .ucmd()
+            .arg("!")
+            .args(&test[..])
+            .run()
+            .status_code(1);
+    }
+}
+
+#[test]
+#[ignore = "fixme: error reporting"]
+fn test_dangling_string_comparison_is_error() {
+    new_ucmd!()
+        .args(&["missing_something", "="])
+        .run()
+        .status_code(2)
+        .stderr_is("test: missing argument after ‘=’");
+}
+
+#[test]
+fn test_stringop_is_literal_after_bang() {
+    let scenario = TestScenario::new(util_name!());
+    let tests = [
+        ["!", "="],
+        ["!", "!="],
+        ["!", "-eq"],
+        ["!", "-ne"],
+        ["!", "-lt"],
+        ["!", "-le"],
+        ["!", "-gt"],
+        ["!", "-ge"],
+        ["!", "-ef"],
+        ["!", "-nt"],
+        ["!", "-ot"],
+    ];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).run().status_code(1);
+    }
+}
+
+#[test]
+fn test_a_bunch_of_not() {
+    new_ucmd!()
+        .args(&["!", "", "!=", "", "-a", "!", "", "!=", ""])
+        .succeeds();
+}
+
+#[test]
+fn test_pseudofloat_equal() {
+    new_ucmd!().args(&["123.45", "=", "123.45"]).succeeds();
+}
+
+#[test]
+fn test_pseudofloat_not_equal() {
+    new_ucmd!().args(&["123.45", "!=", "123.450"]).succeeds();
+}
+
+#[test]
+fn test_negative_arg_is_a_string() {
+    new_ucmd!().arg("-12345").succeeds();
+    new_ucmd!().arg("--qwert").succeeds();
+}
+
+#[test]
+fn test_some_int_compares() {
+    let scenario = TestScenario::new(util_name!());
+
+    let tests = [
+        ["0", "-eq", "0"],
+        ["0", "-ne", "1"],
+        ["421", "-lt", "3720"],
+        ["0", "-le", "0"],
+        ["11", "-gt", "10"],
+        ["1024", "-ge", "512"],
+        ["9223372036854775806", "-le", "9223372036854775807"],
+    ];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).succeeds();
+    }
+}
+
+#[test]
+#[ignore = "fixme: evaluation error (code 1); GNU returns 0"]
+fn test_values_greater_than_i64_allowed() {
+    new_ucmd!()
+        .args(&["9223372036854775808", "-gt", "0"])
+        .succeeds();
+}
+
+#[test]
+fn test_negative_int_compare() {
+    let scenario = TestScenario::new(util_name!());
+
+    let tests = [
+        ["-1", "-eq", "-1"],
+        ["-1", "-ne", "-2"],
+        ["-3720", "-lt", "-421"],
+        ["-10", "-le", "-10"],
+        ["-21", "-gt", "-22"],
+        ["-128", "-ge", "-256"],
+        ["-9223372036854775808", "-le", "-9223372036854775807"],
+    ];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).succeeds();
+    }
+}
+
+#[test]
+fn test_float_inequality_is_error() {
+    new_ucmd!()
+        .args(&["123.45", "-ge", "6"])
+        .run()
+        .status_code(2)
+        .stderr_is("test: invalid integer ‘123.45’");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_invalid_utf8_integer_compare() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    let source = [0x66, 0x6f, 0x80, 0x6f];
+    let arg = OsStr::from_bytes(&source[..]);
+
+    let mut cmd = new_ucmd!();
+    cmd.arg("123").arg("-ne");
+    cmd.raw.arg(arg);
+
+    cmd.run()
+        .status_code(2)
+        .stderr_is("test: invalid integer ‘fo<66>o’");
+
+    let mut cmd = new_ucmd!();
+    cmd.raw.arg(arg);
+    cmd.arg("-eq").arg("456");
+
+    cmd.run()
+        .status_code(2)
+        .stderr_is("test: invalid integer ‘fo<66>o’");
+}
+
+#[test]
+#[ignore = "fixme: parse/evaluation error (code 2); GNU returns 1"]
+fn test_file_is_itself() {
+    new_ucmd!()
+        .args(&["regular_file", "-ef", "regular_file"])
+        .succeeds();
+}
+
+#[test]
+#[ignore = "fixme: parse/evaluation error (code 2); GNU returns 1"]
+fn test_file_is_newer_than_and_older_than_itself() {
+    // odd but matches GNU
+    new_ucmd!()
+        .args(&["regular_file", "-nt", "regular_file"])
+        .run()
+        .status_code(1);
+    new_ucmd!()
+        .args(&["regular_file", "-ot", "regular_file"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+#[ignore = "todo: implement these"]
+fn test_newer_file() {
+    let scenario = TestScenario::new(util_name!());
+
+    scenario.cmd("touch").arg("newer_file").succeeds();
+    scenario
+        .cmd("touch")
+        .args(&["-m", "-d", "last Thursday", "regular_file"])
+        .succeeds();
+
+    scenario
+        .ucmd()
+        .args(&["newer_file", "-nt", "regular_file"])
+        .succeeds();
+    scenario
+        .ucmd()
+        .args(&["regular_file", "-ot", "newer_file"])
+        .succeeds();
+}
+
+#[test]
+fn test_file_exists() {
+    new_ucmd!().args(&["-e", "regular_file"]).succeeds();
+}
+
+#[test]
+fn test_nonexistent_file_does_not_exist() {
+    new_ucmd!()
+        .args(&["-e", "nonexistent_file"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+fn test_nonexistent_file_is_not_regular() {
+    new_ucmd!()
+        .args(&["-f", "nonexistent_file"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+fn test_file_exists_and_is_regular() {
+    new_ucmd!().args(&["-f", "regular_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))] // FIXME: implement on Windows
+fn test_file_is_readable() {
+    new_ucmd!().args(&["-r", "regular_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))] // FIXME: implement on Windows
+fn test_file_is_not_readable() {
+    let scenario = TestScenario::new(util_name!());
+    let mut ucmd = scenario.ucmd();
+    let mut chmod = scenario.cmd("chmod");
+
+    scenario.fixtures.touch("crypto_file");
+    chmod.args(&["u-r", "crypto_file"]).succeeds();
+
+    ucmd.args(&["!", "-r", "crypto_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))] // FIXME: implement on Windows
+fn test_file_is_writable() {
+    new_ucmd!().args(&["-w", "regular_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))] // FIXME: implement on Windows
+fn test_file_is_not_writable() {
+    let scenario = TestScenario::new(util_name!());
+    let mut ucmd = scenario.ucmd();
+    let mut chmod = scenario.cmd("chmod");
+
+    scenario.fixtures.touch("immutable_file");
+    chmod.args(&["u-w", "immutable_file"]).succeeds();
+
+    ucmd.args(&["!", "-w", "immutable_file"]).succeeds();
+}
+
+#[test]
+fn test_file_is_not_executable() {
+    new_ucmd!().args(&["!", "-x", "regular_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))] // FIXME: implement on Windows
+fn test_file_is_executable() {
+    let scenario = TestScenario::new(util_name!());
+    let mut chmod = scenario.cmd("chmod");
+
+    chmod.args(&["u+x", "regular_file"]).succeeds();
+
+    scenario.ucmd().args(&["-x", "regular_file"]).succeeds();
+}
+
+#[test]
+fn test_is_not_empty() {
+    new_ucmd!().args(&["-s", "non_empty_file"]).succeeds();
+}
+
+#[test]
+fn test_nonexistent_file_size_test_is_false() {
+    new_ucmd!()
+        .args(&["-s", "nonexistent_file"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+fn test_not_is_not_empty() {
+    new_ucmd!().args(&["!", "-s", "regular_file"]).succeeds();
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_symlink_is_symlink() {
+    let scenario = TestScenario::new(util_name!());
+    let at = &scenario.fixtures;
+
+    at.symlink_file("regular_file", "symlink");
+
+    // FIXME: implement on Windows
+    scenario.ucmd().args(&["-h", "symlink"]).succeeds();
+    scenario.ucmd().args(&["-L", "symlink"]).succeeds();
+}
+
+#[test]
+fn test_file_is_not_symlink() {
+    let scenario = TestScenario::new(util_name!());
+
+    scenario
+        .ucmd()
+        .args(&["!", "-h", "regular_file"])
+        .succeeds();
+    scenario
+        .ucmd()
+        .args(&["!", "-L", "regular_file"])
+        .succeeds();
+}
+
+#[test]
+fn test_nonexistent_file_is_not_symlink() {
+    let scenario = TestScenario::new(util_name!());
+
+    scenario
+        .ucmd()
+        .args(&["!", "-h", "nonexistent_file"])
+        .succeeds();
+    scenario
+        .ucmd()
+        .args(&["!", "-L", "nonexistent_file"])
+        .succeeds();
+}
+
 #[test]
 fn test_op_prec_and_or_1() {
     new_ucmd!().args(&[" ", "-o", "", "-a", ""]).succeeds();
 }
 
+#[test]
+fn test_op_prec_and_or_1_overridden_by_parentheses() {
+    new_ucmd!()
+        .args(&["(", " ", "-o", "", ")", "-a", ""])
+        .run()
+        .status_code(1);
+}
+
 #[test]
 fn test_op_prec_and_or_2() {
     new_ucmd!()
@@ -22,6 +495,129 @@ fn test_op_prec_and_or_2() {
 }
 
 #[test]
-fn test_or_as_filename() {
-    new_ucmd!().args(&["x", "-a", "-z", "-o"]).fails();
+fn test_op_prec_and_or_2_overridden_by_parentheses() {
+    new_ucmd!()
+        .args(&["", "-a", "(", "", "-o", " ", ")", "-a", " "])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+fn test_negated_boolean_precedence() {
+    let scenario = TestScenario::new(util_name!());
+
+    let tests = [
+        vec!["!", "(", "foo", ")", "-o", "bar"],
+        vec!["!", "", "-o", "", "-a", ""],
+        vec!["!", "(", "", "-a", "", ")", "-o", ""],
+    ];
+
+    for test in &tests {
+        scenario.ucmd().args(&test[..]).succeeds();
+    }
+
+    let negative_tests = [
+        vec!["!", "-n", "", "-a", ""],
+        vec!["", "-a", "", "-o", ""],
+        vec!["!", "", "-a", "", "-o", ""],
+        vec!["!", "(", "", "-a", "", ")", "-a", ""],
+    ];
+
+    for test in &negative_tests {
+        scenario.ucmd().args(&test[..]).run().status_code(1);
+    }
+}
+
+#[test]
+fn test_bang_boolop_precedence() {
+    // For a Boolean combination of two literals, bang inverts the entire expression
+    new_ucmd!().args(&["!", "", "-a", ""]).succeeds();
+    new_ucmd!().args(&["!", "", "-o", ""]).succeeds();
+
+    new_ucmd!()
+        .args(&["!", "a value", "-o", "another value"])
+        .run()
+        .status_code(1);
+
+    // Introducing a UOP — even one that is equivalent to a bare string — causes
+    // bang to invert only the first term
+    new_ucmd!()
+        .args(&["!", "-n", "", "-a", ""])
+        .run()
+        .status_code(1);
+    new_ucmd!()
+        .args(&["!", "", "-a", "-n", ""])
+        .run()
+        .status_code(1);
+
+    // for compound Boolean expressions, bang inverts the _next_ expression
+    // only, not the entire compound expression
+    new_ucmd!()
+        .args(&["!", "", "-a", "", "-a", ""])
+        .run()
+        .status_code(1);
+
+    // parentheses can override this
+    new_ucmd!()
+        .args(&["!", "(", "", "-a", "", "-a", "", ")"])
+        .succeeds();
+}
+
+#[test]
+fn test_inverted_parenthetical_boolop_precedence() {
+    // For a Boolean combination of two literals, bang inverts the entire expression
+    new_ucmd!()
+        .args(&["!", "a value", "-o", "another value"])
+        .run()
+        .status_code(1);
+
+    // only the parenthetical is inverted, not the entire expression
+    new_ucmd!()
+        .args(&["!", "(", "a value", ")", "-o", "another value"])
+        .succeeds();
+}
+
+#[test]
+#[ignore = "fixme: error reporting"]
+fn test_dangling_parenthesis() {
+    new_ucmd!()
+        .args(&["(", "(", "a", "!=", "b", ")", "-o", "-n", "c"])
+        .run()
+        .status_code(2);
+    new_ucmd!()
+        .args(&["(", "(", "a", "!=", "b", ")", "-o", "-n", "c", ")"])
+        .succeeds();
+}
+
+#[test]
+fn test_complicated_parenthesized_expression() {
+    new_ucmd!()
+        .args(&[
+            "(", "(", "!", "(", "a", "=", "b", ")", "-o", "c", "=", "d", ")", "-a", "(", "q", "!=",
+            "r", ")", ")",
+        ])
+        .succeeds();
+}
+
+#[test]
+fn test_erroneous_parenthesized_expression() {
+    new_ucmd!()
+        .args(&["a", "!=", "(", "b", "-a", "b", ")", "!=", "c"])
+        .run()
+        .status_code(2)
+        .stderr_is("test: extra argument ‘b’");
+}
+
+#[test]
+fn test_or_as_filename() {
+    new_ucmd!()
+        .args(&["x", "-a", "-z", "-o"])
+        .run()
+        .status_code(1);
+}
+
+#[test]
+#[ignore = "GNU considers this an error"]
+fn test_strlen_and_nothing() {
+    new_ucmd!().args(&["-n", "a", "-a"]).run().status_code(2);
 }

tests/by-util/test_touch.rs

@@ -29,6 +29,7 @@ fn set_file_times(at: &AtPath, path: &str, atime: FileTime, mtime: FileTime) {
 fn str_to_filetime(format: &str, s: &str) -> FileTime {
     let mut tm = time::strptime(s, format).unwrap();
     tm.tm_utcoff = time::now().tm_utcoff;
+    tm.tm_isdst = -1; // Unknown flag DST
     let ts = tm.to_timespec();
     FileTime::from_unix_time(ts.sec as i64, ts.nsec as u32)
 }
@@ -352,3 +353,72 @@ fn test_touch_set_date() {
     assert_eq!(atime, start_of_year);
     assert_eq!(mtime, start_of_year);
 }
+
+#[test]
+fn test_touch_mtime_dst_succeeds() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_set_mtime_dst_succeeds";
+
+    ucmd.args(&["-m", "-t", "202103140300", file])
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(file));
+
+    let target_time = str_to_filetime("%Y%m%d%H%M", "202103140300");
+    let (_, mtime) = get_file_times(&at, file);
+    assert!(target_time == mtime);
+}
+
+// is_dst_switch_hour returns true if timespec ts is just before the switch
+// to Daylight Saving Time.
+// For example, in EST (UTC-5), Timespec { sec: 1583647200, nsec: 0 }
+// for March 8 2020 01:00:00 AM
+// is just before the switch because on that day clock jumps by 1 hour,
+// so 1 minute after 01:59:00 is 03:00:00.
+fn is_dst_switch_hour(ts: time::Timespec) -> bool {
+    let ts_after = ts + time::Duration::hours(1);
+    let tm = time::at(ts);
+    let tm_after = time::at(ts_after);
+    tm_after.tm_hour == tm.tm_hour + 2
+}
+
+// get_dstswitch_hour returns date string for which touch -m -t fails.
+// For example, in EST (UTC-5), that will be "202003080200" so
+// touch -m -t 202003080200 somefile
+// fails (that date/time does not exist).
+// In other locales it will be a different date/time, and in some locales
+// it doesn't exist at all, in which case this function will return None.
+fn get_dstswitch_hour() -> Option<String> {
+    let now = time::now();
+    // Start from January 1, 2020, 00:00.
+    let mut tm = time::strptime("20200101-0000", "%Y%m%d-%H%M").unwrap();
+    tm.tm_isdst = -1;
+    tm.tm_utcoff = now.tm_utcoff;
+    let mut ts = tm.to_timespec();
+    // Loop through all hours in year 2020 until we find the hour just
+    // before the switch to DST.
+    for _i in 0..(366 * 24) {
+        if is_dst_switch_hour(ts) {
+            let mut tm = time::at(ts);
+            tm.tm_hour = tm.tm_hour + 1;
+            let s = time::strftime("%Y%m%d%H%M", &tm).unwrap().to_string();
+            return Some(s);
+        }
+        ts = ts + time::Duration::hours(1);
+    }
+    None
+}
+
+#[test]
+fn test_touch_mtime_dst_fails() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_set_mtime_dst_fails";
+
+    match get_dstswitch_hour() {
+        Some(s) => {
+            ucmd.args(&["-m", "-t", &s, file]).fails();
+        }
+        None => (),
+    }
+}

tests/by-util/test_tr.rs

@@ -45,6 +45,70 @@ fn test_delete_complement() {
         .stdout_is("ac");
 }
 
+#[test]
+fn test_delete_complement_2() {
+    new_ucmd!()
+        .args(&["-d", "-C", "0-9"])
+        .pipe_in("Phone: 01234 567890")
+        .succeeds()
+        .stdout_is("01234567890");
+    new_ucmd!()
+        .args(&["-d", "--complement", "0-9"])
+        .pipe_in("Phone: 01234 567890")
+        .succeeds()
+        .stdout_is("01234567890");
+}
+
+#[test]
+fn test_complement1() {
+    new_ucmd!()
+        .args(&["-c", "a", "X"])
+        .pipe_in("ab")
+        .run()
+        .stdout_is("aX");
+}
+
+#[test]
+fn test_complement2() {
+    new_ucmd!()
+        .args(&["-c", "0-9", "x"])
+        .pipe_in("Phone: 01234 567890")
+        .run()
+        .stdout_is("xxxxxxx01234x567890");
+}
+
+#[test]
+fn test_complement3() {
+    new_ucmd!()
+        .args(&["-c", "abcdefgh", "123"])
+        .pipe_in("the cat and the bat")
+        .run()
+        .stdout_is("3he3ca33a3d33he3ba3");
+}
+
+#[test]
+fn test_complement4() {
+    // $ echo -n '0x1y2z3' | tr -c '0-@' '*-~'
+    // 0~1~2~3
+    new_ucmd!()
+        .args(&["-c", "0-@", "*-~"])
+        .pipe_in("0x1y2z3")
+        .run()
+        .stdout_is("0~1~2~3");
+}
+
+#[test]
+#[ignore = "fixme: GNU tr returns '0a1b2c3' instead of '0~1~2~3', see #2158"]
+fn test_complement5() {
+    // $ echo '0x1y2z3' | tr -c '\0-@' '*-~'
+    // 0a1b2c3
+    new_ucmd!()
+        .args(&["-c", "\\0-@", "*-~"])
+        .pipe_in("0x1y2z3")
+        .run()
+        .stdout_is("0a1b2c3");
+}
+
 #[test]
 fn test_squeeze() {
     new_ucmd!()
@@ -63,6 +127,24 @@ fn test_squeeze_complement() {
         .stdout_is("aaBcDcc");
 }
 
+#[test]
+fn test_translate_and_squeeze() {
+    new_ucmd!()
+        .args(&["-s", "x", "y"])
+        .pipe_in("xx")
+        .run()
+        .stdout_is("y");
+}
+
+#[test]
+fn test_translate_and_squeeze_multiple_lines() {
+    new_ucmd!()
+        .args(&["-s", "x", "y"])
+        .pipe_in("xxaax\nxaaxx")
+        .run()
+        .stdout_is("yaay\nyaay");
+}
+
 #[test]
 fn test_delete_and_squeeze() {
     new_ucmd!()
@@ -120,19 +202,15 @@ fn test_truncate_with_set1_shorter_than_set2() {
 #[test]
 fn missing_args_fails() {
     let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("missing operand"));
+    ucmd.fails().stderr_contains("missing operand");
 }
 
 #[test]
 fn missing_required_second_arg_fails() {
     let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.args(&["foo"]).run();
-
-    assert!(!result.success);
-    assert!(result.stderr.contains("missing operand after"));
+    ucmd.args(&["foo"])
+        .fails()
+        .stderr_contains("missing operand after");
 }
 
 #[test]

tests/by-util/test_truncate.rs

@@ -6,26 +6,41 @@ static TFILE2: &'static str = "truncate_test_2";
 
 #[test]
 fn test_increase_file_size() {
+    let expected = 5 * 1024;
     let (at, mut ucmd) = at_and_ucmd!();
     let mut file = at.make_file(TFILE1);
     ucmd.args(&["-s", "+5K", TFILE1]).succeeds();
 
     file.seek(SeekFrom::End(0)).unwrap();
-    assert!(file.seek(SeekFrom::Current(0)).unwrap() == 5 * 1024);
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
 }
 
 #[test]
 fn test_increase_file_size_kb() {
+    let expected = 5 * 1000;
     let (at, mut ucmd) = at_and_ucmd!();
     let mut file = at.make_file(TFILE1);
     ucmd.args(&["-s", "+5KB", TFILE1]).succeeds();
 
     file.seek(SeekFrom::End(0)).unwrap();
-    assert!(file.seek(SeekFrom::Current(0)).unwrap() == 5 * 1000);
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
 }
 
 #[test]
 fn test_reference() {
+    let expected = 5 * 1000;
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     let mut file = at.make_file(TFILE2);
@@ -40,17 +55,47 @@ fn test_reference() {
         .run();
 
     file.seek(SeekFrom::End(0)).unwrap();
-    assert!(file.seek(SeekFrom::Current(0)).unwrap() == 5 * 1000);
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
 }
 
 #[test]
 fn test_decrease_file_size() {
+    let expected = 6;
     let (at, mut ucmd) = at_and_ucmd!();
     let mut file = at.make_file(TFILE2);
     file.write_all(b"1234567890").unwrap();
     ucmd.args(&["--size=-4", TFILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
-    assert!(file.seek(SeekFrom::Current(0)).unwrap() == 6);
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_space_in_size() {
+    let expected = 4;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", " 4", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
 }
 
 #[test]
@@ -69,3 +114,159 @@ fn test_failed_incorrect_arg() {
     let (_at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-s", "+5A", TFILE1]).fails();
 }
+
+#[test]
+fn test_at_most_shrinks() {
+    let expected = 4;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", "<4", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_at_most_no_change() {
+    let expected = 10;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", "<40", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_at_least_grows() {
+    let expected = 15;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", ">15", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_at_least_no_change() {
+    let expected = 10;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", ">4", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_round_down() {
+    let expected = 8;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", "/4", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_round_up() {
+    let expected = 12;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file = at.make_file(TFILE2);
+    file.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--size", "%4", TFILE2]).succeeds();
+    file.seek(SeekFrom::End(0)).unwrap();
+    let actual = file.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_size_and_reference() {
+    let expected = 15;
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut file1 = at.make_file(TFILE1);
+    let mut file2 = at.make_file(TFILE2);
+    file1.write_all(b"1234567890").unwrap();
+    ucmd.args(&["--reference", TFILE1, "--size", "+5", TFILE2])
+        .succeeds();
+    file2.seek(SeekFrom::End(0)).unwrap();
+    let actual = file2.seek(SeekFrom::Current(0)).unwrap();
+    assert!(
+        expected == actual,
+        "expected '{}' got '{}'",
+        expected,
+        actual
+    );
+}
+
+#[test]
+fn test_invalid_numbers() {
+    // TODO For compatibility with GNU, `truncate -s 0X` should cause
+    // the same error as `truncate -s 0X file`, but currently it returns
+    // a different error.
+    new_ucmd!()
+        .args(&["-s", "0X", "file"])
+        .fails()
+        .stderr_contains("Invalid number: ‘0X’");
+    new_ucmd!()
+        .args(&["-s", "0XB", "file"])
+        .fails()
+        .stderr_contains("Invalid number: ‘0XB’");
+    new_ucmd!()
+        .args(&["-s", "0B", "file"])
+        .fails()
+        .stderr_contains("Invalid number: ‘0B’");
+}
+
+#[test]
+fn test_reference_file_not_found() {
+    new_ucmd!()
+        .args(&["-r", "a", "b"])
+        .fails()
+        .stderr_contains("cannot stat 'a': No such file or directory");
+}
+
+#[test]
+fn test_reference_with_size_file_not_found() {
+    new_ucmd!()
+        .args(&["-r", "a", "-s", "+1", "b"])
+        .fails()
+        .stderr_contains("cannot stat 'a': No such file or directory");
+}

tests/by-util/test_tsort.rs

@@ -18,33 +18,35 @@ fn test_sort_self_loop() {
 
 #[test]
 fn test_no_such_file() {
-    let result = new_ucmd!().arg("invalid_file_txt").run();
-
-    assert_eq!(true, result.stderr.contains("No such file or directory"));
+    new_ucmd!()
+        .arg("invalid_file_txt")
+        .fails()
+        .stderr_contains("No such file or directory");
 }
 
 #[test]
 fn test_version_flag() {
-    let version_short = new_ucmd!().arg("-V").run();
-    let version_long = new_ucmd!().arg("--version").run();
+    let version_short = new_ucmd!().arg("-V").succeeds();
+    let version_long = new_ucmd!().arg("--version").succeeds();
 
-    assert_eq!(version_short.stdout, version_long.stdout);
+    assert_eq!(version_short.stdout_str(), version_long.stdout_str());
 }
 
 #[test]
 fn test_help_flag() {
-    let help_short = new_ucmd!().arg("-h").run();
-    let help_long = new_ucmd!().arg("--help").run();
+    let help_short = new_ucmd!().arg("-h").succeeds();
+    let help_long = new_ucmd!().arg("--help").succeeds();
 
-    assert_eq!(help_short.stdout, help_long.stdout);
+    assert_eq!(help_short.stdout_str(), help_long.stdout_str());
 }
 
 #[test]
 fn test_multiple_arguments() {
-    let result = new_ucmd!()
+    new_ucmd!()
         .arg("call_graph.txt")
-        .arg("invalid_file.txt")
-        .run();
-
-    assert_eq!(true, result.stderr.contains("error: Found argument 'invalid_file.txt' which wasn't expected, or isn't valid in this context"))
+        .arg("invalid_file")
+        .fails()
+        .stderr_contains(
+            "Found argument 'invalid_file' which wasn't expected, or isn't valid in this context",
+        );
 }

tests/by-util/test_uname.rs

@@ -2,60 +2,46 @@ use crate::common::util::*;
 
 #[test]
 fn test_uname_compatible() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-a").run();
-    assert!(result.success);
+    new_ucmd!().arg("-a").succeeds();
 }
 
 #[test]
 fn test_uname_name() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-n").run();
-    assert!(result.success);
+    new_ucmd!().arg("-n").succeeds();
 }
 
 #[test]
 fn test_uname_processor() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-p").run();
-    assert!(result.success);
-    assert_eq!(result.stdout.trim_end(), "unknown");
+    let result = new_ucmd!().arg("-p").succeeds();
+    assert_eq!(result.stdout_str().trim_end(), "unknown");
 }
 
 #[test]
 fn test_uname_hwplatform() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-i").run();
-    assert!(result.success);
-    assert_eq!(result.stdout.trim_end(), "unknown");
+    let result = new_ucmd!().arg("-i").succeeds();
+    assert_eq!(result.stdout_str().trim_end(), "unknown");
 }
 
 #[test]
 fn test_uname_machine() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-m").run();
-    assert!(result.success);
+    new_ucmd!().arg("-m").succeeds();
 }
 
 #[test]
 fn test_uname_kernel_version() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    let result = ucmd.arg("-v").run();
-    assert!(result.success);
+    new_ucmd!().arg("-v").succeeds();
 }
 
 #[test]
 fn test_uname_kernel() {
     let (_, mut ucmd) = at_and_ucmd!();
 
-    let result = ucmd.arg("-o").run();
-    assert!(result.success);
     #[cfg(target_os = "linux")]
-    assert!(result.stdout.to_lowercase().contains("linux"));
+    {
+        let result = ucmd.arg("-o").succeeds();
+        assert!(result.stdout_str().to_lowercase().contains("linux"));
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    ucmd.arg("-o").succeeds();
 }

tests/by-util/test_uniq.rs

@@ -145,7 +145,7 @@ fn test_invalid_utf8() {
         .arg("not-utf8-sequence.txt")
         .run()
         .failure()
-        .stderr_only("uniq: error: invalid utf-8 sequence of 1 bytes from index 0");
+        .stderr_only("uniq: invalid utf-8 sequence of 1 bytes from index 0");
 }
 
 #[test]

tests/by-util/test_unlink.rs

@@ -22,7 +22,7 @@ fn test_unlink_multiple_files() {
     at.touch(file_b);
 
     ucmd.arg(file_a).arg(file_b).fails().stderr_is(
-        "unlink: error: extra operand: 'test_unlink_multiple_file_b'\nTry 'unlink --help' \
+        "unlink: extra operand: 'test_unlink_multiple_file_b'\nTry 'unlink --help' \
          for more information.\n",
     );
 }
@@ -35,7 +35,7 @@ fn test_unlink_directory() {
     at.mkdir(dir);
 
     ucmd.arg(dir).fails().stderr_is(
-        "unlink: error: cannot unlink 'test_unlink_empty_directory': Not a regular file \
+        "unlink: cannot unlink 'test_unlink_empty_directory': Not a regular file \
          or symlink\n",
     );
 }
@@ -45,7 +45,7 @@ fn test_unlink_nonexistent() {
     let file = "test_unlink_nonexistent";
 
     new_ucmd!().arg(file).fails().stderr_is(
-        "unlink: error: Cannot stat 'test_unlink_nonexistent': No such file or directory \
+        "unlink: Cannot stat 'test_unlink_nonexistent': No such file or directory \
          (os error 2)\n",
     );
 }

tests/by-util/test_uptime.rs

@@ -4,33 +4,23 @@ use crate::common::util::*;
 
 #[test]
 fn test_uptime() {
-    let result = TestScenario::new(util_name!()).ucmd_keepenv().run();
+    TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .succeeds()
+        .stdout_contains("load average:")
+        .stdout_contains(" up ");
 
-    println!("stdout = {}", result.stdout);
-    println!("stderr = {}", result.stderr);
-
-    assert!(result.success);
-    assert!(result.stdout.contains("load average:"));
-    assert!(result.stdout.contains(" up "));
     // Don't check for users as it doesn't show in some CI
 }
 
 #[test]
 fn test_uptime_since() {
-    let scene = TestScenario::new(util_name!());
-
-    let result = scene.ucmd().arg("--since").succeeds();
-
-    println!("stdout = {}", result.stdout);
-    println!("stderr = {}", result.stderr);
-
-    assert!(result.success);
     let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}").unwrap();
-    assert!(re.is_match(&result.stdout.trim()));
+
+    new_ucmd!().arg("--since").succeeds().stdout_matches(&re);
 }
 
 #[test]
 fn test_failed() {
-    let (_at, mut ucmd) = at_and_ucmd!();
-    ucmd.arg("willfail").fails();
+    new_ucmd!().arg("willfail").fails();
 }

tests/by-util/test_users.rs

@@ -1,30 +1,23 @@
 use crate::common::util::*;
-use std::env;
 
 #[test]
 fn test_users_noarg() {
-    let (_, mut ucmd) = at_and_ucmd!();
-    let result = ucmd.run();
-    assert!(result.success);
+    new_ucmd!().succeeds();
 }
+
 #[test]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 fn test_users_check_name() {
-    let result = TestScenario::new(util_name!()).ucmd_keepenv().run();
-    assert!(result.success);
+    #[cfg(target_os = "linux")]
+    let util_name = util_name!();
+    #[cfg(target_vendor = "apple")]
+    let util_name = format!("g{}", util_name!());
 
-    // Expectation: USER is often set
-    let key = "USER";
+    let expected = TestScenario::new(&util_name)
+        .cmd_keepenv(util_name)
+        .env("LANGUAGE", "C")
+        .succeeds()
+        .stdout_move_str();
 
-    match env::var(key) {
-        Err(e) => println!("Key {} isn't set. Found {}", &key, e),
-        Ok(username) =>
-        // Check if "users" contains the name of the user
-        {
-            println!("username found {}", &username);
-            println!("result.stdout {}", &result.stdout);
-            if !&result.stdout.is_empty() {
-                assert!(result.stdout.contains(&username))
-            }
-        }
-    }
+    new_ucmd!().succeeds().stdout_is(&expected);
 }

tests/by-util/test_wc.rs

@@ -1,11 +1,48 @@
 use crate::common::util::*;
 
+#[test]
+fn test_count_bytes_large_stdin() {
+    for &n in &[
+        0,
+        1,
+        42,
+        16 * 1024 - 7,
+        16 * 1024 - 1,
+        16 * 1024,
+        16 * 1024 + 1,
+        16 * 1024 + 3,
+        32 * 1024,
+        64 * 1024,
+        80 * 1024,
+        96 * 1024,
+        112 * 1024,
+        128 * 1024,
+    ] {
+        let data = vec_of_size(n);
+        let expected = format!("{}\n", n);
+        new_ucmd!()
+            .args(&["-c"])
+            .pipe_in(data)
+            .succeeds()
+            .stdout_is_bytes(&expected.as_bytes());
+    }
+}
+
 #[test]
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in_fixture("lorem_ipsum.txt")
         .run()
-        .stdout_is("  13 109 772\n");
+        .stdout_is("     13     109     772\n");
+}
+
+#[test]
+fn test_stdin_explicit() {
+    new_ucmd!()
+        .pipe_in_fixture("lorem_ipsum.txt")
+        .arg("-")
+        .run()
+        .stdout_is("     13     109     772 -\n");
 }
 
 #[test]
@@ -14,9 +51,11 @@ fn test_utf8() {
         .args(&["-lwmcL"])
         .pipe_in_fixture("UTF_8_test.txt")
         .run()
-        .stdout_is("   300  4969 22781 22213    79\n");
-    // GNU returns "  300  2086 22219 22781    79"
-    // TODO: we should fix that to match GNU's behavior
+        .stdout_is("    300    4969   22781   22213      79\n");
+    // GNU returns "    300    2086   22219   22781      79"
+    //
+    // TODO: we should fix the word, character, and byte count to
+    // match the behavior of GNU wc
 }
 
 #[test]
@@ -43,7 +82,7 @@ fn test_stdin_all_counts() {
         .args(&["-c", "-m", "-l", "-L", "-w"])
         .pipe_in_fixture("alice_in_wonderland.txt")
         .run()
-        .stdout_is("   5  57 302 302  66\n");
+        .stdout_is("      5      57     302     302      66\n");
 }
 
 #[test]
@@ -51,7 +90,7 @@ fn test_single_default() {
     new_ucmd!()
         .arg("moby_dick.txt")
         .run()
-        .stdout_is("   18  204 1115 moby_dick.txt\n");
+        .stdout_is("  18  204 1115 moby_dick.txt\n");
 }
 
 #[test]
@@ -67,7 +106,7 @@ fn test_single_all_counts() {
     new_ucmd!()
         .args(&["-c", "-l", "-L", "-m", "-w", "alice_in_wonderland.txt"])
         .run()
-        .stdout_is("   5  57 302 302  66 alice_in_wonderland.txt\n");
+        .stdout_is("  5  57 302 302  66 alice_in_wonderland.txt\n");
 }
 
 #[test]
@@ -80,7 +119,101 @@ fn test_multiple_default() {
         ])
         .run()
         .stdout_is(
-            "   13  109  772 lorem_ipsum.txt\n   18  204 1115 moby_dick.txt\n    5   57  302 \
-             alice_in_wonderland.txt\n   36  370 2189 total\n",
+            "  13  109  772 lorem_ipsum.txt\n  18  204 1115 moby_dick.txt\n   5   57  302 \
+             alice_in_wonderland.txt\n  36  370 2189 total\n",
         );
 }
+
+/// Test for an empty file.
+#[test]
+fn test_file_empty() {
+    new_ucmd!()
+        .args(&["-clmwL", "emptyfile.txt"])
+        .run()
+        .stdout_is("0 0 0 0 0 emptyfile.txt\n");
+}
+
+/// Test for an file containing a single non-whitespace character
+/// *without* a trailing newline.
+#[test]
+fn test_file_single_line_no_trailing_newline() {
+    new_ucmd!()
+        .args(&["-clmwL", "notrailingnewline.txt"])
+        .run()
+        .stdout_is("1 1 2 2 1 notrailingnewline.txt\n");
+}
+
+/// Test for a file that has 100 empty lines (that is, the contents of
+/// the file are the newline character repeated one hundred times).
+#[test]
+fn test_file_many_empty_lines() {
+    new_ucmd!()
+        .args(&["-clmwL", "manyemptylines.txt"])
+        .run()
+        .stdout_is("100   0 100 100   0 manyemptylines.txt\n");
+}
+
+/// Test for a file that has one long line comprising only spaces.
+#[test]
+fn test_file_one_long_line_only_spaces() {
+    new_ucmd!()
+        .args(&["-clmwL", "onelongemptyline.txt"])
+        .run()
+        .stdout_is("    1     0 10001 10001 10000 onelongemptyline.txt\n");
+}
+
+/// Test for a file that has one long line comprising a single "word".
+#[test]
+fn test_file_one_long_word() {
+    new_ucmd!()
+        .args(&["-clmwL", "onelongword.txt"])
+        .run()
+        .stdout_is("    1     1 10001 10001 10000 onelongword.txt\n");
+}
+
+/// Test that the number of bytes in the file dictate the display width.
+///
+/// The width in digits of any count is the width in digits of the
+/// number of bytes in the file, regardless of whether the number of
+/// bytes are displayed.
+#[test]
+fn test_file_bytes_dictate_width() {
+    // This file has 10,001 bytes. Five digits are required to
+    // represent that. Even though the number of lines is 1 and the
+    // number of words is 0, each of those counts is formatted with
+    // five characters, filled with whitespace.
+    new_ucmd!()
+        .args(&["-lw", "onelongemptyline.txt"])
+        .run()
+        .stdout_is("    1     0 onelongemptyline.txt\n");
+
+    // This file has zero bytes. Only one digit is required to
+    // represent that.
+    new_ucmd!()
+        .args(&["-lw", "emptyfile.txt"])
+        .run()
+        .stdout_is("0 0 emptyfile.txt\n");
+}
+
+/// Test that getting counts from a directory is an error.
+#[test]
+fn test_read_from_directory_error() {
+    // TODO To match GNU `wc`, the `stdout` should be:
+    //
+    //     "      0       0       0 .\n"
+    //
+    new_ucmd!()
+        .args(&["."])
+        .fails()
+        .stderr_contains(".: Is a directory\n")
+        .stdout_is("0 0 0 .\n");
+}
+
+/// Test that getting counts from nonexistent file is an error.
+#[test]
+fn test_read_from_nonexistent_file() {
+    new_ucmd!()
+        .args(&["bogusfile"])
+        .fails()
+        .stderr_contains("bogusfile: No such file or directory\n");
+}

tests/by-util/test_who.rs

@@ -1,30 +1,36 @@
-#[cfg(target_os = "linux")]
 use crate::common::util::*;
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_count() {
     for opt in vec!["-q", "--count"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_boot() {
     for opt in vec!["-b", "--boot"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_heading() {
-    for opt in vec!["-H"] {
+    for opt in vec!["-H", "--heading"] {
         // allow whitespace variation
-        // * minor whitespace differences occur between platform built-in outputs; specifically number of TABs between "TIME" and "COMMENT" may be variant
-        let actual = new_ucmd!().arg(opt).run().stdout;
-        let expect = expected_result(opt);
+        // * minor whitespace differences occur between platform built-in outputs;
+        //   specifically number of TABs between "TIME" and "COMMENT" may be variant
+        let actual = new_ucmd!().arg(opt).succeeds().stdout_move_str();
+        let expect = expected_result(&[opt]);
         println!("actual: {:?}", actual);
         println!("expect: {:?}", expect);
         let v_actual: Vec<&str> = actual.split_whitespace().collect();
@@ -33,52 +39,208 @@ fn test_heading() {
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_short() {
     for opt in vec!["-s", "--short"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_login() {
     for opt in vec!["-l", "--login"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_m() {
     for opt in vec!["-m"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_process() {
+    for opt in vec!["-p", "--process"] {
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
+    }
+}
+
+#[test]
+fn test_runlevel() {
+    for opt in vec!["-r", "--runlevel"] {
+        #[cfg(any(target_vendor = "apple", target_os = "linux"))]
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
+
+        #[cfg(not(target_os = "linux"))]
+        new_ucmd!().arg(opt).succeeds().stdout_is("");
+    }
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_time() {
+    for opt in vec!["-t", "--time"] {
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
+    }
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_mesg() {
+    // -T, -w, --mesg
+    //     add user's message status as +, - or ?
+    // --message
+    //     same as -T
+    // --writable
+    //     same as -T
+    for opt in vec!["-T", "-w", "--mesg", "--message", "--writable"] {
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
+    }
+}
+
+#[test]
+fn test_arg1_arg2() {
+    let args = ["am", "i"];
+
+    new_ucmd!()
+        .args(&args)
+        .succeeds()
+        .stdout_is(expected_result(&args));
+}
+
+#[test]
+fn test_too_many_args() {
+    const EXPECTED: &str =
+        "error: The value 'u' was provided to '<FILE>...', but it wasn't expecting any more values";
+
+    let args = ["am", "i", "u"];
+    new_ucmd!().args(&args).fails().stderr_contains(EXPECTED);
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_users() {
+    for opt in vec!["-u", "--users"] {
+        let actual = new_ucmd!().arg(opt).succeeds().stdout_move_str();
+        let expect = expected_result(&[opt]);
+        println!("actual: {:?}", actual);
+        println!("expect: {:?}", expect);
+
+        let mut v_actual: Vec<&str> = actual.split_whitespace().collect();
+        let mut v_expect: Vec<&str> = expect.split_whitespace().collect();
+
+        // TODO: `--users` differs from GNU's output on macOS
+        // Diff < left / right > :
+        // <"runner   console      2021-05-20 22:03 00:08         196\n"
+        // >"runner   console      2021-05-20 22:03  old          196\n"
+        if cfg!(target_os = "macos") {
+            v_actual.remove(4);
+            v_expect.remove(4);
+        }
+
+        assert_eq!(v_actual, v_expect);
+    }
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_lookup() {
+    for opt in vec!["--lookup"] {
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
+    }
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_dead() {
     for opt in vec!["-d", "--dead"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[test]
+fn test_all_separately() {
+    if cfg!(target_os = "macos") {
+        // TODO: fix `-u`, see: test_users
+        return;
+    }
+
+    // -a, --all         same as -b -d --login -p -r -t -T -u
+    let args = ["-b", "-d", "--login", "-p", "-r", "-t", "-T", "-u"];
+    let scene = TestScenario::new(util_name!());
+    scene
+        .ucmd()
+        .args(&args)
+        .succeeds()
+        .stdout_is(expected_result(&args));
+    scene
+        .ucmd()
+        .arg("--all")
+        .succeeds()
+        .stdout_is(expected_result(&args));
+}
+
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
 #[test]
 fn test_all() {
+    if cfg!(target_os = "macos") {
+        // TODO: fix `-u`, see: test_users
+        return;
+    }
+
     for opt in vec!["-a", "--all"] {
-        new_ucmd!().arg(opt).run().stdout_is(expected_result(opt));
+        new_ucmd!()
+            .arg(opt)
+            .succeeds()
+            .stdout_is(expected_result(&[opt]));
     }
 }
 
-#[cfg(target_os = "linux")]
-fn expected_result(arg: &str) -> String {
-    TestScenario::new(util_name!())
-        .cmd_keepenv(util_name!())
+#[cfg(any(target_vendor = "apple", target_os = "linux"))]
+fn expected_result(args: &[&str]) -> String {
+    #[cfg(target_os = "linux")]
+    let util_name = util_name!();
+    #[cfg(target_vendor = "apple")]
+    let util_name = format!("g{}", util_name!());
+
+    TestScenario::new(&util_name)
+        .cmd_keepenv(util_name)
         .env("LANGUAGE", "C")
-        .args(&[arg])
-        .run()
-        .stdout
+        .args(args)
+        .succeeds()
+        .stdout_move_str()
 }

tests/by-util/test_whoami.rs

@@ -1,50 +1,63 @@
 use crate::common::util::*;
-use std::env;
+
+// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
+// If we are running inside the CI and "needle" is in "stderr" skipping this test is
+// considered okay. If we are not inside the CI this calls assert!(result.success).
+//
+// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
+// stderr: "whoami: failed to get username"
+// Maybe: "adduser --uid 1001 username" can put things right?
+fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
+    if !result.succeeded() {
+        println!("result.stdout = {}", result.stdout_str());
+        println!("result.stderr = {}", result.stderr_str());
+        if is_ci() && result.stderr_str().contains(needle) {
+            println!("test skipped:");
+            return true;
+        } else {
+            result.success();
+        }
+    }
+    false
+}
 
 #[test]
 fn test_normal() {
     let (_, mut ucmd) = at_and_ucmd!();
 
     let result = ucmd.run();
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    println!("env::var(CI).is_ok() = {}", env::var("CI").is_ok());
 
-    for (key, value) in env::vars() {
-        println!("{}: {}", key, value);
-    }
-    if is_ci() && result.stderr.contains("failed to get username") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    // use std::env;
+    // println!("env::var(CI).is_ok() = {}", env::var("CI").is_ok());
+    // for (key, value) in env::vars() {
+    //     println!("{}: {}", key, value);
+    // }
+
+    if skipping_test_is_okay(&result, "failed to get username") {
         return;
     }
 
-    assert!(result.success);
-    assert!(!result.stdout.trim().is_empty());
+    result.no_stderr();
+    assert!(!result.stdout_str().trim().is_empty());
 }
 
 #[test]
 #[cfg(not(windows))]
 fn test_normal_compare_id() {
-    let (_, mut ucmd) = at_and_ucmd!();
+    let scene = TestScenario::new(util_name!());
 
-    let result = ucmd.run();
-
-    println!("result.stdout = {}", result.stdout);
-    println!("result.stderr = {}", result.stderr);
-    if is_ci() && result.stderr.contains("failed to get username") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let result_ucmd = scene.ucmd().run();
+    if skipping_test_is_okay(&result_ucmd, "failed to get username") {
         return;
     }
-    assert!(result.success);
-    let ts = TestScenario::new("id");
-    let id = ts.cmd("id").arg("-un").run();
 
-    if is_ci() && id.stderr.contains("cannot find name for user ID") {
-        // In the CI, some server are failing to return whoami.
-        // As seems to be a configuration issue, ignoring it
+    let result_cmd = scene.cmd("id").arg("-un").run();
+    if skipping_test_is_okay(&result_cmd, "cannot find name for user ID") {
         return;
     }
-    assert_eq!(result.stdout.trim(), id.stdout.trim());
+
+    assert_eq!(
+        result_ucmd.stdout_str().trim(),
+        result_cmd.stdout_str().trim()
+    );
 }