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

Merge pull request #7691 from nyurik/commas

Browse source 
chore: cleanup trailing commas before parens
This commit is contained in:
Daniel Hofstetter 2025-04-08 08:15:54 +02:00 • committed by GitHub
commit 8aaa8ff24d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 86 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

8
fuzz/fuzz_targets/fuzz_common/mod.rs
View file

@ -331,9 +331,9 @@ pub fn compare_result(
if rust_result.stdout.trim() != gnu_result.stdout.trim() { if rust_result.stdout.trim() != gnu_result.stdout.trim() {
discrepancies.push("stdout differs"); discrepancies.push("stdout differs");
println!("Rust stdout:",); println!("Rust stdout:");
print_or_empty(rust_result.stdout.as_str()); print_or_empty(rust_result.stdout.as_str());
println!("GNU stdout:",); println!("GNU stdout:");
print_or_empty(gnu_result.stdout.as_ref()); print_or_empty(gnu_result.stdout.as_ref());
print_diff(&rust_result.stdout, &gnu_result.stdout); print_diff(&rust_result.stdout, &gnu_result.stdout);
should_panic = true; should_panic = true;
@ -341,9 +341,9 @@ pub fn compare_result(
if rust_result.stderr.trim() != gnu_result.stderr.trim() { if rust_result.stderr.trim() != gnu_result.stderr.trim() {
discrepancies.push("stderr differs"); discrepancies.push("stderr differs");
println!("Rust stderr:",); println!("Rust stderr:");
print_or_empty(rust_result.stderr.as_str()); print_or_empty(rust_result.stderr.as_str());
println!("GNU stderr:",); println!("GNU stderr:");
print_or_empty(gnu_result.stderr.as_str()); print_or_empty(gnu_result.stderr.as_str());
print_diff(&rust_result.stderr, &gnu_result.stderr); print_diff(&rust_result.stderr, &gnu_result.stderr);
if fail_on_stderr_diff { if fail_on_stderr_diff {

2
src/uu/base32/src/base_common.rs
View file

@ -50,7 +50,7 @@ impl Config {
if let Some(extra_op) = values.next() { if let Some(extra_op) = values.next() {
return Err(UUsageError::new( return Err(UUsageError::new(
BASE_CMD_PARSE_ERROR, BASE_CMD_PARSE_ERROR,
format!("extra operand {}", extra_op.quote(),), format!("extra operand {}", extra_op.quote()),
)); ));
} }

2
src/uu/basename/src/basename.rs
View file

@ -57,7 +57,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
_ => { _ => {
return Err(UUsageError::new( return Err(UUsageError::new(
1, 1,
format!("extra operand {}", name_args[2].quote(),), format!("extra operand {}", name_args[2].quote()),
)); ));
} }
} }

6
src/uu/dd/src/blocks.rs
View file

@ -315,7 +315,7 @@ mod tests {
let buf = [0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8]; let buf = [0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8];
let res = unblock(&buf, 8); let res = unblock(&buf, 8);
assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE],); assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE]);
} }
#[test] #[test]
@ -323,7 +323,7 @@ mod tests {
let buf = [SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE]; let buf = [SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE];
let res = unblock(&buf, 8); let res = unblock(&buf, 8);
assert_eq!(res, vec![NEWLINE],); assert_eq!(res, vec![NEWLINE]);
} }
#[test] #[test]
@ -342,7 +342,7 @@ mod tests {
let buf = [0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE]; let buf = [0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE];
let res = unblock(&buf, 8); let res = unblock(&buf, 8);
assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE],); assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE]);
} }
#[test] #[test]

2
src/uu/dd/src/parseargs/unit_tests.rs
View file

