mirror of
https://github.com/uutils/coreutils
synced 2025-01-18 16:14:13 +00:00
Merge pull request #2484 from jhscheer/refactor_expected_result
tests/common: refactor to reduce duplicate code
This commit is contained in:
Sylvestre Ledru
GitHub
commit
f4de8e1bc8
9 changed files with 570 additions and 679 deletions
|
|
@ -39,13 +39,13 @@ fn _du_basics(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_basics_subdir() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
let result = scene.ucmd().arg(SUB_DIR).succeeds();
|
||||
let result = ts.ucmd().arg(SUB_DIR).succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg(SUB_DIR).run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &[SUB_DIR]));
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -83,15 +83,16 @@ fn _du_basics_subdir(s: &str) {
|
|||
#[test]
|
||||
fn test_du_invalid_size() {
|
||||
let args = &["block-size", "threshold"];
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for s in args {
|
||||
new_ucmd!()
|
||||
ts.ucmd()
|
||||
.arg(format!("--{}=1fb4t", s))
|
||||
.arg("/tmp")
|
||||
.fails()
|
||||
.code_is(1)
|
||||
.stderr_only(format!("du: invalid --{} argument '1fb4t'", s));
|
||||
#[cfg(not(target_pointer_width = "128"))]
|
||||
new_ucmd!()
|
||||
ts.ucmd()
|
||||
.arg(format!("--{}=1Y", s))
|
||||
.arg("/tmp")
|
||||
.fails()
|
||||
|
|
@ -110,16 +111,16 @@ fn test_du_basics_bad_name() {
|
|||
|
||||
#[test]
|
||||
fn test_du_soft_link() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let at = &scene.fixtures;
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let at = &ts.fixtures;
|
||||
|
||||
at.symlink_file(SUB_FILE, SUB_LINK);
|
||||
|
||||
let result = scene.ucmd().arg(SUB_DIR_LINKS).succeeds();
|
||||
let result = ts.ucmd().arg(SUB_DIR_LINKS).succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg(SUB_DIR_LINKS).run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &[SUB_DIR_LINKS]));
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -157,16 +158,16 @@ fn _du_soft_link(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_hard_link() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let at = &scene.fixtures;
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let at = &ts.fixtures;
|
||||
|
||||
at.hard_link(SUB_FILE, SUB_LINK);
|
||||
|
||||
let result = scene.ucmd().arg(SUB_DIR_LINKS).succeeds();
|
||||
let result = ts.ucmd().arg(SUB_DIR_LINKS).succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg(SUB_DIR_LINKS).run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &[SUB_DIR_LINKS]));
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -204,13 +205,13 @@ fn _du_hard_link(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_d_flag() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
let result = scene.ucmd().arg("-d1").succeeds();
|
||||
let result = ts.ucmd().arg("-d1").succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("-d1").run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["-d1"]));
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -247,16 +248,17 @@ fn _du_d_flag(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_dereference() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let at = &scene.fixtures;
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let at = &ts.fixtures;
|
||||
|
||||
at.symlink_dir(SUB_DEEPER_DIR, SUB_DIR_LINKS_DEEPER_SYM_DIR);
|
||||
|
||||
let result = scene.ucmd().arg("-L").arg(SUB_DIR_LINKS).succeeds();
|
||||
let result = ts.ucmd().arg("-L").arg(SUB_DIR_LINKS).succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("-L").arg(SUB_DIR_LINKS).run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["-L", SUB_DIR_LINKS]));
|
||||
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -294,12 +296,12 @@ fn _du_dereference(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_inodes_basic() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let result = scene.ucmd().arg("--inodes").succeeds();
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().arg("--inodes").succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("--inodes").run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["--inodes"]));
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
}
|
||||
|
||||
|
|
@ -335,20 +337,15 @@ fn _du_inodes_basic(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_inodes() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.arg("--summarize")
|
||||
.arg("--inodes")
|
||||
.succeeds()
|
||||
.stdout_only("11\t.\n");
|
||||
|
||||
let result = scene
|
||||
.ucmd()
|
||||
.arg("--separate-dirs")
|
||||
.arg("--inodes")
|
||||
.succeeds();
|
||||
let result = ts.ucmd().arg("--separate-dirs").arg("--inodes").succeeds();
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
result.stdout_contains("3\t.\\subdir\\links\n");
|
||||
|
|
@ -358,7 +355,8 @@ fn test_du_inodes() {
|
|||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("--separate-dirs").arg("--inodes").run();
|
||||
let result_reference =
|
||||
unwrap_or_return!(expected_result(&ts, &["--separate-dirs", "--inodes"]));
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
}
|
||||
}
|
||||
|
|
@ -375,31 +373,29 @@ fn test_du_h_flag_empty_file() {
|
|||
#[cfg(feature = "touch")]
|
||||
#[test]
|
||||
fn test_du_time() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
scene
|
||||
.ccmd("touch")
|
||||
ts.ccmd("touch")
|
||||
.arg("-a")
|
||||
.arg("-t")
|
||||
.arg("201505150000")
|
||||
.arg("date_test")
|
||||
.succeeds();
|
||||
|
||||
scene
|
||||
.ccmd("touch")
|
||||
ts.ccmd("touch")
|
||||
.arg("-m")
|
||||
.arg("-t")
|
||||
.arg("201606160000")
|
||||
.arg("date_test")
|
||||
.succeeds();
|
||||
|
||||
let result = scene.ucmd().arg("--time").arg("date_test").succeeds();
|
||||
let result = ts.ucmd().arg("--time").arg("date_test").succeeds();
|
||||
result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
|
||||
|
||||
let result = scene.ucmd().arg("--time=atime").arg("date_test").succeeds();
|
||||
let result = ts.ucmd().arg("--time=atime").arg("date_test").succeeds();
|
||||
result.stdout_only("0\t2015-05-15 00:00\tdate_test\n");
|
||||
|
||||
let result = scene.ucmd().arg("--time=ctime").arg("date_test").succeeds();
|
||||
let result = ts.ucmd().arg("--time=ctime").arg("date_test").succeeds();
|
||||
result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
|
||||
|
||||
#[cfg(not(target_env = "musl"))]
|
||||
|
|
@ -408,7 +404,7 @@ fn test_du_time() {
|
|||
|
||||
let re_birth =
|
||||
Regex::new(r"0\t[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}\tdate_test").unwrap();
|
||||
let result = scene.ucmd().arg("--time=birth").arg("date_test").succeeds();
|
||||
let result = ts.ucmd().arg("--time=birth").arg("date_test").succeeds();
|
||||
result.stdout_matches(&re_birth);
|
||||
}
|
||||
}
|
||||
|
|
@ -417,21 +413,21 @@ fn test_du_time() {
|
|||
#[cfg(feature = "chmod")]
|
||||
#[test]
|
||||
fn test_du_no_permission() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let at = &scene.fixtures;
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let at = &ts.fixtures;
|
||||
|
||||
at.mkdir_all(SUB_DIR_LINKS);
|
||||
|
||||
scene.ccmd("chmod").arg("-r").arg(SUB_DIR_LINKS).succeeds();
|
||||
ts.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
|
||||
let result = ts.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();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &[SUB_DIR_LINKS]));
|
||||
if result_reference
|
||||
.stderr_str()
|
||||
.contains("du: cannot read directory 'subdir/links': Permission denied")
|
||||
|
|
@ -455,13 +451,13 @@ fn _du_no_permission(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_one_file_system() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
let result = scene.ucmd().arg("-x").arg(SUB_DIR).succeeds();
|
||||
let result = ts.ucmd().arg("-x").arg(SUB_DIR).succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("-x").arg(SUB_DIR).run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["-x", SUB_DIR]));
|
||||
if result_reference.succeeded() {
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
return;
|
||||
|
|
@ -472,19 +468,17 @@ fn test_du_one_file_system() {
|
|||
|
||||
#[test]
|
||||
fn test_du_threshold() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
|
||||
let threshold = if cfg!(windows) { "7K" } else { "10K" };
|
||||
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.arg(format!("--threshold={}", threshold))
|
||||
.succeeds()
|
||||
.stdout_contains("links")
|
||||
.stdout_does_not_contain("deeper_dir");
|
||||
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.arg(format!("--threshold=-{}", threshold))
|
||||
.succeeds()
|
||||
.stdout_does_not_contain("links")
|
||||
|
|
@ -493,12 +487,12 @@ fn test_du_threshold() {
|
|||
|
||||
#[test]
|
||||
fn test_du_apparent_size() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let result = scene.ucmd().arg("--apparent-size").succeeds();
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().arg("--apparent-size").succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("--apparent-size").run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["--apparent-size"]));
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
}
|
||||
|
||||
|
|
@ -561,12 +555,12 @@ fn _du_apparent_size(s: &str) {
|
|||
|
||||
#[test]
|
||||
fn test_du_bytes() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let result = scene.ucmd().arg("--bytes").succeeds();
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().arg("--bytes").succeeds();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let result_reference = scene.cmd("du").arg("--bytes").run();
|
||||
let result_reference = unwrap_or_return!(expected_result(&ts, &["--bytes"]));
|
||||
assert_eq!(result.stdout_str(), result_reference.stdout_str());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,55 +1,20 @@
|
|||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
//spell-checker: ignore coreutil
|
||||
|
||||
use crate::common::util::*;
|
||||
|
||||
// spell-checker:ignore (ToDO) coreutil
|
||||
|
||||
// These tests run the GNU coreutils `(g)groups` binary in `$PATH` in order to gather reference values.
|
||||
// If the `(g)groups` in `$PATH` doesn't include a coreutils version string,
|
||||
// or the version is too low, the test is skipped.
|
||||
|
||||
// The reference version is 8.32. Here 8.30 was chosen because right now there's no
|
||||
// ubuntu image for github action available with a higher version than 8.30.
|
||||
const VERSION_MIN: &str = "8.30"; // minimum Version for the reference `groups` in $PATH
|
||||
const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
|
||||
const UUTILS_WARNING: &str = "uutils-tests-warning";
|
||||
const UUTILS_INFO: &str = "uutils-tests-info";
|
||||
|
||||
macro_rules! unwrap_or_return {
|
||||
( $e:expr ) => {
|
||||
match $e {
|
||||
Ok(x) => x,
|
||||
Err(e) => {
|
||||
println!("{}: test skipped: {}", UUTILS_INFO, e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn whoami() -> String {
|
||||
// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
|
||||
//
|
||||
// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
|
||||
// whoami: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for group ID 116
|
||||
//
|
||||
// However, when running "id" from within "/bin/bash" it looks fine:
|
||||
// id: "uid=1001(runner) gid=118(docker) groups=118(docker),4(adm),101(systemd-journal)"
|
||||
// whoami: "runner"
|
||||
|
||||
// Use environment variable to get current user instead of
|
||||
// invoking `whoami` and fall back to user "nobody" on error.
|
||||
std::env::var("USER").unwrap_or_else(|e| {
|
||||
println!("{}: {}, using \"nobody\" instead", UUTILS_WARNING, e);
|
||||
"nobody".to_string()
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_groups() {
|
||||
let result = new_ucmd!().run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&[]));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
|
||||
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -62,8 +27,9 @@ fn test_groups() {
|
|||
fn test_groups_username() {
|
||||
let test_users = [&whoami()[..]];
|
||||
|
||||
let result = new_ucmd!().args(&test_users).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&test_users));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().args(&test_users).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
|
||||
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -74,103 +40,18 @@ fn test_groups_username() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_groups_username_multiple() {
|
||||
// TODO: [2021-06; jhscheer] refactor this as `let util_name = host_name_for(util_name!())` when that function is added to 'tests/common'
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(all(unix, not(target_os = "linux")))]
|
||||
let util_name = &format!("g{}", util_name!());
|
||||
let version_check_string = check_coreutil_version(util_name, VERSION_MIN_MULTIPLE_USERS);
|
||||
if version_check_string.starts_with(UUTILS_WARNING) {
|
||||
println!("{}\ntest skipped", version_check_string);
|
||||
return;
|
||||
}
|
||||
unwrap_or_return!(check_coreutil_version(
|
||||
util_name!(),
|
||||
VERSION_MIN_MULTIPLE_USERS
|
||||
));
|
||||
let test_users = ["root", "man", "postfix", "sshd", &whoami()];
|
||||
|
||||
let result = new_ucmd!().args(&test_users).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&test_users));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().args(&test_users).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
|
||||
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
.code_is(exp_result.code());
|
||||
}
|
||||
|
||||
fn check_coreutil_version(util_name: &str, version_expected: &str) -> String {
|
||||
// example:
|
||||
// $ id --version | head -n 1
|
||||
// id (GNU coreutils) 8.32.162-4eda
|
||||
let scene = TestScenario::new(util_name);
|
||||
let version_check = scene
|
||||
.cmd_keepenv(&util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.arg("--version")
|
||||
.run();
|
||||
version_check
|
||||
.stdout_str()
|
||||
.split('\n')
|
||||
.collect::<Vec<_>>()
|
||||
.get(0)
|
||||
.map_or_else(
|
||||
|| format!("{}: unexpected output format for reference coreutil: '{} --version'", UUTILS_WARNING, util_name),
|
||||
|s| {
|
||||
if s.contains(&format!("(GNU coreutils) {}", version_expected)) {
|
||||
s.to_string()
|
||||
} else if s.contains("(GNU coreutils)") {
|
||||
let version_found = s.split_whitespace().last().unwrap()[..4].parse::<f32>().unwrap_or_default();
|
||||
let version_expected = version_expected.parse::<f32>().unwrap_or_default();
|
||||
if version_found > version_expected {
|
||||
format!("{}: version for the reference coreutil '{}' is higher than expected; expected: {}, found: {}", UUTILS_INFO, util_name, version_expected, version_found)
|
||||
} else {
|
||||
format!("{}: version for the reference coreutil '{}' does not match; expected: {}, found: {}", UUTILS_WARNING, util_name, version_expected, version_found) }
|
||||
} else {
|
||||
format!("{}: no coreutils version string found for reference coreutils '{} --version'", UUTILS_WARNING, util_name)
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[allow(clippy::needless_borrow)]
|
||||
#[cfg(unix)]
|
||||
fn expected_result(args: &[&str]) -> Result<CmdResult, String> {
|
||||
// TODO: [2021-06; jhscheer] refactor this as `let util_name = host_name_for(util_name!())` when that function is added to 'tests/common'
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(all(unix, not(target_os = "linux")))]
|
||||
let util_name = &format!("g{}", util_name!());
|
||||
|
||||
let version_check_string = check_coreutil_version(util_name, VERSION_MIN);
|
||||
if version_check_string.starts_with(UUTILS_WARNING) {
|
||||
return Err(version_check_string);
|
||||
}
|
||||
println!("{}", version_check_string);
|
||||
|
||||
let scene = TestScenario::new(util_name);
|
||||
let result = scene
|
||||
.cmd_keepenv(util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.run();
|
||||
|
||||
let (stdout, stderr): (String, String) = if cfg!(target_os = "linux") {
|
||||
(
|
||||
result.stdout_str().to_string(),
|
||||
result.stderr_str().to_string(),
|
||||
)
|
||||
} else {
|
||||
// strip 'g' prefix from results:
|
||||
let from = util_name.to_string() + ":";
|
||||
let to = &from[1..];
|
||||
(
|
||||
result.stdout_str().replace(&from, to),
|
||||
result.stderr_str().replace(&from, to),
|
||||
)
|
||||
};
|
||||
|
||||
Ok(CmdResult::new(
|
||||
Some(result.tmpd()),
|
||||
Some(result.code()),
|
||||
result.succeeded(),
|
||||
stdout.as_bytes(),
|
||||
stderr.as_bytes(),
|
||||
))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,60 +1,28 @@
|
|||
use crate::common::util::*;
|
||||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
// spell-checker:ignore (ToDO) coreutil
|
||||
|
||||
// These tests run the GNU coreutils `(g)id` binary in `$PATH` in order to gather reference values.
|
||||
// If the `(g)id` in `$PATH` doesn't include a coreutils version string,
|
||||
// or the version is too low, the test is skipped.
|
||||
use crate::common::util::*;
|
||||
|
||||
// The reference version is 8.32. Here 8.30 was chosen because right now there's no
|
||||
// ubuntu image for github action available with a higher version than 8.30.
|
||||
const VERSION_MIN: &str = "8.30"; // minimum Version for the reference `id` in $PATH
|
||||
const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
|
||||
const UUTILS_WARNING: &str = "uutils-tests-warning";
|
||||
const UUTILS_INFO: &str = "uutils-tests-info";
|
||||
|
||||
macro_rules! unwrap_or_return {
|
||||
( $e:expr ) => {
|
||||
match $e {
|
||||
Ok(x) => x,
|
||||
Err(e) => {
|
||||
println!("{}: test skipped: {}", UUTILS_INFO, e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn whoami() -> String {
|
||||
// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
|
||||
//
|
||||
// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
|
||||
// whoami: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for group ID 116
|
||||
//
|
||||
// However, when running "id" from within "/bin/bash" it looks fine:
|
||||
// id: "uid=1001(runner) gid=118(docker) groups=118(docker),4(adm),101(systemd-journal)"
|
||||
// whoami: "runner"
|
||||
|
||||
// Use environment variable to get current user instead of
|
||||
// invoking `whoami` and fall back to user "nobody" on error.
|
||||
std::env::var("USER").unwrap_or_else(|e| {
|
||||
println!("{}: {}, using \"nobody\" instead", UUTILS_WARNING, e);
|
||||
"nobody".to_string()
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_no_specified_user() {
|
||||
let result = new_ucmd!().run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&[]));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
|
||||
let mut _exp_stdout = exp_result.stdout_str().to_string();
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
// NOTE: (SELinux NotImplemented) strip 'context' part from exp_stdout:
|
||||
// example:
|
||||
// uid=1001(runner) gid=121(docker) groups=121(docker),4(adm),101(systemd-journal) \
|
||||
// context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
|
||||
if let Some(context_offset) = exp_result.stdout_str().find(" context=") {
|
||||
_exp_stdout.replace_range(context_offset.._exp_stdout.len() - 1, "");
|
||||
}
|
||||
|
|
@ -71,10 +39,9 @@ fn test_id_no_specified_user() {
|
|||
fn test_id_single_user() {
|
||||
let test_users = [&whoami()[..]];
|
||||
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&test_users));
|
||||
scene
|
||||
.ucmd()
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
|
||||
ts.ucmd()
|
||||
.args(&test_users)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -85,36 +52,32 @@ fn test_id_single_user() {
|
|||
for &opt in &["--user", "--group", "--groups"] {
|
||||
let mut args = vec![opt];
|
||||
args.extend_from_slice(&test_users);
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--zero");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--name");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.pop();
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -127,8 +90,9 @@ fn test_id_single_user() {
|
|||
#[cfg(unix)]
|
||||
fn test_id_single_user_non_existing() {
|
||||
let args = &["hopefully_non_existing_username"];
|
||||
let result = new_ucmd!().args(args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().args(args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, args));
|
||||
|
||||
// It is unknown why on macOS (and possibly others?) `id` adds "Invalid argument".
|
||||
// coreutils 8.32: $ LC_ALL=C id foobar
|
||||
|
|
@ -143,11 +107,11 @@ fn test_id_single_user_non_existing() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_name() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for &opt in &["--user", "--group", "--groups"] {
|
||||
let args = [opt, "--name"];
|
||||
let result = scene.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&args));
|
||||
let result = ts.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
|
|
@ -162,11 +126,11 @@ fn test_id_name() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_real() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for &opt in &["--user", "--group", "--groups"] {
|
||||
let args = [opt, "--real"];
|
||||
let result = scene.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&args));
|
||||
let result = ts.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
|
|
@ -206,23 +170,17 @@ fn test_id_password_style() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_multiple_users() {
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(all(unix, not(target_os = "linux")))]
|
||||
let util_name = &format!("g{}", util_name!());
|
||||
let version_check_string = check_coreutil_version(util_name, VERSION_MIN_MULTIPLE_USERS);
|
||||
if version_check_string.starts_with(UUTILS_WARNING) {
|
||||
println!("{}\ntest skipped", version_check_string);
|
||||
return;
|
||||
}
|
||||
unwrap_or_return!(check_coreutil_version(
|
||||
util_name!(),
|
||||
VERSION_MIN_MULTIPLE_USERS
|
||||
));
|
||||
|
||||
// Same typical users that GNU test suite is using.
|
||||
let test_users = ["root", "man", "postfix", "sshd", &whoami()];
|
||||
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&test_users));
|
||||
scene
|
||||
.ucmd()
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
|
||||
ts.ucmd()
|
||||
.args(&test_users)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -233,36 +191,32 @@ fn test_id_multiple_users() {
|
|||
for &opt in &["--user", "--group", "--groups"] {
|
||||
let mut args = vec![opt];
|
||||
args.extend_from_slice(&test_users);
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--zero");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--name");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.pop();
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -274,15 +228,10 @@ fn test_id_multiple_users() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_multiple_users_non_existing() {
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(all(unix, not(target_os = "linux")))]
|
||||
let util_name = &format!("g{}", util_name!());
|
||||
let version_check_string = check_coreutil_version(util_name, VERSION_MIN_MULTIPLE_USERS);
|
||||
if version_check_string.starts_with(UUTILS_WARNING) {
|
||||
println!("{}\ntest skipped", version_check_string);
|
||||
return;
|
||||
}
|
||||
unwrap_or_return!(check_coreutil_version(
|
||||
util_name!(),
|
||||
VERSION_MIN_MULTIPLE_USERS
|
||||
));
|
||||
|
||||
let test_users = [
|
||||
"root",
|
||||
|
|
@ -297,10 +246,9 @@ fn test_id_multiple_users_non_existing() {
|
|||
&whoami(),
|
||||
];
|
||||
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&test_users));
|
||||
scene
|
||||
.ucmd()
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let mut exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
|
||||
ts.ucmd()
|
||||
.args(&test_users)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -311,36 +259,32 @@ fn test_id_multiple_users_non_existing() {
|
|||
for &opt in &["--user", "--group", "--groups"] {
|
||||
let mut args = vec![opt];
|
||||
args.extend_from_slice(&test_users);
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--zero");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.push("--name");
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str().replace(": Invalid argument", ""))
|
||||
.code_is(exp_result.code());
|
||||
args.pop();
|
||||
exp_result = unwrap_or_return!(expected_result(&args));
|
||||
scene
|
||||
.ucmd()
|
||||
exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
|
|
@ -352,20 +296,19 @@ fn test_id_multiple_users_non_existing() {
|
|||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_default_format() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for &opt1 in &["--name", "--real"] {
|
||||
// id: cannot print only names or real IDs in default format
|
||||
let args = [opt1];
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.fails()
|
||||
.stderr_only(unwrap_or_return!(expected_result(&args)).stderr_str());
|
||||
.stderr_only(unwrap_or_return!(expected_result(&ts, &args)).stderr_str());
|
||||
for &opt2 in &["--user", "--group", "--groups"] {
|
||||
// u/g/G n/r
|
||||
let args = [opt2, opt1];
|
||||
let result = scene.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&args));
|
||||
let result = ts.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
|
|
@ -375,38 +318,35 @@ fn test_id_default_format() {
|
|||
for &opt2 in &["--user", "--group", "--groups"] {
|
||||
// u/g/G
|
||||
let args = [opt2];
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_only(unwrap_or_return!(expected_result(&args)).stdout_str());
|
||||
.stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_id_zero() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for z_flag in &["-z", "--zero"] {
|
||||
// id: option --zero not permitted in default format
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.args(&[z_flag])
|
||||
.fails()
|
||||
.stderr_only(unwrap_or_return!(expected_result(&[z_flag])).stderr_str());
|
||||
.stderr_only(unwrap_or_return!(expected_result(&ts, &[z_flag])).stderr_str());
|
||||
for &opt1 in &["--name", "--real"] {
|
||||
// id: cannot print only names or real IDs in default format
|
||||
let args = [opt1, z_flag];
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.fails()
|
||||
.stderr_only(unwrap_or_return!(expected_result(&args)).stderr_str());
|
||||
.stderr_only(unwrap_or_return!(expected_result(&ts, &args)).stderr_str());
|
||||
for &opt2 in &["--user", "--group", "--groups"] {
|
||||
// u/g/G n/r z
|
||||
let args = [opt2, z_flag, opt1];
|
||||
let result = scene.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&args));
|
||||
let result = ts.ucmd().args(&args).run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &args));
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
|
|
@ -416,90 +356,10 @@ fn test_id_zero() {
|
|||
for &opt2 in &["--user", "--group", "--groups"] {
|
||||
// u/g/G z
|
||||
let args = [opt2, z_flag];
|
||||
scene
|
||||
.ucmd()
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_only(unwrap_or_return!(expected_result(&args)).stdout_str());
|
||||
.stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_coreutil_version(util_name: &str, version_expected: &str) -> String {
|
||||
// example:
|
||||
// $ id --version | head -n 1
|
||||
// id (GNU coreutils) 8.32.162-4eda
|
||||
let scene = TestScenario::new(util_name);
|
||||
let version_check = scene
|
||||
.cmd_keepenv(&util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.arg("--version")
|
||||
.run();
|
||||
version_check
|
||||
.stdout_str()
|
||||
.split('\n')
|
||||
.collect::<Vec<_>>()
|
||||
.get(0)
|
||||
.map_or_else(
|
||||
|| format!("{}: unexpected output format for reference coreutil: '{} --version'", UUTILS_WARNING, util_name),
|
||||
|s| {
|
||||
if s.contains(&format!("(GNU coreutils) {}", version_expected)) {
|
||||
s.to_string()
|
||||
} else if s.contains("(GNU coreutils)") {
|
||||
let version_found = s.split_whitespace().last().unwrap()[..4].parse::<f32>().unwrap_or_default();
|
||||
let version_expected = version_expected.parse::<f32>().unwrap_or_default();
|
||||
if version_found > version_expected {
|
||||
format!("{}: version for the reference coreutil '{}' is higher than expected; expected: {}, found: {}", UUTILS_INFO, util_name, version_expected, version_found)
|
||||
} else {
|
||||
format!("{}: version for the reference coreutil '{}' does not match; expected: {}, found: {}", UUTILS_WARNING, util_name, version_expected, version_found) }
|
||||
} else {
|
||||
format!("{}: no coreutils version string found for reference coreutils '{} --version'", UUTILS_WARNING, util_name)
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[allow(clippy::needless_borrow)]
|
||||
#[cfg(unix)]
|
||||
fn expected_result(args: &[&str]) -> Result<CmdResult, String> {
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(all(unix, not(target_os = "linux")))]
|
||||
let util_name = &format!("g{}", util_name!());
|
||||
|
||||
let version_check_string = check_coreutil_version(util_name, VERSION_MIN);
|
||||
if version_check_string.starts_with(UUTILS_WARNING) {
|
||||
return Err(version_check_string);
|
||||
}
|
||||
println!("{}", version_check_string);
|
||||
|
||||
let scene = TestScenario::new(util_name);
|
||||
let result = scene
|
||||
.cmd_keepenv(util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.run();
|
||||
|
||||
let (stdout, stderr): (String, String) = if cfg!(target_os = "linux") {
|
||||
(
|
||||
result.stdout_str().to_string(),
|
||||
result.stderr_str().to_string(),
|
||||
)
|
||||
} else {
|
||||
// strip 'g' prefix from results:
|
||||
let from = util_name.to_string() + ":";
|
||||
let to = &from[1..];
|
||||
(
|
||||
result.stdout_str().replace(&from, to),
|
||||
result.stderr_str().replace(&from, to),
|
||||
)
|
||||
};
|
||||
|
||||
Ok(CmdResult::new(
|
||||
Some(result.tmpd()),
|
||||
Some(result.code()),
|
||||
result.succeeded(),
|
||||
stdout.as_bytes(),
|
||||
stderr.as_bytes(),
|
||||
))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,8 @@
|
|||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
extern crate uucore;
|
||||
|
||||
use crate::common::util::*;
|
||||
|
|
@ -20,19 +25,16 @@ fn test_long_format() {
|
|||
let login = "root";
|
||||
let pw: Passwd = Passwd::locate(login).unwrap();
|
||||
let real_name = pw.user_info().replace("&", &pw.name().capitalize());
|
||||
new_ucmd!()
|
||||
.arg("-l")
|
||||
.arg(login)
|
||||
.succeeds()
|
||||
.stdout_is(format!(
|
||||
"Login name: {:<28}In real life: {}\nDirectory: {:<29}Shell: {}\n\n",
|
||||
login,
|
||||
real_name,
|
||||
pw.user_dir(),
|
||||
pw.user_shell()
|
||||
));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
ts.ucmd().arg("-l").arg(login).succeeds().stdout_is(format!(
|
||||
"Login name: {:<28}In real life: {}\nDirectory: {:<29}Shell: {}\n\n",
|
||||
login,
|
||||
real_name,
|
||||
pw.user_dir(),
|
||||
pw.user_shell()
|
||||
));
|
||||
|
||||
new_ucmd!()
|
||||
ts.ucmd()
|
||||
.arg("-lb")
|
||||
.arg(login)
|
||||
.succeeds()
|
||||
|
|
@ -42,15 +44,18 @@ fn test_long_format() {
|
|||
));
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_long_format_multiple_users() {
|
||||
let args = ["-l", "root", "root", "root"];
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args));
|
||||
|
||||
new_ucmd!()
|
||||
ts.ucmd()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
.stdout_is(expect.stdout_str())
|
||||
.stderr_is(expect.stderr_str());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -59,55 +64,41 @@ fn test_long_format_wo_user() {
|
|||
new_ucmd!().arg("-l").fails().code_is(1);
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[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 = new_ucmd!().args(&args).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&args);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
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"))]
|
||||
#[cfg(unix)]
|
||||
#[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 = new_ucmd!().args(&args).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&args);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
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"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_no_flag() {
|
||||
let actual = new_ucmd!().succeeds().stdout_move_str();
|
||||
let expect = expected_result(&[]);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &[])).stdout_move_str();
|
||||
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 {
|
||||
#[cfg(target_os = "linux")]
|
||||
let util_name = util_name!();
|
||||
#[cfg(target_vendor = "apple")]
|
||||
let util_name = format!("g{}", util_name!());
|
||||
|
||||
// note: clippy::needless_borrow *false positive*
|
||||
#[allow(clippy::needless_borrow)]
|
||||
TestScenario::new(&util_name)
|
||||
.cmd_keepenv(util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.succeeds()
|
||||
.stdout_move_str()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,8 @@
|
|||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
extern crate regex;
|
||||
|
||||
use crate::common::util::*;
|
||||
|
|
@ -109,30 +114,29 @@ const FS_FORMAT_STR: &str = "%b %c %i %l %n %s %S %t %T"; // avoid "%a %d %f" wh
|
|||
#[cfg(target_os = "linux")]
|
||||
fn test_terse_fs_format() {
|
||||
let args = ["-f", "-t", "/proc"];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).run().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(target_os = "linux")]
|
||||
fn test_fs_format() {
|
||||
let args = ["-f", "-c", FS_FORMAT_STR, "/dev/shm"];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.run()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).run().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
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).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&args);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
println!("actual: {:?}", actual);
|
||||
println!("expect: {:?}", expect);
|
||||
let v_actual: Vec<&str> = actual.trim().split(' ').collect();
|
||||
|
|
@ -156,12 +160,13 @@ fn test_terse_normal_format() {
|
|||
);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_format_created_time() {
|
||||
let args = ["-c", "%w", "/bin"];
|
||||
let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&args);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
println!("actual: {:?}", actual);
|
||||
println!("expect: {:?}", expect);
|
||||
// note: using a regex instead of `split_whitespace()` in order to detect whitespace differences
|
||||
|
|
@ -180,12 +185,13 @@ fn test_format_created_time() {
|
|||
);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_format_created_seconds() {
|
||||
let args = ["-c", "%W", "/bin"];
|
||||
let actual = new_ucmd!().args(&args).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&args);
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
println!("actual: {:?}", actual);
|
||||
println!("expect: {:?}", expect);
|
||||
// note: using a regex instead of `split_whitespace()` in order to detect whitespace differences
|
||||
|
|
@ -204,21 +210,20 @@ fn test_format_created_seconds() {
|
|||
);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_normal_format() {
|
||||
let args = ["-c", NORMAL_FORMAT_STR, "/bin"];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_symlinks() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
let at = &scene.fixtures;
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let at = &ts.fixtures;
|
||||
|
||||
let mut tested: bool = false;
|
||||
// arbitrarily chosen symlinks with hope that the CI environment provides at least one of them
|
||||
|
|
@ -232,18 +237,12 @@ fn test_symlinks() {
|
|||
if at.file_exists(file) && at.is_symlink(file) {
|
||||
tested = true;
|
||||
let args = ["-c", NORMAL_FORMAT_STR, file];
|
||||
scene
|
||||
.ucmd()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
// -L, --dereference follow links
|
||||
let args = ["-L", "-c", NORMAL_FORMAT_STR, file];
|
||||
scene
|
||||
.ucmd()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
if !tested {
|
||||
|
|
@ -269,13 +268,12 @@ fn test_char() {
|
|||
#[cfg(any(target_vendor = "apple"))]
|
||||
"/dev/ptmx",
|
||||
];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_vendor = "apple"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_multi_files() {
|
||||
let args = [
|
||||
|
|
@ -287,38 +285,19 @@ fn test_multi_files() {
|
|||
"/etc/fstab",
|
||||
"/var",
|
||||
];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_printf() {
|
||||
let args = [
|
||||
"--printf=123%-# 15q\\r\\\"\\\\\\a\\b\\e\\f\\v%+020.23m\\x12\\167\\132\\112\\n",
|
||||
"/",
|
||||
];
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
}
|
||||
|
||||
#[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!());
|
||||
|
||||
// note: clippy::needless_borrow *false positive*
|
||||
#[allow(clippy::needless_borrow)]
|
||||
TestScenario::new(&util_name)
|
||||
.cmd_keepenv(util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.succeeds()
|
||||
.stdout_move_str()
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,38 +1,42 @@
|
|||
use crate::common::util::*;
|
||||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
// spell-checker:ignore (flags) runlevel mesg
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
use crate::common::util::*;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_count() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-q", "--count"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_boot() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-b", "--boot"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_heading() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-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).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&[opt]);
|
||||
let actual = ts.ucmd().arg(opt).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
println!("actual: {:?}", actual);
|
||||
println!("expect: {:?}", expect);
|
||||
let v_actual: Vec<&str> = actual.split_whitespace().collect();
|
||||
|
|
@ -41,76 +45,70 @@ fn test_heading() {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_short() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-s", "--short"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_login() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-l", "--login"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_m() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-m"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_process() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-p", "--process"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_runlevel() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-r", "--runlevel"] {
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
new_ucmd!().arg(opt).succeeds().stdout_is("");
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is("");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_time() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-t", "--time"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_mesg() {
|
||||
// -T, -w, --mesg
|
||||
|
|
@ -119,22 +117,20 @@ fn test_mesg() {
|
|||
// same as -T
|
||||
// --writable
|
||||
// same as -T
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-T", "-w", "--mesg", "--message", "--writable"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_arg1_arg2() {
|
||||
let args = ["am", "i"];
|
||||
|
||||
new_ucmd!()
|
||||
.args(&args)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&args));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -146,12 +142,13 @@ fn test_too_many_args() {
|
|||
new_ucmd!().args(&args).fails().stderr_contains(EXPECTED);
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_users() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-u", "--users"] {
|
||||
let actual = new_ucmd!().arg(opt).succeeds().stdout_move_str();
|
||||
let expect = expected_result(&[opt]);
|
||||
let actual = ts.ucmd().arg(opt).succeeds().stdout_move_str();
|
||||
let expect = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
println!("actual: {:?}", actual);
|
||||
println!("expect: {:?}", expect);
|
||||
|
||||
|
|
@ -170,28 +167,26 @@ fn test_users() {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_lookup() {
|
||||
let opt = "--lookup";
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_dead() {
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-d", "--dead"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_all_separately() {
|
||||
if cfg!(target_os = "macos") {
|
||||
|
|
@ -201,20 +196,14 @@ fn test_all_separately() {
|
|||
|
||||
// -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));
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
|
||||
ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &["--all"])).stdout_move_str();
|
||||
ts.ucmd().arg("--all").succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
|
||||
#[cfg(any(target_vendor = "apple", target_os = "linux"))]
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_all() {
|
||||
if cfg!(target_os = "macos") {
|
||||
|
|
@ -222,27 +211,9 @@ fn test_all() {
|
|||
return;
|
||||
}
|
||||
|
||||
let ts = TestScenario::new(util_name!());
|
||||
for opt in &["-a", "--all"] {
|
||||
new_ucmd!()
|
||||
.arg(opt)
|
||||
.succeeds()
|
||||
.stdout_is(expected_result(&[opt]));
|
||||
let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
|
||||
ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
|
||||
}
|
||||
}
|
||||
|
||||
#[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!());
|
||||
|
||||
// note: clippy::needless_borrow *false positive*
|
||||
#[allow(clippy::needless_borrow)]
|
||||
TestScenario::new(&util_name)
|
||||
.cmd_keepenv(util_name)
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.succeeds()
|
||||
.stdout_move_str()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,63 +1,48 @@
|
|||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
#[cfg(unix)]
|
||||
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: 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]
|
||||
#[cfg(unix)]
|
||||
fn test_normal() {
|
||||
let (_, mut ucmd) = at_and_ucmd!();
|
||||
let ts = TestScenario::new(util_name!());
|
||||
let result = ts.ucmd().run();
|
||||
let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
|
||||
|
||||
let result = ucmd.run();
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
result.no_stderr();
|
||||
assert!(!result.stdout_str().trim().is_empty());
|
||||
result
|
||||
.stdout_is(exp_result.stdout_str())
|
||||
.stderr_is(exp_result.stderr_str())
|
||||
.code_is(exp_result.code());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(windows))]
|
||||
#[cfg(unix)]
|
||||
fn test_normal_compare_id() {
|
||||
let scene = TestScenario::new(util_name!());
|
||||
|
||||
let result_ucmd = scene.ucmd().run();
|
||||
if skipping_test_is_okay(&result_ucmd, "failed to get username") {
|
||||
return;
|
||||
let ts = TestScenario::new("id");
|
||||
let id_un = unwrap_or_return!(expected_result(&ts, &["-un"]));
|
||||
if id_un.succeeded() {
|
||||
new_ucmd!().succeeds().stdout_is(id_un.stdout_str());
|
||||
} else if is_ci() && id_un.stderr_str().contains("cannot find name for user ID") {
|
||||
println!("test skipped:");
|
||||
} else {
|
||||
id_un.success();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_normal_compare_env() {
|
||||
let whoami = whoami();
|
||||
if whoami == "nobody" {
|
||||
println!("test skipped:");
|
||||
return;
|
||||
} else if !is_ci() {
|
||||
new_ucmd!().succeeds().stdout_is(format!("{}\n", whoami));
|
||||
} else {
|
||||
println!("test skipped:");
|
||||
}
|
||||
|
||||
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_ucmd.stdout_str().trim(),
|
||||
result_cmd.stdout_str().trim()
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,8 @@
|
|||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
/// Platform-independent helper for constructing a PathBuf from individual elements
|
||||
#[macro_export]
|
||||
macro_rules! path_concat {
|
||||
|
|
@ -66,3 +71,19 @@ macro_rules! at_and_ucmd {
|
|||
(ts.fixtures.clone(), ts.ucmd())
|
||||
}};
|
||||
}
|
||||
|
||||
/// If `common::util::expected_result` returns an error, i.e. the `util` in `$PATH` doesn't
|
||||
/// include a coreutils version string or the version is too low,
|
||||
/// this macro can be used to automatically skip the test and print the reason.
|
||||
#[macro_export]
|
||||
macro_rules! unwrap_or_return {
|
||||
( $e:expr ) => {
|
||||
match $e {
|
||||
Ok(x) => x,
|
||||
Err(e) => {
|
||||
println!("test skipped: {}", e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,10 +1,17 @@
|
|||
//spell-checker: ignore (linux) rlimit prlimit Rlim
|
||||
// * This file is part of the uutils coreutils package.
|
||||
// *
|
||||
// * For the full copyright and license information, please view the LICENSE
|
||||
// * file that was distributed with this source code.
|
||||
|
||||
//spell-checker: ignore (linux) rlimit prlimit Rlim coreutil
|
||||
|
||||
#![allow(dead_code)]
|
||||
|
||||
use pretty_assertions::assert_eq;
|
||||
#[cfg(target_os = "linux")]
|
||||
use rlimit::{prlimit, rlim};
|
||||
#[cfg(unix)]
|
||||
use std::borrow::Cow;
|
||||
use std::env;
|
||||
#[cfg(not(windows))]
|
||||
use std::ffi::CString;
|
||||
|
|
@ -695,7 +702,7 @@ impl AtPath {
|
|||
/// Fixtures can be found under `tests/fixtures/$util_name/`
|
||||
pub struct TestScenario {
|
||||
bin_path: PathBuf,
|
||||
util_name: String,
|
||||
pub util_name: String,
|
||||
pub fixtures: AtPath,
|
||||
tmpd: Rc<TempDir>,
|
||||
}
|
||||
|
|
@ -1036,6 +1043,179 @@ pub fn vec_of_size(n: usize) -> Vec<u8> {
|
|||
result
|
||||
}
|
||||
|
||||
pub fn whoami() -> String {
|
||||
// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
|
||||
//
|
||||
// From the Logs: "Build (ubuntu-18.04, x86_64-unknown-linux-gnu, feat_os_unix, use-cross)"
|
||||
// whoami: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for user ID 1001
|
||||
// id --name: cannot find name for group ID 116
|
||||
//
|
||||
// However, when running "id" from within "/bin/bash" it looks fine:
|
||||
// id: "uid=1001(runner) gid=118(docker) groups=118(docker),4(adm),101(systemd-journal)"
|
||||
// whoami: "runner"
|
||||
|
||||
// Use environment variable to get current user instead of
|
||||
// invoking `whoami` and fall back to user "nobody" on error.
|
||||
std::env::var("USER").unwrap_or_else(|e| {
|
||||
println!("{}: {}, using \"nobody\" instead", UUTILS_WARNING, e);
|
||||
"nobody".to_string()
|
||||
})
|
||||
}
|
||||
|
||||
/// Add prefix 'g' for `util_name` if not on linux
|
||||
#[cfg(unix)]
|
||||
pub fn host_name_for<'a>(util_name: &'a str) -> Cow<'a, str> {
|
||||
// In some environments, e.g. macOS/freebsd, the GNU coreutils are prefixed with "g"
|
||||
// to not interfere with the BSD counterparts already in `$PATH`.
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
return format!("g{}", util_name).into();
|
||||
#[cfg(target_os = "linux")]
|
||||
return util_name.into();
|
||||
}
|
||||
|
||||
// GNU coreutils version 8.32 is the reference version since it is the latest version and the
|
||||
// GNU test suite in "coreutils/.github/workflows/GnuTests.yml" runs against it.
|
||||
// However, here 8.30 was chosen because right now there's no ubuntu image for the github actions
|
||||
// CICD available with a higher version than 8.30.
|
||||
// GNU coreutils versions from the CICD images for comparison:
|
||||
// ubuntu-2004: 8.30 (latest)
|
||||
// ubuntu-1804: 8.28
|
||||
// macos-latest: 8.32
|
||||
const VERSION_MIN: &str = "8.30"; // minimum Version for the reference `coreutil` in `$PATH`
|
||||
|
||||
const UUTILS_WARNING: &str = "uutils-tests-warning";
|
||||
const UUTILS_INFO: &str = "uutils-tests-info";
|
||||
|
||||
/// Run `util_name --version` and return Ok if the version is >= `version_expected`.
|
||||
/// Returns an error if
|
||||
/// * `util_name` cannot run
|
||||
/// * the version cannot be parsed
|
||||
/// * the version is too low
|
||||
///
|
||||
/// This is used by `expected_result` to check if the coreutils version is >= `VERSION_MIN`.
|
||||
/// It makes sense to use this manually in a test if a feature
|
||||
/// is tested that was introduced after `VERSION_MIN`
|
||||
///
|
||||
/// Example:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use crate::common::util::*;
|
||||
/// const VERSION_MIN_MULTIPLE_USERS: &str = "8.31";
|
||||
///
|
||||
/// #[test]
|
||||
/// fn test_xyz() {
|
||||
/// unwrap_or_return!(check_coreutil_version(
|
||||
/// util_name!(),
|
||||
/// VERSION_MIN_MULTIPLE_USERS
|
||||
/// ));
|
||||
/// // proceed with the test...
|
||||
/// }
|
||||
/// ```
|
||||
#[cfg(unix)]
|
||||
pub fn check_coreutil_version(
|
||||
util_name: &str,
|
||||
version_expected: &str,
|
||||
) -> std::result::Result<String, String> {
|
||||
// example:
|
||||
// $ id --version | head -n 1
|
||||
// id (GNU coreutils) 8.32.162-4eda
|
||||
|
||||
let util_name = &host_name_for(util_name);
|
||||
log_info("run", format!("{} --version", util_name));
|
||||
let version_check = match Command::new(util_name.as_ref())
|
||||
.env("LC_ALL", "C")
|
||||
.arg("--version")
|
||||
.output()
|
||||
{
|
||||
Ok(s) => s,
|
||||
Err(e) => {
|
||||
return Err(format!(
|
||||
"{}: '{}' {}",
|
||||
UUTILS_WARNING,
|
||||
util_name,
|
||||
e.to_string()
|
||||
))
|
||||
}
|
||||
};
|
||||
std::str::from_utf8(&version_check.stdout).unwrap()
|
||||
.split('\n')
|
||||
.collect::<Vec<_>>()
|
||||
.get(0)
|
||||
.map_or_else(
|
||||
|| Err(format!("{}: unexpected output format for reference coreutil: '{} --version'", UUTILS_WARNING, util_name)),
|
||||
|s| {
|
||||
if s.contains(&format!("(GNU coreutils) {}", version_expected)) {
|
||||
Ok(format!("{}: {}", UUTILS_INFO, s.to_string()))
|
||||
} else if s.contains("(GNU coreutils)") {
|
||||
let version_found = s.split_whitespace().last().unwrap()[..4].parse::<f32>().unwrap_or_default();
|
||||
let version_expected = version_expected.parse::<f32>().unwrap_or_default();
|
||||
if version_found > version_expected {
|
||||
Ok(format!("{}: version for the reference coreutil '{}' is higher than expected; expected: {}, found: {}", UUTILS_INFO, util_name, version_expected, version_found))
|
||||
} else {
|
||||
Err(format!("{}: version for the reference coreutil '{}' does not match; expected: {}, found: {}", UUTILS_WARNING, util_name, version_expected, version_found)) }
|
||||
} else {
|
||||
Err(format!("{}: no coreutils version string found for reference coreutils '{} --version'", UUTILS_WARNING, util_name))
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// This runs the GNU coreutils `util_name` binary in `$PATH` in order to
|
||||
/// dynamically gather reference values on the system.
|
||||
/// If the `util_name` in `$PATH` doesn't include a coreutils version string,
|
||||
/// or the version is too low, this returns an error and the test should be skipped.
|
||||
///
|
||||
/// Example:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use crate::common::util::*;
|
||||
/// #[test]
|
||||
/// fn test_xyz() {
|
||||
/// let ts = TestScenario::new(util_name!());
|
||||
/// let result = ts.ucmd().run();
|
||||
/// let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
|
||||
/// result
|
||||
/// .stdout_is(exp_result.stdout_str())
|
||||
/// .stderr_is(exp_result.stderr_str())
|
||||
/// .code_is(exp_result.code());
|
||||
/// }
|
||||
///```
|
||||
#[cfg(unix)]
|
||||
pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<CmdResult, String> {
|
||||
let util_name = &host_name_for(&ts.util_name);
|
||||
println!("{}", check_coreutil_version(util_name, VERSION_MIN)?);
|
||||
|
||||
let result = ts
|
||||
.cmd_keepenv(util_name.as_ref())
|
||||
.env("LC_ALL", "C")
|
||||
.args(args)
|
||||
.run();
|
||||
|
||||
let (stdout, stderr): (String, String) = if cfg!(target_os = "linux") {
|
||||
(
|
||||
result.stdout_str().to_string(),
|
||||
result.stderr_str().to_string(),
|
||||
)
|
||||
} else {
|
||||
// `host_name_for` added prefix, strip 'g' prefix from results:
|
||||
let from = util_name.to_string() + ":";
|
||||
let to = &from[1..];
|
||||
(
|
||||
result.stdout_str().replace(&from, to),
|
||||
result.stderr_str().replace(&from, to),
|
||||
)
|
||||
};
|
||||
|
||||
Ok(CmdResult::new(
|
||||
Some(result.tmpd()),
|
||||
Some(result.code()),
|
||||
result.succeeded(),
|
||||
stdout.as_bytes(),
|
||||
stderr.as_bytes(),
|
||||
))
|
||||
}
|
||||
|
||||
/// Sanity checks for test utils
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
|
|
@ -1272,4 +1452,33 @@ mod tests {
|
|||
|
||||
res.normalized_newlines_stdout_is("A\r\nB\nC\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_check_coreutil_version() {
|
||||
match check_coreutil_version("id", VERSION_MIN) {
|
||||
Ok(s) => assert!(s.starts_with("uutils-tests-")),
|
||||
Err(s) => assert!(s.starts_with("uutils-tests-warning")),
|
||||
};
|
||||
#[cfg(target_os = "linux")]
|
||||
std::assert_eq!(
|
||||
check_coreutil_version("no test name", VERSION_MIN),
|
||||
Err("uutils-tests-warning: 'no test name' \
|
||||
No such file or directory (os error 2)"
|
||||
.to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn test_expected_result() {
|
||||
let ts = TestScenario::new("id");
|
||||
// assert!(expected_result(&ts, &[]).is_ok());
|
||||
match expected_result(&ts, &[]) {
|
||||
Ok(r) => assert!(r.succeeded()),
|
||||
Err(s) => assert!(s.starts_with("uutils-tests-warning")),
|
||||
}
|
||||
let ts = TestScenario::new("no test name");
|
||||
assert!(expected_result(&ts, &[]).is_err());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue