coreutils/tests/by-util/test_chown.rs

747 lines
21 KiB
Rust
Raw Normal View History

// spell-checker:ignore (words) agroupthatdoesntexist auserthatdoesntexist cuuser groupname notexisting passgrp
use crate::common::util::*;
#[cfg(any(target_os = "linux", target_os = "android"))]
use rust_users::get_effective_uid;
2016-06-22 13:39:46 +00:00
extern crate chown;
2016-06-22 13:39:46 +00:00
2021-04-10 21:03:07 +00:00
// 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)"
//
2021-04-10 21:03:07 +00:00
// stderr: "whoami: cannot find name for user ID 1001"
// TODO: Maybe `adduser --uid 1001 username` can put things right?
//
2021-04-10 21:03:07 +00:00
// 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"
//
2021-04-10 21:03:07 +00:00
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
}
2016-06-22 13:39:46 +00:00
#[cfg(test)]
2016-08-14 05:22:42 +00:00
mod test_passgrp {
use super::chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
2016-06-22 13:39:46 +00:00
#[test]
2016-08-14 05:22:42 +00:00
fn test_usr2uid() {
assert_eq!(0, usr2uid("root").unwrap());
2021-05-29 12:32:35 +00:00
assert!(usr2uid("88_888_888").is_err());
2016-08-14 05:22:42 +00:00
assert!(usr2uid("auserthatdoesntexist").is_err());
2016-06-22 13:39:46 +00:00
}
#[test]
2016-08-14 05:22:42 +00:00
fn test_grp2gid() {
if cfg!(target_os = "linux") || cfg!(target_os = "android") || cfg!(target_os = "windows") {
2022-01-30 12:55:03 +00:00
assert_eq!(0, grp2gid("root").unwrap());
2016-07-04 14:50:54 +00:00
} else {
assert_eq!(0, grp2gid("wheel").unwrap());
2016-07-04 14:50:54 +00:00
}
2021-05-29 12:32:35 +00:00
assert!(grp2gid("88_888_888").is_err());
2016-08-14 05:22:42 +00:00
assert!(grp2gid("agroupthatdoesntexist").is_err());
2016-06-22 13:39:46 +00:00
}
#[test]
fn test_uid2usr() {
assert_eq!("root", uid2usr(0).unwrap());
2021-05-29 12:32:35 +00:00
assert!(uid2usr(88_888_888).is_err());
2016-06-22 13:39:46 +00:00
}
#[test]
fn test_gid2grp() {
if cfg!(target_os = "linux") || cfg!(target_os = "android") || cfg!(target_os = "windows") {
2016-07-04 14:50:54 +00:00
assert_eq!("root", gid2grp(0).unwrap());
} else {
assert_eq!("wheel", gid2grp(0).unwrap());
2016-07-04 14:50:54 +00:00
}
2021-05-29 12:32:35 +00:00
assert!(gid2grp(88_888_888).is_err());
2016-06-22 13:39:46 +00:00
}
}
#[test]
fn test_invalid_option() {
2020-04-13 18:36:03 +00:00
new_ucmd!().arg("-w").arg("-q").arg("/").fails();
2016-06-22 13:39:46 +00:00
}
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
#[test]
2021-04-10 21:03:07 +00:00
fn test_chown_only_owner() {
// test chown username file.txt
2021-04-10 21:03:07 +00:00
let scene = TestScenario::new(util_name!());
2021-04-10 21:03:07 +00:00
let at = &scene.fixtures;
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
// 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");
2021-04-10 21:03:07 +00:00
// 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]
2021-04-10 21:03:07 +00:00
fn test_chown_only_owner_colon() {
// test chown username: file.txt
2021-04-10 21:03:07 +00:00
let scene = TestScenario::new(util_name!());
2021-04-10 21:03:07 +00:00
let at = &scene.fixtures;
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
scene
.ucmd()
.arg(format!("{user_name}:"))
2021-04-10 21:03:07 +00:00
.arg("--verbose")
.arg(file1)
.succeeds()
.stderr_contains("retained as");
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");
2021-04-10 21:03:07 +00:00
}
#[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);
2021-04-10 21:03:07 +00:00
// 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: '::'");
scene
.ucmd()
.arg("..")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("invalid group: '..'");
2021-04-10 21:03:07 +00:00
}
#[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]
// FixME: Fails on freebsd because of chown: invalid group: 'root:root'
#[cfg(not(target_os = "freebsd"))]
2021-04-10 21:03:07 +00:00
fn test_chown_owner_group() {
// test chown username:group file.txt
2021-04-10 21:03:07 +00:00
let scene = TestScenario::new(util_name!());
2021-04-10 21:03:07 +00:00
let at = &scene.fixtures;
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
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();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
2021-04-10 21:03:07 +00:00
let group_name = String::from(result.stdout_str().trim());
assert!(!group_name.is_empty());
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg(format!("{user_name}:{group_name}"))
2021-04-10 21:03:07 +00:00
.arg("--verbose")
.arg(file1)
.run();
if skipping_test_is_okay(&result, "chown: invalid group:") {
return;
}
result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
scene
.ucmd()
.arg("root:root:root")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("invalid group");
scene
.ucmd()
.arg("root.root.root")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("invalid group");
2021-04-10 21:03:07 +00:00
// 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]
// FixME: Fails on freebsd because of chown: invalid group: 'root:root'
#[cfg(not(target_os = "freebsd"))]
fn test_chown_various_input() {
// 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 skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
let group_name = String::from(result.stdout_str().trim());
assert!(!group_name.is_empty());
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;
}
result.stderr_contains("retained as");
// check that username.groupname is understood
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;
}
result.stderr_contains("retained as");
// Fails as user.name doesn't exist in the CI
// but it is valid
scene
.ucmd()
.arg(format!("{}:{}", "user.name", "groupname"))
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("chown: invalid user: 'user.name:groupname'");
}
#[test]
// FixME: on macos & freebsd group name is not recognized correctly: "chown: invalid group: ':groupname'
#[cfg(any(
windows,
all(unix, not(any(target_os = "macos", target_os = "freebsd")))
))]
fn test_chown_only_group() {
// test chown :group file.txt
2021-04-10 21:03:07 +00:00
let scene = TestScenario::new(util_name!());
2021-04-10 21:03:07 +00:00
let at = &scene.fixtures;
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg(format!(":{user_name}"))
2021-04-10 21:03:07 +00:00
.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;
}
2021-04-10 21:03:07 +00:00
if is_ci() && result.stderr_str().contains("chown: invalid group:") {
// With mac into the CI, we can get this answer
return;
}
result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
result.success();
scene
.ucmd()
.arg(":root")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("failed to change");
}
#[test]
2021-04-10 21:03:07 +00:00
fn test_chown_only_user_id() {
// test chown 1111 file.txt
2021-04-10 21:03:07 +00:00
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;
}
2021-04-10 21:03:07 +00:00
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
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;
}
result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
scene
.ucmd()
.arg("0")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("failed to change");
}
#[test]
fn test_chown_fail_id() {
// test chown 1111. 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;
}
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
let file1 = "test_chown_file1";
at.touch(file1);
scene
.ucmd()
.arg(format!("{user_id}:"))
.arg(file1)
.fails()
.stderr_contains("invalid spec");
scene
.ucmd()
.arg(format!("{user_id}."))
.arg(file1)
.fails()
.stderr_contains("invalid spec");
}
/// Test for setting the owner to a user ID for a user that does not exist.
///
/// For example:
///
/// $ touch f && chown 12345 f
///
/// succeeds with exit status 0 and outputs nothing. The owner of the
/// file is set to 12345, even though no user with that ID exists.
///
/// This test must be run as root, because only the root user can
/// transfer ownership of a file.
#[test]
fn test_chown_only_user_id_nonexistent_user() {
let ts = TestScenario::new(util_name!());
let at = ts.fixtures.clone();
at.touch("f");
if let Ok(result) = run_ucmd_as_root(&ts, &["12345", "f"]) {
result.success().no_stdout().no_stderr();
} else {
print!("Test skipped; requires root user");
}
}
#[test]
// FixME: stderr = chown: ownership of 'test_chown_file1' retained as cuuser:wheel
#[cfg(not(target_os = "freebsd"))]
fn test_chown_only_group_id() {
// test chown :1111 file.txt
2021-04-10 21:03:07 +00:00
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;
}
2021-04-10 21:03:07 +00:00
let group_id = String::from(result.stdout_str().trim());
assert!(!group_id.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg(format!(":{group_id}"))
2021-04-10 21:03:07 +00:00
.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;
}
result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
// 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 for setting the group to a group ID for a group that does not exist.
///
/// For example:
///
/// $ touch f && chown :12345 f
///
/// succeeds with exit status 0 and outputs nothing. The group of the
/// file is set to 12345, even though no group with that ID exists.
///
/// This test must be run as root, because only the root user can
/// transfer ownership of a file.
#[test]
fn test_chown_only_group_id_nonexistent_group() {
let ts = TestScenario::new(util_name!());
let at = ts.fixtures.clone();
at.touch("f");
if let Ok(result) = run_ucmd_as_root(&ts, &[":12345", "f"]) {
result.success().no_stdout().no_stderr();
} else {
print!("Test skipped; requires root user");
}
}
#[test]
2021-04-10 21:03:07 +00:00
fn test_chown_owner_group_id() {
// test chown 1111:1111 file.txt
2021-04-10 21:03:07 +00:00
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;
}
2021-04-10 21:03:07 +00:00
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
let result = scene.cmd_keepenv("id").arg("-g").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
2021-04-10 21:03:07 +00:00
let group_id = String::from(result.stdout_str().trim());
assert!(!group_id.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg(format!("{user_id}:{group_id}"))
2021-04-10 21:03:07 +00:00
.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");
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");
2021-04-10 21:03:07 +00:00
scene
.ucmd()
.arg("0:0")
.arg("--verbose")
.arg(file1)
.fails()
.stderr_contains("failed to change");
}
#[test]
// FixME: Fails on freebsd because of chown: invalid group: '0:root'
#[cfg(not(target_os = "freebsd"))]
2021-04-10 21:03:07 +00:00
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;
}
2021-04-10 21:03:07 +00:00
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
let result = scene.cmd_keepenv("id").arg("-gn").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
2021-04-10 21:03:07 +00:00
let group_name = String::from(result.stdout_str().trim());
assert!(!group_name.is_empty());
2021-04-10 21:03:07 +00:00
let file1 = "test_chown_file1";
at.touch(file1);
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg(format!("{user_id}:{group_name}"))
2021-04-10 21:03:07 +00:00
.arg("--verbose")
.arg(file1)
.run();
result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
// 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!());
2021-04-10 21:03:07 +00:00
let at = &scene.fixtures;
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
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"));
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg("-R")
.arg("--verbose")
2021-04-10 21:03:07 +00:00
.arg(user_name)
.arg("a")
.arg("z")
.run();
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!());
2021-04-10 21:03:07 +00:00
let result = scene.cmd("whoami").run();
2021-04-10 21:03:07 +00:00
if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
return;
}
2021-04-10 21:03:07 +00:00
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
2021-04-10 21:03:07 +00:00
let result = scene
.ucmd()
.arg("--preserve-root")
.arg("-R")
2021-04-10 21:03:07 +00:00
.arg(user_name)
.arg("/")
.fails();
result.stderr_contains("chown: it is dangerous to operate recursively");
}
#[cfg(any(target_os = "linux", target_os = "android"))]
2020-12-13 10:30:49 +00:00
#[test]
fn test_big_p() {
if get_effective_uid() != 0 {
new_ucmd!()
.arg("-RP")
.arg("bin")
.arg("/proc/self/cwd")
.fails()
.stderr_contains(
// linux fails with "Operation not permitted (os error 1)"
// because of insufficient permissions,
// android fails with "Permission denied (os error 13)"
// because it can't resolve /proc (even though it can resolve /proc/self/)
"chown: changing ownership of '/proc/self/cwd': ",
);
}
}
2021-04-10 21:03:07 +00:00
#[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
2022-10-23 04:18:56 +00:00
// result.stderr_contains("retained as");
2021-04-10 21:03:07 +00:00
// TODO: uncomment once message changed from "cannot dereference" to "cannot access"
2022-10-23 04:18:56 +00:00
// result.stderr_contains("cannot access 'not_existing': No such file or directory");
2021-04-10 21:03:07 +00:00
}