@ -157,7 +157,7 @@ fn test_all_top_level_args_no_leading_dashes() {
); );
// no conv flags apply to output // no conv flags apply to output
assert_eq!(settings.oconv, OConvFlags::default(),); assert_eq!(settings.oconv, OConvFlags::default());
// iconv=count_bytes,skip_bytes // iconv=count_bytes,skip_bytes
assert_eq!( assert_eq!(

2
src/uu/expr/src/syntax_tree.rs
View file

@ -784,7 +784,7 @@ mod test {
AstNode::parse(&["index", "1", "2"]), AstNode::parse(&["index", "1", "2"]),
Ok(op(BinOp::String(StringOp::Index), "1", "2")), Ok(op(BinOp::String(StringOp::Index), "1", "2")),
); );
assert_eq!(AstNode::parse(&["length", "1"]), Ok(length("1")),); assert_eq!(AstNode::parse(&["length", "1"]), Ok(length("1")));
assert_eq!( assert_eq!(
AstNode::parse(&["substr", "1", "2", "3"]), AstNode::parse(&["substr", "1", "2", "3"]),
Ok(substr("1", "2", "3")), Ok(substr("1", "2", "3")),

2
src/uu/pathchk/src/pathchk.rs
View file

@ -197,7 +197,7 @@ fn check_default(path: &[String]) -> bool {
// but some non-POSIX hosts do (as an alias for "."), // but some non-POSIX hosts do (as an alias for "."),
// so allow "" if `symlink_metadata` (corresponds to `lstat`) does. // so allow "" if `symlink_metadata` (corresponds to `lstat`) does.
if fs::symlink_metadata(&joined_path).is_err() { if fs::symlink_metadata(&joined_path).is_err() {
writeln!(std::io::stderr(), "pathchk: '': No such file or directory",); writeln!(std::io::stderr(), "pathchk: '': No such file or directory");
return false; return false;
} }
} }

2
src/uu/sort/src/sort.rs
View file

@ -1946,7 +1946,7 @@ mod tests {
#[test] #[test]
fn test_tokenize_fields() { fn test_tokenize_fields() {
let line = "foo bar b x"; let line = "foo bar b x";
assert_eq!(tokenize_helper(line, None), vec![0..3, 3..7, 7..9, 9..14,],); assert_eq!(tokenize_helper(line, None), vec![0..3, 3..7, 7..9, 9..14,]);
} }
#[test] #[test]

2
src/uu/stty/src/flags.rs
View file

@ -279,7 +279,7 @@ pub const BAUD_RATES: &[(&str, BaudRate)] = &[
("500000", BaudRate::B500000), ("500000", BaudRate::B500000),
#[cfg(any(target_os = "android", target_os = "linux"))] #[cfg(any(target_os = "android", target_os = "linux"))]
("576000", BaudRate::B576000), ("576000", BaudRate::B576000),
#[cfg(any(target_os = "android", target_os = "linux",))] #[cfg(any(target_os = "android", target_os = "linux"))]
("921600", BaudRate::B921600), ("921600", BaudRate::B921600),
#[cfg(any(target_os = "android", target_os = "linux"))] #[cfg(any(target_os = "android", target_os = "linux"))]
("1000000", BaudRate::B1000000), ("1000000", BaudRate::B1000000),

2
src/uu/tr/src/tr.rs
View file

@ -85,7 +85,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
"{start} {op}\nOnly one string may be given when deleting without squeezing repeats.", "{start} {op}\nOnly one string may be given when deleting without squeezing repeats.",
) )
} else { } else {
format!("{start} {op}",) format!("{start} {op}")
}; };
return Err(UUsageError::new(1, msg)); return Err(UUsageError::new(1, msg));
} }

6
src/uucore/src/lib/features/version_cmp.rs
View file

@ -174,12 +174,12 @@ mod tests {
); );
// Shortened names // Shortened names
assert_eq!(version_cmp("world", "wo"), Ordering::Greater,); assert_eq!(version_cmp("world", "wo"), Ordering::Greater);
assert_eq!(version_cmp("hello10wo", "hello10world"), Ordering::Less,); assert_eq!(version_cmp("hello10wo", "hello10world"), Ordering::Less);
// Simple names // Simple names
assert_eq!(version_cmp("world", "hello"), Ordering::Greater,); assert_eq!(version_cmp("world", "hello"), Ordering::Greater);
assert_eq!(version_cmp("hello", "world"), Ordering::Less); assert_eq!(version_cmp("hello", "world"), Ordering::Less);

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

@ -4699,7 +4699,7 @@ mod same_file {
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4714,9 +4714,9 @@ mod same_file {
.args(&["--rem", FILE_NAME, SYMLINK_NAME]) .args(&["--rem", FILE_NAME, SYMLINK_NAME])
.succeeds(); .succeeds();
assert!(at.file_exists(SYMLINK_NAME)); assert!(at.file_exists(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -4734,9 +4734,9 @@ mod same_file {
assert!(at.symlink_exists(backup)); assert!(at.symlink_exists(backup));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
assert!(at.file_exists(SYMLINK_NAME)); assert!(at.file_exists(SYMLINK_NAME));
assert_eq!(at.read(SYMLINK_NAME), CONTENTS,); assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4755,7 +4755,7 @@ mod same_file {
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4772,7 +4772,7 @@ mod same_file {
.succeeds(); .succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(SYMLINK_NAME)); assert!(at.file_exists(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4792,7 +4792,7 @@ mod same_file {
assert!(at.file_exists(SYMLINK_NAME)); assert!(at.file_exists(SYMLINK_NAME));
assert!(at.symlink_exists(backup)); assert!(at.symlink_exists(backup));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4810,7 +4810,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -4826,7 +4826,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
// the following tests tries to copy a symlink to the file that symlink points to with // the following tests tries to copy a symlink to the file that symlink points to with
// various options // various options
@ -4845,7 +4845,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4864,7 +4864,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
#[test] #[test]
@ -4884,7 +4884,7 @@ mod same_file {
// this doesn't makes sense but this is how gnu does it // this doesn't makes sense but this is how gnu does it
assert_eq!(FILE_NAME, at.resolve_link(FILE_NAME)); assert_eq!(FILE_NAME, at.resolve_link(FILE_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(backup), CONTENTS,); assert_eq!(at.read(backup), CONTENTS);
} }
} }
@ -4902,7 +4902,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4921,7 +4921,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.symlink_exists(SYMLINK_NAME)); assert!(at.symlink_exists(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4938,7 +4938,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("'foo' and 'foo' are the same file"); .stderr_contains("'foo' and 'foo' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
#[test] #[test]
@ -4953,7 +4953,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("'foo' and 'foo' are the same file"); .stderr_contains("'foo' and 'foo' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -4970,8 +4970,8 @@ mod same_file {
.succeeds(); .succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(backup)); assert!(at.file_exists(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(at.read(backup), CONTENTS,); assert_eq!(at.read(backup), CONTENTS);
} }
} }
@ -4988,7 +4988,7 @@ mod same_file {
.succeeds(); .succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(!at.file_exists(backup)); assert!(!at.file_exists(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5005,8 +5005,8 @@ mod same_file {
.succeeds(); .succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(backup)); assert!(at.file_exists(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(at.read(backup), CONTENTS,); assert_eq!(at.read(backup), CONTENTS);
} }
} }
@ -5022,7 +5022,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("'foo' and 'foo' are the same file"); .stderr_contains("'foo' and 'foo' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5040,7 +5040,7 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&[option, symlink1, symlink2]).succeeds(); scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(FILE_NAME, at.resolve_link(symlink2)); assert_eq!(FILE_NAME, at.resolve_link(symlink2));
} }
@ -5061,7 +5061,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("'sl1' and 'sl2' are the same file"); .stderr_contains("'sl1' and 'sl2' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(FILE_NAME, at.resolve_link(symlink2)); assert_eq!(FILE_NAME, at.resolve_link(symlink2));
} }
@ -5077,10 +5077,10 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&["--rem", symlink1, symlink2]).succeeds(); scene.ucmd().args(&["--rem", symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert!(at.file_exists(symlink2)); assert!(at.file_exists(symlink2));
assert_eq!(at.read(symlink2), CONTENTS,); assert_eq!(at.read(symlink2), CONTENTS);
} }
#[test] #[test]
@ -5096,10 +5096,10 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&[option, symlink1, symlink2]).succeeds(); scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert!(at.file_exists(symlink2)); assert!(at.file_exists(symlink2));
assert_eq!(at.read(symlink2), CONTENTS,); assert_eq!(at.read(symlink2), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
} }
} }
@ -5117,7 +5117,7 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&[option, symlink1, symlink2]).succeeds(); scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(FILE_NAME, at.resolve_link(symlink2)); assert_eq!(FILE_NAME, at.resolve_link(symlink2));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
@ -5138,7 +5138,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("cannot create hard link 'sl2' to 'sl1'"); .stderr_contains("cannot create hard link 'sl2' to 'sl1'");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(FILE_NAME, at.resolve_link(symlink2)); assert_eq!(FILE_NAME, at.resolve_link(symlink2));
} }
@ -5154,10 +5154,10 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&["-fl", symlink1, symlink2]).succeeds(); scene.ucmd().args(&["-fl", symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert!(at.file_exists(symlink2)); assert!(at.file_exists(symlink2));
assert_eq!(at.read(symlink2), CONTENTS,); assert_eq!(at.read(symlink2), CONTENTS);
} }
#[test] #[test]
@ -5173,10 +5173,10 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&[option, symlink1, symlink2]).succeeds(); scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert!(at.file_exists(symlink2)); assert!(at.file_exists(symlink2));
assert_eq!(at.read(symlink2), CONTENTS,); assert_eq!(at.read(symlink2), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
} }
} }
@ -5196,7 +5196,7 @@ mod same_file {
.fails() .fails()
.stderr_contains("cannot create symlink 'sl2' to 'sl1'"); .stderr_contains("cannot create symlink 'sl2' to 'sl1'");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(FILE_NAME, at.resolve_link(symlink2)); assert_eq!(FILE_NAME, at.resolve_link(symlink2));
} }
@ -5212,7 +5212,7 @@ mod same_file {
at.symlink_file(FILE_NAME, symlink2); at.symlink_file(FILE_NAME, symlink2);
scene.ucmd().args(&["-sf", symlink1, symlink2]).succeeds(); scene.ucmd().args(&["-sf", symlink1, symlink2]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(FILE_NAME, at.resolve_link(symlink1)); assert_eq!(FILE_NAME, at.resolve_link(symlink1));
assert_eq!(symlink1, at.resolve_link(symlink2)); assert_eq!(symlink1, at.resolve_link(symlink2));
} }
@ -5235,7 +5235,7 @@ mod same_file {
.stderr_contains("'foo' and 'hardlink' are the same file"); .stderr_contains("'foo' and 'hardlink' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(hardlink)); assert!(at.file_exists(hardlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5252,7 +5252,7 @@ mod same_file {
.succeeds(); .succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(hardlink)); assert!(at.file_exists(hardlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5268,7 +5268,7 @@ mod same_file {
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(hardlink)); assert!(at.file_exists(hardlink));
assert!(at.file_exists(backup)); assert!(at.file_exists(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5283,7 +5283,7 @@ mod same_file {
scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds(); scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds();
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(hardlink)); assert!(at.file_exists(hardlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5302,7 +5302,7 @@ mod same_file {
.stderr_contains("'foo' and 'hardlink' are the same file"); .stderr_contains("'foo' and 'hardlink' are the same file");
assert!(at.file_exists(FILE_NAME)); assert!(at.file_exists(FILE_NAME));
assert!(at.file_exists(hardlink)); assert!(at.file_exists(hardlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5326,7 +5326,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5347,7 +5347,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5368,7 +5368,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5389,8 +5389,8 @@ mod same_file {
assert!(!at.symlink_exists(SYMLINK_NAME)); assert!(!at.symlink_exists(SYMLINK_NAME));
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(at.read(SYMLINK_NAME), CONTENTS,); assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
} }
#[test] #[test]
@ -5414,8 +5414,8 @@ mod same_file {
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert!(at.symlink_exists(backup)); assert!(at.symlink_exists(backup));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
assert_eq!(at.read(SYMLINK_NAME), CONTENTS,); assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
} }
} }
@ -5440,7 +5440,7 @@ mod same_file {
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert!(at.symlink_exists(backup)); assert!(at.symlink_exists(backup));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5462,7 +5462,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5483,7 +5483,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5504,7 +5504,7 @@ mod same_file {
assert!(!at.symlink_exists(SYMLINK_NAME)); assert!(!at.symlink_exists(SYMLINK_NAME));
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5528,7 +5528,7 @@ mod same_file {
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert!(at.symlink_exists(backup)); assert!(at.symlink_exists(backup));
assert_eq!(FILE_NAME, at.resolve_link(backup)); assert_eq!(FILE_NAME, at.resolve_link(backup));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5550,7 +5550,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }
@ -5572,7 +5572,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME)); assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
#[test] #[test]
@ -5592,7 +5592,7 @@ mod same_file {
assert!(at.symlink_exists(hardlink_to_symlink)); assert!(at.symlink_exists(hardlink_to_symlink));
assert_eq!(hardlink_to_symlink, at.resolve_link(SYMLINK_NAME)); assert_eq!(hardlink_to_symlink, at.resolve_link(SYMLINK_NAME));
assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink)); assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
assert_eq!(at.read(FILE_NAME), CONTENTS,); assert_eq!(at.read(FILE_NAME), CONTENTS);
} }
} }

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

@ -68,7 +68,7 @@ fn du_basics(s: &str) {
assert_eq!(s, answer); assert_eq!(s, answer);
} }
#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows"),))] #[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
fn du_basics(s: &str) { fn du_basics(s: &str) {
let answer = concat!( let answer = concat!(
"8\t./subdir/deeper/deeper_dir\n", "8\t./subdir/deeper/deeper_dir\n",

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

@ -383,7 +383,7 @@ fn test_id_zero() {
fn test_id_context() { fn test_id_context() {
use selinux::{self, KernelSupport}; use selinux::{self, KernelSupport};
if selinux::kernel_support() == KernelSupport::Unsupported { if selinux::kernel_support() == KernelSupport::Unsupported {
println!("test skipped: Kernel has no support for SElinux context",); println!("test skipped: Kernel has no support for SElinux context");
return; return;
} }
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
@ -458,7 +458,7 @@ fn test_id_no_specified_user_posixly() {
{ {
use selinux::{self, KernelSupport}; use selinux::{self, KernelSupport};
if selinux::kernel_support() == KernelSupport::Unsupported { if selinux::kernel_support() == KernelSupport::Unsupported {
println!("test skipped: Kernel has no support for SElinux context",); println!("test skipped: Kernel has no support for SElinux context");
} else { } else {
let result = ts.ucmd().succeeds(); let result = ts.ucmd().succeeds();
assert!(result.stdout_str().contains("context=")); assert!(result.stdout_str().contains("context="));

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

@ -4155,7 +4155,7 @@ fn test_ls_dangling_symlinks() {
fn test_ls_context1() { fn test_ls_context1() {
use selinux::{self, KernelSupport}; use selinux::{self, KernelSupport};
if selinux::kernel_support() == KernelSupport::Unsupported { if selinux::kernel_support() == KernelSupport::Unsupported {
println!("test skipped: Kernel has no support for SElinux context",); println!("test skipped: Kernel has no support for SElinux context");
return; return;
} }
@ -4171,7 +4171,7 @@ fn test_ls_context1() {
fn test_ls_context2() { fn test_ls_context2() {
use selinux::{self, KernelSupport}; use selinux::{self, KernelSupport};
if selinux::kernel_support() == KernelSupport::Unsupported { if selinux::kernel_support() == KernelSupport::Unsupported {
println!("test skipped: Kernel has no support for SElinux context",); println!("test skipped: Kernel has no support for SElinux context");
return; return;
} }
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
@ -4188,7 +4188,7 @@ fn test_ls_context2() {
fn test_ls_context_format() { fn test_ls_context_format() {
use selinux::{self, KernelSupport}; use selinux::{self, KernelSupport};
if selinux::kernel_support() == KernelSupport::Unsupported { if selinux::kernel_support() == KernelSupport::Unsupported {
println!("test skipped: Kernel has no support for SElinux context",); println!("test skipped: Kernel has no support for SElinux context");
return; return;
} }
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());

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

@ -421,7 +421,7 @@ fn test_mv_same_file() {
ucmd.arg(file_a) ucmd.arg(file_a)
.arg(file_a) .arg(file_a)
.fails() .fails()
.stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n",)); .stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n"));
} }
#[test] #[test]
@ -438,7 +438,7 @@ fn test_mv_same_hardlink() {
ucmd.arg(file_a) ucmd.arg(file_a)
.arg(file_b) .arg(file_b)
.fails() .fails()
.stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n",)); .stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n"));
} }
#[test] #[test]
@ -456,7 +456,7 @@ fn test_mv_same_symlink() {
ucmd.arg(file_b) ucmd.arg(file_b)
.arg(file_a) .arg(file_a)
.fails() .fails()
.stderr_is(format!("mv: '{file_b}' and '{file_a}' are the same file\n",)); .stderr_is(format!("mv: '{file_b}' and '{file_a}' are the same file\n"));
let (at2, mut ucmd2) = at_and_ucmd!(); let (at2, mut ucmd2) = at_and_ucmd!();
at2.touch(file_a); at2.touch(file_a);
@ -1811,7 +1811,7 @@ mod inter_partition_copying {
// make sure that file contents in other_fs_file didn't change. // make sure that file contents in other_fs_file didn't change.
assert_eq!( assert_eq!(
read_to_string(&other_fs_file_path,).expect("Unable to read other_fs_file"), read_to_string(&other_fs_file_path).expect("Unable to read other_fs_file"),
"other fs file contents" "other fs file contents"
); );

2
tests/test_util_name.rs
View file

@ -41,7 +41,7 @@ fn execution_phrase_double() {
assert!( assert!(
String::from_utf8(output.stderr) String::from_utf8(output.stderr)
.unwrap() .unwrap()
.contains(&format!("Usage: {} ls", scenario.bin_path.display(),)) .contains(&format!("Usage: {} ls", scenario.bin_path.display()))
); );
} }