RGBCube/uutils-coreutils
1
Fork 0
mirror of https://github.com/RGBCube/uutils-coreutils synced 2025-07-29 12:07:46 +00:00
Code Issues Activity

Merge pull request #6748 from dcampbell24/fix-clippy-reduced-commits-try-try-again

Browse source 
Clippy Pedantic Acceptable Commits Try Again
This commit is contained in:
Sylvestre Ledru 2024-09-30 09:34:10 +02:00 • committed by GitHub
commit 892e9a4bc0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
57 changed files with 255 additions and 294 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/uu/cksum/src/cksum.rs
View file

@ -168,13 +168,13 @@ where
} }
} }
}; };
print!("{}", before_filename); print!("{before_filename}");
if should_print_filename { if should_print_filename {
// The filename might not be valid UTF-8, and filename.display() would mangle the names. // The filename might not be valid UTF-8, and filename.display() would mangle the names.
// Therefore, emit the bytes directly to stdout, without any attempt at encoding them. // Therefore, emit the bytes directly to stdout, without any attempt at encoding them.
let _dropped_result = stdout().write_all(os_str_as_bytes(filename.as_os_str())?); let _dropped_result = stdout().write_all(os_str_as_bytes(filename.as_os_str())?);
} }
println!("{}", after_filename); println!("{after_filename}");
} }
Ok(()) Ok(())

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

@ -42,7 +42,7 @@ struct LineReader {
impl LineReader { impl LineReader {
fn new(input: Input, line_ending: LineEnding) -> Self { fn new(input: Input, line_ending: LineEnding) -> Self {
Self { input, line_ending } Self { line_ending, input }
} }
fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {

2
src/uu/cp/src/copydir.rs
View file

@ -175,7 +175,7 @@ impl Entry {
let source_is_dir = direntry.path().is_dir(); let source_is_dir = direntry.path().is_dir();
if path_ends_with_terminator(context.target) && source_is_dir { if path_ends_with_terminator(context.target) && source_is_dir {
if let Err(e) = std::fs::create_dir_all(context.target) { if let Err(e) = std::fs::create_dir_all(context.target) {
eprintln!("Failed to create directory: {}", e); eprintln!("Failed to create directory: {e}");
} }
} else { } else {
descendant = descendant.strip_prefix(context.root)?.to_path_buf(); descendant = descendant.strip_prefix(context.root)?.to_path_buf();

5
src/uu/cut/src/cut.rs
View file

@ -476,10 +476,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
Options { Options {
out_delimiter, out_delimiter,
line_ending, line_ending,
field_opts: Some(FieldOptions { field_opts: Some(FieldOptions { delimiter, only_delimited })},
only_delimited,
delimiter,
})},
) )
}), }),
(2.., _, _, _) => Err( (2.., _, _, _) => Err(

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

@ -237,7 +237,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
None => { None => {
return Err(USimpleError::new( return Err(USimpleError::new(
1, 1,
format!("invalid date {}", relative_time), format!("invalid date {relative_time}"),
)); ));
} }
} }

4
src/uu/df/src/df.rs
View file

@ -444,7 +444,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
None => { None => {
let filesystems = get_all_filesystems(&opt).map_err(|e| { let filesystems = get_all_filesystems(&opt).map_err(|e| {
let context = "cannot read table of mounted file systems"; let context = "cannot read table of mounted file systems";
USimpleError::new(e.code(), format!("{}: {}", context, e)) USimpleError::new(e.code(), format!("{context}: {e}"))
})?; })?;
if filesystems.is_empty() { if filesystems.is_empty() {
@ -457,7 +457,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let paths: Vec<_> = paths.collect(); let paths: Vec<_> = paths.collect();
let filesystems = get_named_filesystems(&paths, &opt).map_err(|e| { let filesystems = get_named_filesystems(&paths, &opt).map_err(|e| {
let context = "cannot read table of mounted file systems"; let context = "cannot read table of mounted file systems";
USimpleError::new(e.code(), format!("{}: {}", context, e)) USimpleError::new(e.code(), format!("{context}: {e}"))
})?; })?;
// This can happen if paths are given as command-line arguments // This can happen if paths are given as command-line arguments

2
src/uu/df/src/filesystem.rs
View file

@ -111,9 +111,9 @@ impl Filesystem {
#[cfg(windows)] #[cfg(windows)]
let usage = FsUsage::new(Path::new(&_stat_path)).ok()?; let usage = FsUsage::new(Path::new(&_stat_path)).ok()?;
Some(Self { Some(Self {
file,
mount_info, mount_info,
usage, usage,
file,
}) })
} }

18
src/uu/df/src/table.rs
View file

@ -841,12 +841,12 @@ mod tests {
}, },
usage: crate::table::FsUsage { usage: crate::table::FsUsage {
blocksize: 4096, blocksize: 4096,
blocks: 244029695, blocks: 244_029_695,
bfree: 125085030, bfree: 125_085_030,
bavail: 125085030, bavail: 125_085_030,
bavail_top_bit_set: false, bavail_top_bit_set: false,
files: 999, files: 999,
ffree: 1000000, ffree: 1_000_000,
}, },
}; };
@ -871,12 +871,12 @@ mod tests {
}, },
usage: crate::table::FsUsage { usage: crate::table::FsUsage {
blocksize: 4096, blocksize: 4096,
blocks: 244029695, blocks: 244_029_695,
bfree: 125085030, bfree: 125_085_030,
bavail: 125085030, bavail: 125_085_030,
bavail_top_bit_set: false, bavail_top_bit_set: false,
files: 99999999999, files: 99_999_999_999,
ffree: 999999, ffree: 999_999,
}, },
}; };

17
src/uu/dircolors/src/dircolors.rs
View file

@ -78,14 +78,14 @@ pub fn generate_type_output(fmt: &OutputFmt) -> String {
match fmt { match fmt {
OutputFmt::Display => FILE_TYPES OutputFmt::Display => FILE_TYPES
.iter() .iter()
.map(|&(_, key, val)| format!("\x1b[{}m{}\t{}\x1b[0m", val, key, val)) .map(|&(_, key, val)| format!("\x1b[{val}m{key}\t{val}\x1b[0m"))
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join("\n"), .join("\n"),
_ => { _ => {
// Existing logic for other formats // Existing logic for other formats
FILE_TYPES FILE_TYPES
.iter() .iter()
.map(|&(_, v1, v2)| format!("{}={}", v1, v2)) .map(|&(_, v1, v2)| format!("{v1}={v2}"))
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join(":") .join(":")
} }
@ -100,8 +100,7 @@ fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
display_parts.push(type_output); display_parts.push(type_output);
for &(extension, code) in FILE_COLORS { for &(extension, code) in FILE_COLORS {
let prefix = if extension.starts_with('*') { "" } else { "*" }; let prefix = if extension.starts_with('*') { "" } else { "*" };
let formatted_extension = let formatted_extension = format!("\x1b[{code}m{prefix}{extension}\t{code}\x1b[0m");
format!("\x1b[{}m{}{}\t{}\x1b[0m", code, prefix, extension, code);
display_parts.push(formatted_extension); display_parts.push(formatted_extension);
} }
display_parts.join("\n") display_parts.join("\n")
@ -111,8 +110,8 @@ fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
let mut parts = vec![]; let mut parts = vec![];
for &(extension, code) in FILE_COLORS { for &(extension, code) in FILE_COLORS {
let prefix = if extension.starts_with('*') { "" } else { "*" }; let prefix = if extension.starts_with('*') { "" } else { "*" };
let formatted_extension = format!("{}{}", prefix, extension); let formatted_extension = format!("{prefix}{extension}");
parts.push(format!("{}={}", formatted_extension, code)); parts.push(format!("{formatted_extension}={code}"));
} }
let (prefix, suffix) = get_colors_format_strings(fmt); let (prefix, suffix) = get_colors_format_strings(fmt);
let ls_colors = parts.join(sep); let ls_colors = parts.join(sep);
@ -493,7 +492,7 @@ pub fn generate_dircolors_config() -> String {
); );
config.push_str("COLORTERM ?*\n"); config.push_str("COLORTERM ?*\n");
for term in TERMS { for term in TERMS {
config.push_str(&format!("TERM {}\n", term)); config.push_str(&format!("TERM {term}\n"));
} }
config.push_str( config.push_str(
@ -514,14 +513,14 @@ pub fn generate_dircolors_config() -> String {
); );
for (name, _, code) in FILE_TYPES { for (name, _, code) in FILE_TYPES {
config.push_str(&format!("{} {}\n", name, code)); config.push_str(&format!("{name} {code}\n"));
} }
config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n"); config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n");
config.push_str("# to color below. Put the extension, a space, and the color init string.\n"); config.push_str("# to color below. Put the extension, a space, and the color init string.\n");
for (ext, color) in FILE_COLORS { for (ext, color) in FILE_COLORS {
config.push_str(&format!("{} {}\n", ext, color)); config.push_str(&format!("{ext} {color}\n"));
} }
config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n"); config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n");
config.push_str("# config specific to those matching environment variables."); config.push_str("# config specific to those matching environment variables.");

7
src/uu/du/src/du.rs
View file

@ -594,7 +594,7 @@ fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
if path.is_dir() { if path.is_dir() {
return Err(std::io::Error::new( return Err(std::io::Error::new(
std::io::ErrorKind::Other, std::io::ErrorKind::Other,
format!("{}: read error: Is a directory", file_name), format!("{file_name}: read error: Is a directory"),
)); ));
} }
@ -604,10 +604,7 @@ fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => { Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Err(std::io::Error::new( return Err(std::io::Error::new(
std::io::ErrorKind::Other, std::io::ErrorKind::Other,
format!( format!("cannot open '{file_name}' for reading: No such file or directory"),
"cannot open '{}' for reading: No such file or directory",
file_name
),
)) ))
} }
Err(e) => return Err(e), Err(e) => return Err(e),

10
src/uu/env/src/env.rs vendored
View file

@ -65,7 +65,7 @@ fn print_env(line_ending: LineEnding) {
let stdout_raw = io::stdout(); let stdout_raw = io::stdout();
let mut stdout = stdout_raw.lock(); let mut stdout = stdout_raw.lock();
for (n, v) in env::vars() { for (n, v) in env::vars() {
write!(stdout, "{}={}{}", n, v, line_ending).unwrap(); write!(stdout, "{n}={v}{line_ending}").unwrap();
} }
} }
@ -281,15 +281,15 @@ pub fn parse_args_from_str(text: &NativeIntStr) -> UResult<Vec<NativeIntString>>
USimpleError::new(125, "invalid backslash at end of string in -S") USimpleError::new(125, "invalid backslash at end of string in -S")
} }
parse_error::ParseError::InvalidSequenceBackslashXInMinusS { pos: _, c } => { parse_error::ParseError::InvalidSequenceBackslashXInMinusS { pos: _, c } => {
USimpleError::new(125, format!("invalid sequence '\\{}' in -S", c)) USimpleError::new(125, format!("invalid sequence '\\{c}' in -S"))
} }
parse_error::ParseError::MissingClosingQuote { pos: _, c: _ } => { parse_error::ParseError::MissingClosingQuote { pos: _, c: _ } => {
USimpleError::new(125, "no terminating quote in -S string") USimpleError::new(125, "no terminating quote in -S string")
} }
parse_error::ParseError::ParsingOfVariableNameFailed { pos, msg } => { parse_error::ParseError::ParsingOfVariableNameFailed { pos, msg } => {
USimpleError::new(125, format!("variable name issue (at {}): {}", pos, msg,)) USimpleError::new(125, format!("variable name issue (at {pos}): {msg}",))
} }
_ => USimpleError::new(125, format!("Error: {:?}", e)), _ => USimpleError::new(125, format!("Error: {e:?}")),
}) })
} }
@ -393,7 +393,7 @@ impl EnvAppData {
| clap::error::ErrorKind::DisplayVersion => e.into(), | clap::error::ErrorKind::DisplayVersion => e.into(),
_ => { _ => {
// extent any real issue with parameter parsing by the ERROR_MSG_S_SHEBANG // extent any real issue with parameter parsing by the ERROR_MSG_S_SHEBANG
let s = format!("{}", e); let s = format!("{e}");
if !s.is_empty() { if !s.is_empty() {
let s = s.trim_end(); let s = s.trim_end();
uucore::show_error!("{}", s); uucore::show_error!("{}", s);

2
src/uu/env/src/parse_error.rs vendored
View file

@ -39,7 +39,7 @@ pub enum ParseError {
impl fmt::Display for ParseError { impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(format!("{:?}", self).as_str()) f.write_str(format!("{self:?}").as_str())
} }
} }

4
src/uu/env/src/variable_parser.rs vendored
View file

@ -21,7 +21,7 @@ impl<'a, 'b> VariableParser<'a, 'b> {
if c.is_ascii_digit() { if c.is_ascii_digit() {
return Err(ParseError::ParsingOfVariableNameFailed { return Err(ParseError::ParsingOfVariableNameFailed {
pos: self.parser.get_peek_position(), pos: self.parser.get_peek_position(),
msg: format!("Unexpected character: '{}', expected variable name must not start with 0..9", c) }); msg: format!("Unexpected character: '{c}', expected variable name must not start with 0..9") });
} }
} }
Ok(()) Ok(())
@ -79,7 +79,7 @@ impl<'a, 'b> VariableParser<'a, 'b> {
Some(c) => { Some(c) => {
return Err(ParseError::ParsingOfVariableNameFailed { return Err(ParseError::ParsingOfVariableNameFailed {
pos: self.parser.get_peek_position(), pos: self.parser.get_peek_position(),
msg: format!("Unexpected character: '{}', expected a closing brace ('}}') or colon (':')", c) msg: format!("Unexpected character: '{c}', expected a closing brace ('}}') or colon (':')")
}) })
}, },
}; };

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

@ -139,7 +139,7 @@ impl StringOp {
Self::Match => { Self::Match => {
let left = left.eval()?.eval_as_string(); let left = left.eval()?.eval_as_string();
let right = right.eval()?.eval_as_string(); let right = right.eval()?.eval_as_string();
let re_string = format!("^{}", right); let re_string = format!("^{right}");
let re = Regex::with_options( let re = Regex::with_options(
&re_string, &re_string,
RegexOptions::REGEX_OPTION_NONE, RegexOptions::REGEX_OPTION_NONE,

6
src/uu/factor/src/factor.rs
View file

@ -66,12 +66,12 @@ fn write_result(
for (factor, n) in factorization { for (factor, n) in factorization {
if print_exponents { if print_exponents {
if n > 1 { if n > 1 {
write!(w, " {}^{}", factor, n)?; write!(w, " {factor}^{n}")?;
} else { } else {
write!(w, " {}", factor)?; write!(w, " {factor}")?;
} }
} else { } else {
w.write_all(format!(" {}", factor).repeat(n).as_bytes())?; w.write_all(format!(" {factor}").repeat(n).as_bytes())?;
} }
} }
writeln!(w)?; writeln!(w)?;

8
src/uu/fmt/src/fmt.rs
View file

@ -129,7 +129,7 @@ impl FmtOptions {
if width > MAX_WIDTH { if width > MAX_WIDTH {
return Err(USimpleError::new( return Err(USimpleError::new(
1, 1,
format!("invalid width: '{}': Numerical result out of range", width), format!("invalid width: '{width}': Numerical result out of range"),
)); ));
} }
@ -154,13 +154,13 @@ impl FmtOptions {
crown, crown,
tagged, tagged,
mail, mail,
uniform,
quick,
split_only, split_only,
prefix, prefix,
xprefix, xprefix,
anti_prefix, anti_prefix,
xanti_prefix, xanti_prefix,
uniform,
quick,
width, width,
goal, goal,
tabwidth, tabwidth,
@ -241,7 +241,7 @@ fn extract_files(matches: &ArgMatches) -> UResult<Vec<String>> {
} else { } else {
let first_num = x.chars().nth(1).expect("a negative number should be at least two characters long"); let first_num = x.chars().nth(1).expect("a negative number should be at least two characters long");
Some(Err( Some(Err(
UUsageError::new(1, format!("invalid option -- {}; -WIDTH is recognized only when it is the first\noption; use -w N instead", first_num)) UUsageError::new(1, format!("invalid option -- {first_num}; -WIDTH is recognized only when it is the first\noption; use -w N instead"))
)) ))
} }
} else { } else {

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

@ -96,7 +96,7 @@ fn create_algorithm_from_flags(matches: &ArgMatches) -> UResult<HashAlgorithm> {
set_or_err(detect_algo("b3sum", None)?)?; set_or_err(detect_algo("b3sum", None)?)?;
} }
if matches.get_flag("sha3") { if matches.get_flag("sha3") {
let bits = matches.get_one::<usize>("bits").cloned(); let bits = matches.get_one::<usize>("bits").copied();
set_or_err(create_sha3(bits)?)?; set_or_err(create_sha3(bits)?)?;
} }
if matches.get_flag("sha3-224") { if matches.get_flag("sha3-224") {

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

@ -158,7 +158,7 @@ fn table() {
.enumerate() .enumerate()
.filter(|(_, s)| **s != "EXIT") .filter(|(_, s)| **s != "EXIT")
{ {
println!("{0: >#2} {1}", idx, signal); println!("{idx: >#2} {signal}");
} }
} }

4
src/uu/ls/src/dired.rs
View file

@ -122,9 +122,9 @@ pub fn print_dired_output(
/// Helper function to print positions with a given prefix. /// Helper function to print positions with a given prefix.
fn print_positions(prefix: &str, positions: &Vec<BytePosition>) { fn print_positions(prefix: &str, positions: &Vec<BytePosition>) {
print!("{}", prefix); print!("{prefix}");
for c in positions { for c in positions {
print!(" {}", c); print!(" {c}");
} }
println!(); println!();
} }

16
src/uu/ls/src/ls.rs
View file

@ -831,7 +831,7 @@ impl Config {
options::FULL_TIME, options::FULL_TIME,
] ]
.iter() .iter()
.flat_map(|opt| { .filter_map(|opt| {
if options.value_source(opt) == Some(clap::parser::ValueSource::CommandLine) { if options.value_source(opt) == Some(clap::parser::ValueSource::CommandLine) {
options.indices_of(opt) options.indices_of(opt)
} else { } else {
@ -2040,7 +2040,7 @@ fn show_dir_name(path_data: &PathData, out: &mut BufWriter<Stdout>, config: &Con
if config.hyperlink && !config.dired { if config.hyperlink && !config.dired {
let name = escape_name(path_data.p_buf.as_os_str(), &config.quoting_style); let name = escape_name(path_data.p_buf.as_os_str(), &config.quoting_style);
let hyperlink = create_hyperlink(&name, path_data); let hyperlink = create_hyperlink(&name, path_data);
write!(out, "{}:", hyperlink).unwrap(); write!(out, "{hyperlink}:").unwrap();
} else { } else {
write!(out, "{}:", path_data.p_buf.display()).unwrap(); write!(out, "{}:", path_data.p_buf.display()).unwrap();
} }
@ -2091,7 +2091,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
// color is given // color is given
if style_manager.get_normal_style().is_some() { if style_manager.get_normal_style().is_some() {
let to_write = style_manager.reset(true); let to_write = style_manager.reset(true);
write!(out, "{}", to_write)?; write!(out, "{to_write}")?;
} }
} }
@ -2574,7 +2574,7 @@ fn display_items(
Format::Commas => { Format::Commas => {
let mut current_col = 0; let mut current_col = 0;
if let Some(name) = names.next() { if let Some(name) = names.next() {
write!(out, "{}", name)?; write!(out, "{name}")?;
current_col = ansi_width(&name) as u16 + 2; current_col = ansi_width(&name) as u16 + 2;
} }
for name in names { for name in names {
@ -2582,10 +2582,10 @@ fn display_items(
// If the width is 0 we print one single line // If the width is 0 we print one single line
if config.width != 0 && current_col + name_width + 1 > config.width { if config.width != 0 && current_col + name_width + 1 > config.width {
current_col = name_width + 2; current_col = name_width + 2;
write!(out, ",\n{}", name)?; write!(out, ",\n{name}")?;
} else { } else {
current_col += name_width + 2; current_col += name_width + 2;
write!(out, ", {}", name)?; write!(out, ", {name}")?;
} }
} }
// Current col is never zero again if names have been printed. // Current col is never zero again if names have been printed.
@ -2855,7 +2855,7 @@ fn display_item_long(
); );
let displayed_item = if quoted && !item_name.starts_with('\'') { let displayed_item = if quoted && !item_name.starts_with('\'') {
format!(" {}", item_name) format!(" {item_name}")
} else { } else {
item_name item_name
}; };
@ -2969,7 +2969,7 @@ fn display_item_long(
} }
write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap(); write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap();
} }
write!(out, "{}", output_display)?; write!(out, "{output_display}")?;
Ok(()) Ok(())
} }

6
src/uu/numfmt/src/numfmt.rs
View file

@ -67,7 +67,7 @@ fn format_and_handle_validation(input_line: &str, options: &NumfmtOptions) -> UR
} }
InvalidModes::Ignore => {} InvalidModes::Ignore => {}
}; };
println!("{}", input_line); println!("{input_line}");
} }
Ok(()) Ok(())
@ -428,8 +428,8 @@ mod tests {
options.header = 0; options.header = 0;
let result = handle_buffer(BufReader::new(mock_buffer), &options) let result = handle_buffer(BufReader::new(mock_buffer), &options)
.expect_err("returned Ok after receiving IO error"); .expect_err("returned Ok after receiving IO error");
let result_debug = format!("{:?}", result); let result_debug = format!("{result:?}");
let result_display = format!("{}", result); let result_display = format!("{result}");
assert_eq!(result_debug, "IoError(\"broken pipe\")"); assert_eq!(result_debug, "IoError(\"broken pipe\")");
assert_eq!(result_display, "broken pipe"); assert_eq!(result_display, "broken pipe");
assert_eq!(result.code(), 1); assert_eq!(result.code(), 1);

4
src/uu/od/src/inputdecoder.rs
View file

@ -179,8 +179,8 @@ mod tests {
assert_eq!(-2.0, mem.read_float(0, 8)); assert_eq!(-2.0, mem.read_float(0, 8));
assert_eq!(-2.0, mem.read_float(4, 4)); assert_eq!(-2.0, mem.read_float(4, 4));
assert_eq!(0xc000000000000000, mem.read_uint(0, 8)); assert_eq!(0xc000_0000_0000_0000, mem.read_uint(0, 8));
assert_eq!(0xc0000000, mem.read_uint(4, 4)); assert_eq!(0xc000_0000, mem.read_uint(4, 4));
assert_eq!(0xc000, mem.read_uint(6, 2)); assert_eq!(0xc000, mem.read_uint(6, 2));
assert_eq!(0xc0, mem.read_uint(7, 1)); assert_eq!(0xc0, mem.read_uint(7, 1));
assert_eq!(&[0, 0xc0], mem.get_buffer(6)); assert_eq!(&[0, 0xc0], mem.get_buffer(6));

85
src/uu/od/src/prn_float.rs
View file

@ -94,72 +94,72 @@ fn format_float(f: f64, width: usize, precision: usize) -> String {
#[allow(clippy::cognitive_complexity)] #[allow(clippy::cognitive_complexity)]
fn test_format_flo32() { fn test_format_flo32() {
assert_eq!(format_flo32(1.0), " 1.0000000"); assert_eq!(format_flo32(1.0), " 1.0000000");
assert_eq!(format_flo32(9.9999990), " 9.9999990"); assert_eq!(format_flo32(9.999_999_0), " 9.9999990");
assert_eq!(format_flo32(10.0), " 10.000000"); assert_eq!(format_flo32(10.0), " 10.000000");
assert_eq!(format_flo32(99.999977), " 99.999977"); assert_eq!(format_flo32(99.999_977), " 99.999977");
assert_eq!(format_flo32(99.999992), " 99.999992"); assert_eq!(format_flo32(99.999_992), " 99.999992");
assert_eq!(format_flo32(100.0), " 100.00000"); assert_eq!(format_flo32(100.0), " 100.00000");
assert_eq!(format_flo32(999.99994), " 999.99994"); assert_eq!(format_flo32(999.99994), " 999.99994");
assert_eq!(format_flo32(1000.0), " 1000.0000"); assert_eq!(format_flo32(1000.0), " 1000.0000");
assert_eq!(format_flo32(9999.9990), " 9999.9990"); assert_eq!(format_flo32(9999.9990), " 9999.9990");
assert_eq!(format_flo32(10000.0), " 10000.000"); assert_eq!(format_flo32(10000.0), " 10000.000");
assert_eq!(format_flo32(99999.992), " 99999.992"); assert_eq!(format_flo32(99999.992), " 99999.992");
assert_eq!(format_flo32(100000.0), " 100000.00"); assert_eq!(format_flo32(100_000.0), " 100000.00");
assert_eq!(format_flo32(999999.94), " 999999.94"); assert_eq!(format_flo32(999_999.94), " 999999.94");
assert_eq!(format_flo32(1000000.0), " 1000000.0"); assert_eq!(format_flo32(1_000_000.0), " 1000000.0");
assert_eq!(format_flo32(9999999.0), " 9999999.0"); assert_eq!(format_flo32(9_999_999.0), " 9999999.0");
assert_eq!(format_flo32(10000000.0), " 10000000"); assert_eq!(format_flo32(10_000_000.0), " 10000000");
assert_eq!(format_flo32(99999992.0), " 99999992"); assert_eq!(format_flo32(99_999_992.0), " 99999992");
assert_eq!(format_flo32(100000000.0), " 1.0000000e8"); assert_eq!(format_flo32(100_000_000.0), " 1.0000000e8");
assert_eq!(format_flo32(9.9999994e8), " 9.9999994e8"); assert_eq!(format_flo32(9.999_999_4e8), " 9.9999994e8");
assert_eq!(format_flo32(1.0e9), " 1.0000000e9"); assert_eq!(format_flo32(1.0e9), " 1.0000000e9");
assert_eq!(format_flo32(9.9999990e9), " 9.9999990e9"); assert_eq!(format_flo32(9.999_999_0e9), " 9.9999990e9");
assert_eq!(format_flo32(1.0e10), " 1.0000000e10"); assert_eq!(format_flo32(1.0e10), " 1.0000000e10");
assert_eq!(format_flo32(0.1), " 0.10000000"); assert_eq!(format_flo32(0.1), " 0.10000000");
assert_eq!(format_flo32(0.99999994), " 0.99999994"); assert_eq!(format_flo32(0.999_999_94), " 0.99999994");
assert_eq!(format_flo32(0.010000001), " 1.0000001e-2"); assert_eq!(format_flo32(0.010_000_001), " 1.0000001e-2");
assert_eq!(format_flo32(0.099999994), " 9.9999994e-2"); assert_eq!(format_flo32(0.099_999_994), " 9.9999994e-2");
assert_eq!(format_flo32(0.001), " 1.0000000e-3"); assert_eq!(format_flo32(0.001), " 1.0000000e-3");
assert_eq!(format_flo32(0.0099999998), " 9.9999998e-3"); assert_eq!(format_flo32(0.009_999_999_8), " 9.9999998e-3");
assert_eq!(format_flo32(-1.0), " -1.0000000"); assert_eq!(format_flo32(-1.0), " -1.0000000");
assert_eq!(format_flo32(-9.9999990), " -9.9999990"); assert_eq!(format_flo32(-9.999_999_0), " -9.9999990");
assert_eq!(format_flo32(-10.0), " -10.000000"); assert_eq!(format_flo32(-10.0), " -10.000000");
assert_eq!(format_flo32(-99.999977), " -99.999977"); assert_eq!(format_flo32(-99.999_977), " -99.999977");
assert_eq!(format_flo32(-99.999992), " -99.999992"); assert_eq!(format_flo32(-99.999_992), " -99.999992");
assert_eq!(format_flo32(-100.0), " -100.00000"); assert_eq!(format_flo32(-100.0), " -100.00000");
assert_eq!(format_flo32(-999.99994), " -999.99994"); assert_eq!(format_flo32(-999.99994), " -999.99994");
assert_eq!(format_flo32(-1000.0), " -1000.0000"); assert_eq!(format_flo32(-1000.0), " -1000.0000");
assert_eq!(format_flo32(-9999.9990), " -9999.9990"); assert_eq!(format_flo32(-9999.9990), " -9999.9990");
assert_eq!(format_flo32(-10000.0), " -10000.000"); assert_eq!(format_flo32(-10000.0), " -10000.000");
assert_eq!(format_flo32(-99999.992), " -99999.992"); assert_eq!(format_flo32(-99999.992), " -99999.992");
assert_eq!(format_flo32(-100000.0), " -100000.00"); assert_eq!(format_flo32(-100_000.0), " -100000.00");
assert_eq!(format_flo32(-999999.94), " -999999.94"); assert_eq!(format_flo32(-999_999.94), " -999999.94");
assert_eq!(format_flo32(-1000000.0), " -1000000.0"); assert_eq!(format_flo32(-1_000_000.0), " -1000000.0");
assert_eq!(format_flo32(-9999999.0), " -9999999.0"); assert_eq!(format_flo32(-9_999_999.0), " -9999999.0");
assert_eq!(format_flo32(-10000000.0), " -10000000"); assert_eq!(format_flo32(-10_000_000.0), " -10000000");
assert_eq!(format_flo32(-99999992.0), " -99999992"); assert_eq!(format_flo32(-99_999_992.0), " -99999992");
assert_eq!(format_flo32(-100000000.0), " -1.0000000e8"); assert_eq!(format_flo32(-100_000_000.0), " -1.0000000e8");
assert_eq!(format_flo32(-9.9999994e8), " -9.9999994e8"); assert_eq!(format_flo32(-9.999_999_4e8), " -9.9999994e8");
assert_eq!(format_flo32(-1.0e9), " -1.0000000e9"); assert_eq!(format_flo32(-1.0e9), " -1.0000000e9");
assert_eq!(format_flo32(-9.9999990e9), " -9.9999990e9"); assert_eq!(format_flo32(-9.999_999_0e9), " -9.9999990e9");
assert_eq!(format_flo32(-1.0e10), " -1.0000000e10"); assert_eq!(format_flo32(-1.0e10), " -1.0000000e10");
assert_eq!(format_flo32(-0.1), " -0.10000000"); assert_eq!(format_flo32(-0.1), " -0.10000000");
assert_eq!(format_flo32(-0.99999994), " -0.99999994"); assert_eq!(format_flo32(-0.999_999_94), " -0.99999994");
assert_eq!(format_flo32(-0.010000001), " -1.0000001e-2"); assert_eq!(format_flo32(-0.010_000_001), " -1.0000001e-2");
assert_eq!(format_flo32(-0.099999994), " -9.9999994e-2"); assert_eq!(format_flo32(-0.099_999_994), " -9.9999994e-2");
assert_eq!(format_flo32(-0.001), " -1.0000000e-3"); assert_eq!(format_flo32(-0.001), " -1.0000000e-3");
assert_eq!(format_flo32(-0.0099999998), " -9.9999998e-3"); assert_eq!(format_flo32(-0.009_999_999_8), " -9.9999998e-3");
assert_eq!(format_flo32(3.4028233e38), " 3.4028233e38"); assert_eq!(format_flo32(3.402_823_3e38), " 3.4028233e38");
assert_eq!(format_flo32(-3.4028233e38), " -3.4028233e38"); assert_eq!(format_flo32(-3.402_823_3e38), " -3.4028233e38");
assert_eq!(format_flo32(-1.1663108e-38), "-1.1663108e-38"); assert_eq!(format_flo32(-1.166_310_8e-38), "-1.1663108e-38");
assert_eq!(format_flo32(-4.7019771e-38), "-4.7019771e-38"); assert_eq!(format_flo32(-4.701_977_1e-38), "-4.7019771e-38");
assert_eq!(format_flo32(1e-45), " 1e-45"); assert_eq!(format_flo32(1e-45), " 1e-45");
assert_eq!(format_flo32(-3.402823466e+38), " -3.4028235e38"); assert_eq!(format_flo32(-3.402_823_466e+38), " -3.4028235e38");
assert_eq!(format_flo32(f32::NAN), " NaN"); assert_eq!(format_flo32(f32::NAN), " NaN");
assert_eq!(format_flo32(f32::INFINITY), " inf"); assert_eq!(format_flo32(f32::INFINITY), " inf");
assert_eq!(format_flo32(f32::NEG_INFINITY), " -inf"); assert_eq!(format_flo32(f32::NEG_INFINITY), " -inf");
@ -172,13 +172,16 @@ fn test_format_flo32() {
fn test_format_flo64() { fn test_format_flo64() {
assert_eq!(format_flo64(1.0), " 1.0000000000000000"); assert_eq!(format_flo64(1.0), " 1.0000000000000000");
assert_eq!(format_flo64(10.0), " 10.000000000000000"); assert_eq!(format_flo64(10.0), " 10.000000000000000");
assert_eq!(format_flo64(1000000000000000.0), " 1000000000000000.0");
assert_eq!( assert_eq!(
format_flo64(10000000000000000.0), format_flo64(1_000_000_000_000_000.0),
" 1000000000000000.0"
);
assert_eq!(
format_flo64(10_000_000_000_000_000.0),
" 10000000000000000" " 10000000000000000"
); );
assert_eq!( assert_eq!(
format_flo64(100000000000000000.0), format_flo64(100_000_000_000_000_000.0),
" 1.0000000000000000e17" " 1.0000000000000000e17"
); );
@ -186,7 +189,7 @@ fn test_format_flo64() {
assert_eq!(format_flo64(-0.01), " -1.0000000000000000e-2"); assert_eq!(format_flo64(-0.01), " -1.0000000000000000e-2");
assert_eq!( assert_eq!(
format_flo64(-2.2250738585072014e-308), format_flo64(-2.225_073_858_507_201_4e-308),
"-2.2250738585072014e-308" "-2.2250738585072014e-308"
); );
assert_eq!(format_flo64(4e-320), " 4e-320"); assert_eq!(format_flo64(4e-320), " 4e-320");

5
src/uu/paste/src/paste.rs
View file

@ -111,10 +111,7 @@ fn paste(
if delimiters.ends_with('\\') && !delimiters.ends_with("\\\\") { if delimiters.ends_with('\\') && !delimiters.ends_with("\\\\") {
return Err(USimpleError::new( return Err(USimpleError::new(
1, 1,
format!( format!("delimiter list ends with an unescaped backslash: {delimiters}"),
"delimiter list ends with an unescaped backslash: {}",
delimiters
),
)); ));
} }

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

@ -129,7 +129,7 @@ impl WordFilter {
HashSet::new() // really only chars found in file HashSet::new() // really only chars found in file
} else { } else {
// GNU off means at least these are considered // GNU off means at least these are considered
[' ', '\t', '\n'].iter().cloned().collect() [' ', '\t', '\n'].iter().copied().collect()
}; };
hs.extend(chars); hs.extend(chars);
Some(hs) Some(hs)

2
src/uu/split/src/platform/unix.rs
View file

@ -104,7 +104,7 @@ impl Drop for FilterWriter {
if return_code != 0 { if return_code != 0 {
show!(USimpleError::new( show!(USimpleError::new(
1, 1,
format!("Shell process returned {}", return_code) format!("Shell process returned {return_code}")
)); ));
} }
} else { } else {

4
src/uu/split/src/split.rs
View file

@ -658,7 +658,7 @@ where
// Most likely continuous/infinite input stream // Most likely continuous/infinite input stream
return Err(io::Error::new( return Err(io::Error::new(
ErrorKind::Other, ErrorKind::Other,
format!("{}: cannot determine input size", input), format!("{input}: cannot determine input size"),
)); ));
} else { } else {
// Could be that file size is larger than set read limit // Could be that file size is larger than set read limit
@ -684,7 +684,7 @@ where
// to address all possible file types and edge cases // to address all possible file types and edge cases
return Err(io::Error::new( return Err(io::Error::new(
ErrorKind::Other, ErrorKind::Other,
format!("{}: cannot determine file size", input), format!("{input}: cannot determine file size"),
)); ));
} }
} }

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

@ -586,7 +586,7 @@ impl Stater {
let mut mount_list = read_fs_list() let mut mount_list = read_fs_list()
.map_err(|e| { .map_err(|e| {
let context = "cannot read table of mounted file systems"; let context = "cannot read table of mounted file systems";
USimpleError::new(e.code(), format!("{}: {}", context, e)) USimpleError::new(e.code(), format!("{context}: {e}"))
})? })?
.iter() .iter()
.map(|mi| mi.mount_dir.clone()) .map(|mi| mi.mount_dir.clone())

2
src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
View file

@ -40,7 +40,7 @@ fn set_buffer(stream: *mut FILE, value: &str) {
let buff_size: usize = match input.parse() { let buff_size: usize = match input.parse() {
Ok(num) => num, Ok(num) => num,
Err(_) => { Err(_) => {
eprintln!("failed to allocate a {} byte stdio buffer", value); eprintln!("failed to allocate a {value} byte stdio buffer");
std::process::exit(1); std::process::exit(1);
} }
}; };

14
src/uu/touch/src/error.rs
View file

@ -39,12 +39,10 @@ impl UError for TouchError {}
impl Display for TouchError { impl Display for TouchError {
fn fmt(&self, f: &mut Formatter) -> Result { fn fmt(&self, f: &mut Formatter) -> Result {
match self { match self {
Self::InvalidDateFormat(s) => write!(f, "Unable to parse date: {}", s), Self::InvalidDateFormat(s) => write!(f, "Unable to parse date: {s}"),
Self::InvalidFiletime(time) => write!( Self::InvalidFiletime(time) => {
f, write!(f, "Source has invalid access or modification time: {time}",)
"Source has invalid access or modification time: {}", }
time,
),
Self::ReferenceFileInaccessible(path, err) => { Self::ReferenceFileInaccessible(path, err) => {
write!( write!(
f, f,
@ -54,9 +52,9 @@ impl Display for TouchError {
) )
} }
Self::WindowsStdoutPathError(code) => { Self::WindowsStdoutPathError(code) => {
write!(f, "GetFinalPathNameByHandleW failed with code {}", code) write!(f, "GetFinalPathNameByHandleW failed with code {code}")
} }
Self::TouchFileError { error, .. } => write!(f, "{}", error), Self::TouchFileError { error, .. } => write!(f, "{error}"),
} }
} }
} }

6
src/uu/touch/src/touch.rs
View file

@ -585,8 +585,8 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
15 => (YYYYMMDDHHMM_DOT_SS, s.to_owned()), 15 => (YYYYMMDDHHMM_DOT_SS, s.to_owned()),
12 => (YYYYMMDDHHMM, s.to_owned()), 12 => (YYYYMMDDHHMM, s.to_owned()),
// If we don't add "20", we have insufficient information to parse // If we don't add "20", we have insufficient information to parse
13 => (YYYYMMDDHHMM_DOT_SS, format!("20{}", s)), 13 => (YYYYMMDDHHMM_DOT_SS, format!("20{s}")),
10 => (YYYYMMDDHHMM, format!("20{}", s)), 10 => (YYYYMMDDHHMM, format!("20{s}")),
11 => (YYYYMMDDHHMM_DOT_SS, format!("{}{}", current_year(), s)), 11 => (YYYYMMDDHHMM_DOT_SS, format!("{}{}", current_year(), s)),
8 => (YYYYMMDDHHMM, format!("{}{}", current_year(), s)), 8 => (YYYYMMDDHHMM, format!("{}{}", current_year(), s)),
_ => { _ => {
@ -766,7 +766,7 @@ mod tests {
}, },
) { ) {
Err(TouchError::InvalidFiletime(filetime)) => assert_eq!(filetime, invalid_filetime), Err(TouchError::InvalidFiletime(filetime)) => assert_eq!(filetime, invalid_filetime),
Err(e) => panic!("Expected TouchError::InvalidFiletime, got {}", e), Err(e) => panic!("Expected TouchError::InvalidFiletime, got {e}"),
Ok(_) => panic!("Expected to error with TouchError::InvalidFiletime but succeeded"), Ok(_) => panic!("Expected to error with TouchError::InvalidFiletime but succeeded"),
}; };
} }

4
src/uu/tr/src/operation.rs
View file

@ -112,7 +112,7 @@ impl Sequence {
Self::Class(class) => match class { Self::Class(class) => match class {
Class::Alnum => Box::new((b'0'..=b'9').chain(b'A'..=b'Z').chain(b'a'..=b'z')), Class::Alnum => Box::new((b'0'..=b'9').chain(b'A'..=b'Z').chain(b'a'..=b'z')),
Class::Alpha => Box::new((b'A'..=b'Z').chain(b'a'..=b'z')), Class::Alpha => Box::new((b'A'..=b'Z').chain(b'a'..=b'z')),
Class::Blank => Box::new(unicode_table::BLANK.iter().cloned()), Class::Blank => Box::new(unicode_table::BLANK.iter().copied()),
Class::Control => Box::new((0..=31).chain(std::iter::once(127))), Class::Control => Box::new((0..=31).chain(std::iter::once(127))),
Class::Digit => Box::new(b'0'..=b'9'), Class::Digit => Box::new(b'0'..=b'9'),
Class::Graph => Box::new( Class::Graph => Box::new(
@ -137,7 +137,7 @@ impl Sequence {
.chain(123..=126), .chain(123..=126),
), ),
Class::Punct => Box::new((33..=47).chain(58..=64).chain(91..=96).chain(123..=126)), Class::Punct => Box::new((33..=47).chain(58..=64).chain(91..=96).chain(123..=126)),
Class::Space => Box::new(unicode_table::SPACES.iter().cloned()), Class::Space => Box::new(unicode_table::SPACES.iter().copied()),
Class::Xdigit => Box::new((b'0'..=b'9').chain(b'A'..=b'F').chain(b'a'..=b'f')), Class::Xdigit => Box::new((b'0'..=b'9').chain(b'A'..=b'F').chain(b'a'..=b'f')),
Class::Lower => Box::new(b'a'..=b'z'), Class::Lower => Box::new(b'a'..=b'z'),
Class::Upper => Box::new(b'A'..=b'Z'), Class::Upper => Box::new(b'A'..=b'Z'),

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

@ -82,17 +82,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let op = sets[1].quote(); let op = sets[1].quote();
let msg = if sets_len == 2 { let msg = if sets_len == 2 {
format!( format!(
"{} {}\nOnly one string may be given when deleting without squeezing repeats.", "{start} {op}\nOnly one string may be given when deleting without squeezing repeats.",
start, op,
) )
} else { } else {
format!("{} {}", start, op,) format!("{start} {op}",)
}; };
return Err(UUsageError::new(1, msg)); return Err(UUsageError::new(1, msg));
} }
if sets_len > 2 { if sets_len > 2 {
let op = sets[2].quote(); let op = sets[2].quote();
let msg = format!("{} {}", start, op); let msg = format!("{start} {op}");
return Err(UUsageError::new(1, msg)); return Err(UUsageError::new(1, msg));
} }
} }

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

@ -36,7 +36,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if path.is_dir() { if path.is_dir() {
return Err(USimpleError::new( return Err(USimpleError::new(
1, 1,
format!("{}: read error: Is a directory", input), format!("{input}: read error: Is a directory"),
)); ));
} }
file_buf = File::open(path).map_err_context(|| input.to_string())?; file_buf = File::open(path).map_err_context(|| input.to_string())?;

3
src/uu/users/src/users.rs
View file

@ -33,8 +33,7 @@ fn get_long_usage() -> String {
let default_path: &str = OPENBSD_UTMP_FILE; let default_path: &str = OPENBSD_UTMP_FILE;
format!( format!(
"Output who is currently logged in according to FILE. "Output who is currently logged in according to FILE.
If FILE is not specified, use {}. /var/log/wtmp as FILE is common.", If FILE is not specified, use {default_path}. /var/log/wtmp as FILE is common."
default_path
) )
} }

15
src/uucore/src/lib/features/checksum.rs
View file

@ -23,6 +23,7 @@ use crate::{
}, },
util_name, util_name,
}; };
use std::fmt::Write;
use std::io::stdin; use std::io::stdin;
use std::io::BufRead; use std::io::BufRead;
use thiserror::Error; use thiserror::Error;
@ -323,9 +324,10 @@ fn determine_regex(lines: &[String]) -> Option<(Regex, bool)> {
fn bytes_to_hex(bytes: &[u8]) -> String { fn bytes_to_hex(bytes: &[u8]) -> String {
bytes bytes
.iter() .iter()
.map(|byte| format!("{:02x}", byte)) .fold(String::with_capacity(bytes.len() * 2), |mut hex, byte| {
.collect::<Vec<String>>() write!(hex, "{byte:02x}").unwrap();
.join("") hex
})
} }
fn get_expected_checksum( fn get_expected_checksum(
@ -365,10 +367,7 @@ fn get_file_to_check(
match File::open(filename) { match File::open(filename) {
Ok(f) => { Ok(f) => {
if f.metadata().ok()?.is_dir() { if f.metadata().ok()?.is_dir() {
show!(USimpleError::new( show!(USimpleError::new(1, format!("{filename}: Is a directory")));
1,
format!("{}: Is a directory", filename)
));
None None
} else { } else {
Some(Box::new(f)) Some(Box::new(f))
@ -378,7 +377,7 @@ fn get_file_to_check(
if !ignore_missing { if !ignore_missing {
// yes, we have both stderr and stdout here // yes, we have both stderr and stdout here
show!(err.map_err_context(|| filename.to_string())); show!(err.map_err_context(|| filename.to_string()));
println!("{}: FAILED open or read", filename); println!("{filename}: FAILED open or read");
} }
res.failed_open_file += 1; res.failed_open_file += 1;
// we could not open the file but we want to continue // we could not open the file but we want to continue

2
src/uucore/src/lib/features/format/human.rs
View file

@ -54,7 +54,7 @@ pub fn human_readable(size: u64, sfmt: SizeFormat) -> String {
#[test] #[test]
fn test_human_readable() { fn test_human_readable() {
let test_cases = [ let test_cases = [
(133456345, SizeFormat::Binary, "128M"), (133_456_345, SizeFormat::Binary, "128M"),
(12 * 1024 * 1024, SizeFormat::Binary, "12M"), (12 * 1024 * 1024, SizeFormat::Binary, "12M"),
(8500, SizeFormat::Binary, "8.4K"), (8500, SizeFormat::Binary, "8.4K"),
]; ];

99
src/uucore/src/lib/features/format/num_format.rs
View file

@ -204,9 +204,9 @@ impl Formatter for UnsignedInt {
}; };
Ok(Self { Ok(Self {
variant,
width, width,
precision, precision,
variant,
alignment, alignment,
}) })
} }
@ -340,7 +340,7 @@ fn format_float_decimal(f: f64, precision: usize, force_decimal: ForceDecimal) -
if precision == 0 && force_decimal == ForceDecimal::Yes { if precision == 0 && force_decimal == ForceDecimal::Yes {
format!("{f:.0}.") format!("{f:.0}.")
} else { } else {
format!("{f:.*}", precision) format!("{f:.precision$}")
} }
} }
@ -380,10 +380,7 @@ fn format_float_scientific(
Case::Uppercase => 'E', Case::Uppercase => 'E',
}; };
format!( format!("{normalized:.precision$}{additional_dot}{exp_char}{exponent:+03}")
"{normalized:.*}{additional_dot}{exp_char}{exponent:+03}",
precision
)
} }
fn format_float_shortest( fn format_float_shortest(
@ -427,7 +424,7 @@ fn format_float_shortest(
"" ""
}; };
let mut normalized = format!("{normalized:.*}", precision); let mut normalized = format!("{normalized:.precision$}");
if force_decimal == ForceDecimal::No { if force_decimal == ForceDecimal::No {
strip_fractional_zeroes_and_dot(&mut normalized); strip_fractional_zeroes_and_dot(&mut normalized);
@ -449,7 +446,7 @@ fn format_float_shortest(
let mut formatted = if decimal_places == 0 && force_decimal == ForceDecimal::Yes { let mut formatted = if decimal_places == 0 && force_decimal == ForceDecimal::Yes {
format!("{f:.0}.") format!("{f:.0}.")
} else { } else {
format!("{f:.*}", decimal_places) format!("{f:.decimal_places$}")
}; };
if force_decimal == ForceDecimal::No { if force_decimal == ForceDecimal::No {
@ -514,11 +511,7 @@ fn write_output(
// Using min() because self.width could be 0, 0usize - 1usize should be avoided // Using min() because self.width could be 0, 0usize - 1usize should be avoided
let remaining_width = width - min(width, sign_indicator.len()); let remaining_width = width - min(width, sign_indicator.len());
match alignment { match alignment {
NumberAlignment::Left => write!( NumberAlignment::Left => write!(writer, "{sign_indicator}{s:<remaining_width$}"),
writer,
"{sign_indicator}{s:<width$}",
width = remaining_width
),
NumberAlignment::RightSpace => { NumberAlignment::RightSpace => {
let is_sign = sign_indicator.starts_with('-') || sign_indicator.starts_with('+'); // When sign_indicator is in ['-', '+'] let is_sign = sign_indicator.starts_with('-') || sign_indicator.starts_with('+'); // When sign_indicator is in ['-', '+']
if is_sign && remaining_width > 0 { if is_sign && remaining_width > 0 {
@ -526,19 +519,11 @@ fn write_output(
s = sign_indicator + s.as_str(); s = sign_indicator + s.as_str();
write!(writer, "{s:>width$}", width = remaining_width + 1) // Since we now add sign_indicator and s together, plus 1 write!(writer, "{s:>width$}", width = remaining_width + 1) // Since we now add sign_indicator and s together, plus 1
} else { } else {
write!( write!(writer, "{sign_indicator}{s:>remaining_width$}")
writer,
"{sign_indicator}{s:>width$}",
width = remaining_width
)
} }
} }
NumberAlignment::RightZero => { NumberAlignment::RightZero => {
write!( write!(writer, "{sign_indicator}{s:0>remaining_width$}")
writer,
"{sign_indicator}{s:0>width$}",
width = remaining_width
)
} }
} }
} }
@ -575,12 +560,12 @@ mod test {
assert_eq!(f(0.0), "0.000000"); assert_eq!(f(0.0), "0.000000");
assert_eq!(f(1.0), "1.000000"); assert_eq!(f(1.0), "1.000000");
assert_eq!(f(100.0), "100.000000"); assert_eq!(f(100.0), "100.000000");
assert_eq!(f(123456.789), "123456.789000"); assert_eq!(f(123_456.789), "123456.789000");
assert_eq!(f(12.3456789), "12.345679"); assert_eq!(f(12.345_678_9), "12.345679");
assert_eq!(f(1000000.0), "1000000.000000"); assert_eq!(f(1_000_000.0), "1000000.000000");
assert_eq!(f(99999999.0), "99999999.000000"); assert_eq!(f(99_999_999.0), "99999999.000000");
assert_eq!(f(1.9999995), "1.999999"); assert_eq!(f(1.999_999_5), "1.999999");
assert_eq!(f(1.9999996), "2.000000"); assert_eq!(f(1.999_999_6), "2.000000");
} }
#[test] #[test]
@ -590,10 +575,10 @@ mod test {
assert_eq!(f(0.0), "0.000000e+00"); assert_eq!(f(0.0), "0.000000e+00");
assert_eq!(f(1.0), "1.000000e+00"); assert_eq!(f(1.0), "1.000000e+00");
assert_eq!(f(100.0), "1.000000e+02"); assert_eq!(f(100.0), "1.000000e+02");
assert_eq!(f(123456.789), "1.234568e+05"); assert_eq!(f(123_456.789), "1.234568e+05");
assert_eq!(f(12.3456789), "1.234568e+01"); assert_eq!(f(12.345_678_9), "1.234568e+01");
assert_eq!(f(1000000.0), "1.000000e+06"); assert_eq!(f(1_000_000.0), "1.000000e+06");
assert_eq!(f(99999999.0), "1.000000e+08"); assert_eq!(f(99_999_999.0), "1.000000e+08");
} }
#[test] #[test]
@ -604,19 +589,19 @@ mod test {
assert_eq!(f(0.0), "0e+00"); assert_eq!(f(0.0), "0e+00");
assert_eq!(f(1.0), "1e+00"); assert_eq!(f(1.0), "1e+00");
assert_eq!(f(100.0), "1e+02"); assert_eq!(f(100.0), "1e+02");
assert_eq!(f(123456.789), "1e+05"); assert_eq!(f(123_456.789), "1e+05");
assert_eq!(f(12.3456789), "1e+01"); assert_eq!(f(12.345_678_9), "1e+01");
assert_eq!(f(1000000.0), "1e+06"); assert_eq!(f(1_000_000.0), "1e+06");
assert_eq!(f(99999999.0), "1e+08"); assert_eq!(f(99_999_999.0), "1e+08");
let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::Yes); let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::Yes);
assert_eq!(f(0.0), "0.e+00"); assert_eq!(f(0.0), "0.e+00");
assert_eq!(f(1.0), "1.e+00"); assert_eq!(f(1.0), "1.e+00");
assert_eq!(f(100.0), "1.e+02"); assert_eq!(f(100.0), "1.e+02");
assert_eq!(f(123456.789), "1.e+05"); assert_eq!(f(123_456.789), "1.e+05");
assert_eq!(f(12.3456789), "1.e+01"); assert_eq!(f(12.345_678_9), "1.e+01");
assert_eq!(f(1000000.0), "1.e+06"); assert_eq!(f(1_000_000.0), "1.e+06");
assert_eq!(f(99999999.0), "1.e+08"); assert_eq!(f(99_999_999.0), "1.e+08");
} }
#[test] #[test]
@ -626,10 +611,10 @@ mod test {
assert_eq!(f(0.0), "0"); assert_eq!(f(0.0), "0");
assert_eq!(f(1.0), "1"); assert_eq!(f(1.0), "1");
assert_eq!(f(100.0), "100"); assert_eq!(f(100.0), "100");
assert_eq!(f(123456.789), "123457"); assert_eq!(f(123_456.789), "123457");
assert_eq!(f(12.3456789), "12.3457"); assert_eq!(f(12.345_678_9), "12.3457");
assert_eq!(f(1000000.0), "1e+06"); assert_eq!(f(1_000_000.0), "1e+06");
assert_eq!(f(99999999.0), "1e+08"); assert_eq!(f(99_999_999.0), "1e+08");
} }
#[test] #[test]
@ -639,10 +624,10 @@ mod test {
assert_eq!(f(0.0), "0.00000"); assert_eq!(f(0.0), "0.00000");
assert_eq!(f(1.0), "1.00000"); assert_eq!(f(1.0), "1.00000");
assert_eq!(f(100.0), "100.000"); assert_eq!(f(100.0), "100.000");
assert_eq!(f(123456.789), "123457."); assert_eq!(f(123_456.789), "123457.");
assert_eq!(f(12.3456789), "12.3457"); assert_eq!(f(12.345_678_9), "12.3457");
assert_eq!(f(1000000.0), "1.00000e+06"); assert_eq!(f(1_000_000.0), "1.00000e+06");
assert_eq!(f(99999999.0), "1.00000e+08"); assert_eq!(f(99_999_999.0), "1.00000e+08");
} }
#[test] #[test]
@ -652,19 +637,19 @@ mod test {
assert_eq!(f(0.0), "0"); assert_eq!(f(0.0), "0");
assert_eq!(f(1.0), "1"); assert_eq!(f(1.0), "1");
assert_eq!(f(100.0), "1e+02"); assert_eq!(f(100.0), "1e+02");
assert_eq!(f(123456.789), "1e+05"); assert_eq!(f(123_456.789), "1e+05");
assert_eq!(f(12.3456789), "1e+01"); assert_eq!(f(12.345_678_9), "1e+01");
assert_eq!(f(1000000.0), "1e+06"); assert_eq!(f(1_000_000.0), "1e+06");
assert_eq!(f(99999999.0), "1e+08"); assert_eq!(f(99_999_999.0), "1e+08");
let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::Yes); let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::Yes);
assert_eq!(f(0.0), "0."); assert_eq!(f(0.0), "0.");
assert_eq!(f(1.0), "1."); assert_eq!(f(1.0), "1.");
assert_eq!(f(100.0), "1.e+02"); assert_eq!(f(100.0), "1.e+02");
assert_eq!(f(123456.789), "1.e+05"); assert_eq!(f(123_456.789), "1.e+05");
assert_eq!(f(12.3456789), "1.e+01"); assert_eq!(f(12.345_678_9), "1.e+01");
assert_eq!(f(1000000.0), "1.e+06"); assert_eq!(f(1_000_000.0), "1.e+06");
assert_eq!(f(99999999.0), "1.e+08"); assert_eq!(f(99_999_999.0), "1.e+08");
} }
#[test] #[test]

2
src/uucore/src/lib/features/format/num_parser.rs
View file

@ -356,7 +356,7 @@ mod tests {
assert_eq!(Ok(0.5), ParsedNumber::parse_f64("0x.8")); assert_eq!(Ok(0.5), ParsedNumber::parse_f64("0x.8"));
assert_eq!(Ok(0.0625), ParsedNumber::parse_f64("0x.1")); assert_eq!(Ok(0.0625), ParsedNumber::parse_f64("0x.1"));
assert_eq!(Ok(15.0078125), ParsedNumber::parse_f64("0xf.02")); assert_eq!(Ok(15.007_812_5), ParsedNumber::parse_f64("0xf.02"));
} }
#[test] #[test]

2
src/uucore/src/lib/features/fs.rs
View file

@ -231,7 +231,7 @@ pub enum ResolveMode {
/// replace this once that lands /// replace this once that lands
pub fn normalize_path(path: &Path) -> PathBuf { pub fn normalize_path(path: &Path) -> PathBuf {
let mut components = path.components().peekable(); let mut components = path.components().peekable();
let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().copied() {
components.next(); components.next();
PathBuf::from(c.as_os_str()) PathBuf::from(c.as_os_str())
} else { } else {

14
src/uucore/src/lib/features/fsext.rs
View file

@ -179,9 +179,9 @@ impl MountInfo {
dev_id, dev_id,
dev_name, dev_name,
fs_type, fs_type,
mount_root,
mount_dir, mount_dir,
mount_option, mount_option,
mount_root,
remote, remote,
dummy, dummy,
}) })
@ -907,7 +907,7 @@ pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
0x0187 => "autofs".into(), 0x0187 => "autofs".into(),
0x4246_5331 => "befs".into(), 0x4246_5331 => "befs".into(),
0x6264_6576 => "bdevfs".into(), 0x6264_6576 => "bdevfs".into(),
0xCA451A4E => "bcachefs".into(), 0xCA45_1A4E => "bcachefs".into(),
0x1BAD_FACE => "bfs".into(), 0x1BAD_FACE => "bfs".into(),
0xCAFE_4A11 => "bpf_fs".into(), 0xCAFE_4A11 => "bpf_fs".into(),
0x4249_4E4D => "binfmt_misc".into(), 0x4249_4E4D => "binfmt_misc".into(),
@ -1037,12 +1037,12 @@ mod tests {
fn test_fs_type() { fn test_fs_type() {
// spell-checker:disable // spell-checker:disable
assert_eq!("ext2/ext3", pretty_fstype(0xEF53)); assert_eq!("ext2/ext3", pretty_fstype(0xEF53));
assert_eq!("tmpfs", pretty_fstype(0x01021994)); assert_eq!("tmpfs", pretty_fstype(0x0102_1994));
assert_eq!("nfs", pretty_fstype(0x6969)); assert_eq!("nfs", pretty_fstype(0x6969));
assert_eq!("btrfs", pretty_fstype(0x9123683e)); assert_eq!("btrfs", pretty_fstype(0x9123_683e));
assert_eq!("xfs", pretty_fstype(0x58465342)); assert_eq!("xfs", pretty_fstype(0x5846_5342));
assert_eq!("zfs", pretty_fstype(0x2FC12FC1)); assert_eq!("zfs", pretty_fstype(0x2FC1_2FC1));
assert_eq!("ntfs", pretty_fstype(0x5346544e)); assert_eq!("ntfs", pretty_fstype(0x5346_544e));
assert_eq!("fat", pretty_fstype(0x4006)); assert_eq!("fat", pretty_fstype(0x4006));
assert_eq!("UNKNOWN (0x1234)", pretty_fstype(0x1234)); assert_eq!("UNKNOWN (0x1234)", pretty_fstype(0x1234));
// spell-checker:enable // spell-checker:enable

4
src/uucore/src/lib/features/perms.rs
View file

@ -220,8 +220,8 @@ fn is_root(path: &Path, would_traverse_symlink: bool) -> bool {
Some(".") | Some("..") => true, Some(".") | Some("..") => true,
Some(path_str) => { Some(path_str) => {
(path_str.ends_with(MAIN_SEPARATOR_STR)) (path_str.ends_with(MAIN_SEPARATOR_STR))
|| (path_str.ends_with(&format!("{}.", MAIN_SEPARATOR_STR))) || (path_str.ends_with(&format!("{MAIN_SEPARATOR_STR}.")))
|| (path_str.ends_with(&format!("{}..", MAIN_SEPARATOR_STR))) || (path_str.ends_with(&format!("{MAIN_SEPARATOR_STR}..")))
} }
}; };
// TODO: Once we reach MSRV 1.74.0, replace this abomination by something simpler, e.g. this: // TODO: Once we reach MSRV 1.74.0, replace this abomination by something simpler, e.g. this:

2
src/uucore/src/lib/features/process.rs
View file

@ -151,6 +151,6 @@ mod tests {
assert!(getsid(getpid()).expect("getsid(getpid)") > 0); assert!(getsid(getpid()).expect("getsid(getpid)") > 0);
// This might caused tests failure but the probability is low. // This might caused tests failure but the probability is low.
assert!(getsid(999999).is_err()); assert!(getsid(999_999).is_err());
} }
} }

10
src/uucore/src/lib/features/quoting_style.rs
View file

@ -801,31 +801,31 @@ mod tests {
always_quote: false, always_quote: false,
show_control: false, show_control: false,
}; };
assert_eq!(format!("{}", style), "shell-escape"); assert_eq!(format!("{style}"), "shell-escape");
let style = QuotingStyle::Shell { let style = QuotingStyle::Shell {
escape: false, escape: false,
always_quote: true, always_quote: true,
show_control: false, show_control: false,
}; };
assert_eq!(format!("{}", style), "shell-always-quote"); assert_eq!(format!("{style}"), "shell-always-quote");
let style = QuotingStyle::Shell { let style = QuotingStyle::Shell {
escape: false, escape: false,
always_quote: false, always_quote: false,
show_control: true, show_control: true,
}; };
assert_eq!(format!("{}", style), "shell-show-control"); assert_eq!(format!("{style}"), "shell-show-control");
let style = QuotingStyle::C { let style = QuotingStyle::C {
quotes: Quotes::Double, quotes: Quotes::Double,
}; };
assert_eq!(format!("{}", style), "C"); assert_eq!(format!("{style}"), "C");
let style = QuotingStyle::Literal { let style = QuotingStyle::Literal {
show_control: false, show_control: false,
}; };
assert_eq!(format!("{}", style), "literal"); assert_eq!(format!("{style}"), "literal");
} }
#[test] #[test]

6
src/uucore/src/lib/mods/posix.rs
View file

@ -21,13 +21,13 @@
use std::env; use std::env;
/// '199209' for POSIX 1003.2-1992, which would define Obsolete mode /// '199209' for POSIX 1003.2-1992, which would define Obsolete mode
pub const OBSOLETE: usize = 199209; pub const OBSOLETE: usize = 199_209;
/// '200112' for POSIX 1003.1-2001, which is the minimum version for Traditional mode /// '200112' for POSIX 1003.1-2001, which is the minimum version for Traditional mode
pub const TRADITIONAL: usize = 200112; pub const TRADITIONAL: usize = 200_112;
/// '200809' for POSIX 1003.1-2008, which is the minimum version for Modern mode /// '200809' for POSIX 1003.1-2008, which is the minimum version for Modern mode
pub const MODERN: usize = 200809; pub const MODERN: usize = 200_809;
/// Returns the value of the `_POSIX2_VERSION` environment variable if it is defined /// Returns the value of the `_POSIX2_VERSION` environment variable if it is defined
pub fn posix_version() -> Option<usize> { pub fn posix_version() -> Option<usize> {

2
src/uucore/src/lib/parser/parse_glob.rs
View file

@ -97,7 +97,7 @@ mod tests {
// test that we don't look for closing square brackets unnecessarily // test that we don't look for closing square brackets unnecessarily
// Verifies issue #5584 // Verifies issue #5584
let chars = "^[".repeat(174571); let chars = "^[".repeat(174_571);
assert_eq!(fix_negation(chars.as_str()), chars); assert_eq!(fix_negation(chars.as_str()), chars);
} }

6
src/uucore/src/lib/parser/shortcut_value_parser.rs
View file

@ -79,8 +79,7 @@ fn add_ambiguous_value_tip(
err.insert( err.insert(
ContextKind::Suggested, ContextKind::Suggested,
ContextValue::StyledStrs(vec![format!( ContextValue::StyledStrs(vec![format!(
"It looks like '{}' could match several values. Did you mean {}?", "It looks like '{value}' could match several values. Did you mean {formatted_possible_values}?"
value, formatted_possible_values
) )
.into()]), .into()]),
); );
@ -175,8 +174,7 @@ mod tests {
let result = parser.parse_ref(&cmd, None, OsStr::new(ambiguous_value)); let result = parser.parse_ref(&cmd, None, OsStr::new(ambiguous_value));
assert_eq!(ErrorKind::InvalidValue, result.as_ref().unwrap_err().kind()); assert_eq!(ErrorKind::InvalidValue, result.as_ref().unwrap_err().kind());
assert!(result.unwrap_err().to_string().contains(&format!( assert!(result.unwrap_err().to_string().contains(&format!(
"It looks like '{}' could match several values. Did you mean 'abcd' or 'abef'?", "It looks like '{ambiguous_value}' could match several values. Did you mean 'abcd' or 'abef'?"
ambiguous_value
))); )));
} }

14
src/uucore_procs/src/lib.rs
View file

@ -67,9 +67,10 @@ pub fn help_about(input: TokenStream) -> TokenStream {
let input: Vec<TokenTree> = input.into_iter().collect(); let input: Vec<TokenTree> = input.into_iter().collect();
let filename = get_argument(&input, 0, "filename"); let filename = get_argument(&input, 0, "filename");
let text: String = uuhelp_parser::parse_about(&read_help(&filename)); let text: String = uuhelp_parser::parse_about(&read_help(&filename));
if text.is_empty() { assert!(
panic!("About text not found! Make sure the markdown format is correct"); !text.is_empty(),
} "About text not found! Make sure the markdown format is correct"
);
TokenTree::Literal(Literal::string(&text)).into() TokenTree::Literal(Literal::string(&text)).into()
} }
@ -84,9 +85,10 @@ pub fn help_usage(input: TokenStream) -> TokenStream {
let input: Vec<TokenTree> = input.into_iter().collect(); let input: Vec<TokenTree> = input.into_iter().collect();
let filename = get_argument(&input, 0, "filename"); let filename = get_argument(&input, 0, "filename");
let text: String = uuhelp_parser::parse_usage(&read_help(&filename)); let text: String = uuhelp_parser::parse_usage(&read_help(&filename));
if text.is_empty() { assert!(
panic!("Usage text not found! Make sure the markdown format is correct"); !text.is_empty(),
} "Usage text not found! Make sure the markdown format is correct"
);
TokenTree::Literal(Literal::string(&text)).into() TokenTree::Literal(Literal::string(&text)).into()
} }

3
src/uuhelp_parser/src/lib.rs
View file

@ -62,8 +62,7 @@ pub fn parse_usage(content: &str) -> String {
"{}\n".to_string() "{}\n".to_string()
} }
}) })
.collect::<Vec<_>>() .collect::<String>()
.join("")
.trim() .trim()
.to_string() .to_string()
} }

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

@ -341,7 +341,7 @@ fn test_cp_arg_update_none_fail() {
.arg(TEST_HOW_ARE_YOU_SOURCE) .arg(TEST_HOW_ARE_YOU_SOURCE)
.arg("--update=none-fail") .arg("--update=none-fail")
.fails() .fails()
.stderr_contains(format!("not replacing '{}'", TEST_HOW_ARE_YOU_SOURCE)); .stderr_contains(format!("not replacing '{TEST_HOW_ARE_YOU_SOURCE}'"));
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n"); assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
} }
@ -3897,7 +3897,7 @@ fn test_acl_preserve() {
return; return;
} }
Err(e) => { Err(e) => {
println!("test skipped: setfacl failed with {}", e); println!("test skipped: setfacl failed with {e}");
return; return;
} }
} }
@ -5581,7 +5581,7 @@ fn test_dir_perm_race_with_preserve_mode_and_ownership() {
let child = scene let child = scene
.ucmd() .ucmd()
.args(&[ .args(&[
format!("--preserve={}", attr).as_str(), format!("--preserve={attr}").as_str(),
"-R", "-R",
"--copy-contents", "--copy-contents",
"--parents", "--parents",
@ -5600,12 +5600,12 @@ fn test_dir_perm_race_with_preserve_mode_and_ownership() {
start_time.elapsed() < timeout, start_time.elapsed() < timeout,
"timed out: cp took too long to create destination directory" "timed out: cp took too long to create destination directory"
); );
if at.dir_exists(&format!("{}/{}", DEST_DIR, SRC_DIR)) { if at.dir_exists(&format!("{DEST_DIR}/{SRC_DIR}")) {
break; break;
} }
std::thread::sleep(Duration::from_millis(100)); std::thread::sleep(Duration::from_millis(100));
} }
let mode = at.metadata(&format!("{}/{}", DEST_DIR, SRC_DIR)).mode(); let mode = at.metadata(&format!("{DEST_DIR}/{SRC_DIR}")).mode();
#[allow(clippy::unnecessary_cast, clippy::cast_lossless)] #[allow(clippy::unnecessary_cast, clippy::cast_lossless)]
let mask = if attr == "mode" { let mask = if attr == "mode" {
libc::S_IWGRP | libc::S_IWOTH libc::S_IWGRP | libc::S_IWOTH
@ -5615,8 +5615,7 @@ fn test_dir_perm_race_with_preserve_mode_and_ownership() {
assert_eq!( assert_eq!(
(mode & mask), (mode & mask),
0, 0,
"unwanted permissions are present - {}", "unwanted permissions are present - {attr}"
attr
); );
at.write(FIFO, "done"); at.write(FIFO, "done");
child.wait().unwrap().succeeded(); child.wait().unwrap().succeeded();
@ -5673,18 +5672,15 @@ fn test_preserve_attrs_overriding_2() {
let scene = TestScenario::new(util_name!()); let scene = TestScenario::new(util_name!());
let at = &scene.fixtures; let at = &scene.fixtures;
at.mkdir(FOLDER); at.mkdir(FOLDER);
at.make_file(&format!("{}/{}", FOLDER, FILE1)); at.make_file(&format!("{FOLDER}/{FILE1}"));
at.set_mode(&format!("{}/{}", FOLDER, FILE1), 0o775); at.set_mode(&format!("{FOLDER}/{FILE1}"), 0o775);
at.hard_link( at.hard_link(&format!("{FOLDER}/{FILE1}"), &format!("{FOLDER}/{FILE2}"));
&format!("{}/{}", FOLDER, FILE1),
&format!("{}/{}", FOLDER, FILE2),
);
args.append(&mut vec![FOLDER, DEST]); args.append(&mut vec![FOLDER, DEST]);
let src_file1_metadata = at.metadata(&format!("{}/{}", FOLDER, FILE1)); let src_file1_metadata = at.metadata(&format!("{FOLDER}/{FILE1}"));
scene.ucmd().args(&args).succeeds(); scene.ucmd().args(&args).succeeds();
at.dir_exists(DEST); at.dir_exists(DEST);
let dest_file1_metadata = at.metadata(&format!("{}/{}", DEST, FILE1)); let dest_file1_metadata = at.metadata(&format!("{DEST}/{FILE1}"));
let dest_file2_metadata = at.metadata(&format!("{}/{}", DEST, FILE2)); let dest_file2_metadata = at.metadata(&format!("{DEST}/{FILE2}"));
assert_eq!( assert_eq!(
src_file1_metadata.modified().unwrap(), src_file1_metadata.modified().unwrap(),
dest_file1_metadata.modified().unwrap() dest_file1_metadata.modified().unwrap()

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

@ -1649,7 +1649,7 @@ fn test_reading_partial_blocks_from_fifo() {
// until the writer process starts). // until the writer process starts).
let mut reader_command = Command::new(TESTS_BINARY); let mut reader_command = Command::new(TESTS_BINARY);
let child = reader_command let child = reader_command
.args(["dd", "ibs=3", "obs=3", &format!("if={}", fifoname)]) .args(["dd", "ibs=3", "obs=3", &format!("if={fifoname}")])
.stdout(Stdio::piped()) .stdout(Stdio::piped())
.stderr(Stdio::piped()) .stderr(Stdio::piped())
.spawn() .spawn()
@ -1661,7 +1661,7 @@ fn test_reading_partial_blocks_from_fifo() {
writer_command writer_command
.args([ .args([
"-c", "-c",
&format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname), &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {fifoname}"),
]) ])
.spawn() .spawn()
.unwrap(); .unwrap();
@ -1692,7 +1692,7 @@ fn test_reading_partial_blocks_from_fifo_unbuffered() {
// `bs=N` takes precedence over `ibs=N` and `obs=N`. // `bs=N` takes precedence over `ibs=N` and `obs=N`.
let mut reader_command = Command::new(TESTS_BINARY); let mut reader_command = Command::new(TESTS_BINARY);
let child = reader_command let child = reader_command
.args(["dd", "bs=3", "ibs=1", "obs=1", &format!("if={}", fifoname)]) .args(["dd", "bs=3", "ibs=1", "obs=1", &format!("if={fifoname}")])
.stdout(Stdio::piped()) .stdout(Stdio::piped())
.stderr(Stdio::piped()) .stderr(Stdio::piped())
.spawn() .spawn()
@ -1704,7 +1704,7 @@ fn test_reading_partial_blocks_from_fifo_unbuffered() {
writer_command writer_command
.args([ .args([
"-c", "-c",
&format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname), &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {fifoname}"),
]) ])
.spawn() .spawn()
.unwrap(); .unwrap();
@ -1769,10 +1769,10 @@ fn test_stdin_stdout_not_rewound_even_when_connected_to_seekable_file() {
.succeeds(); .succeeds();
let err_file_content = std::fs::read_to_string(at.plus_as_string("err")).unwrap(); let err_file_content = std::fs::read_to_string(at.plus_as_string("err")).unwrap();
println!("stderr:\n{}", err_file_content); println!("stderr:\n{err_file_content}");
let out_file_content = std::fs::read_to_string(at.plus_as_string("out")).unwrap(); let out_file_content = std::fs::read_to_string(at.plus_as_string("out")).unwrap();
println!("stdout:\n{}", out_file_content); println!("stdout:\n{out_file_content}");
assert_eq!(out_file_content, "bde"); assert_eq!(out_file_content, "bde");
} }

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

@ -935,7 +935,7 @@ mod tests_split_iterator {
// minimal amount of quoting in typical cases. // minimal amount of quoting in typical cases.
match escape_style(s) { match escape_style(s) {
EscapeStyle::None => s.into(), EscapeStyle::None => s.into(),
EscapeStyle::SingleQuoted => format!("'{}'", s).into(), EscapeStyle::SingleQuoted => format!("'{s}'").into(),
EscapeStyle::Mixed => { EscapeStyle::Mixed => {
let mut quoted = String::new(); let mut quoted = String::new();
quoted.push('\''); quoted.push('\'');
@ -1015,17 +1015,13 @@ mod tests_split_iterator {
match split(input) { match split(input) {
Err(actual) => { Err(actual) => {
panic!( panic!(
"[{i}] calling split({:?}):\nexpected: Ok({:?})\n actual: Err({:?})\n", "[{i}] calling split({input:?}):\nexpected: Ok({expected:?})\n actual: Err({actual:?})\n"
input, expected, actual
); );
} }
Ok(actual) => { Ok(actual) => {
assert!( assert!(
expected == actual.as_slice(), expected == actual.as_slice(),
"[{i}] After split({:?}).unwrap()\nexpected: {:?}\n actual: {:?}\n", "[{i}] After split({input:?}).unwrap()\nexpected: {expected:?}\n actual: {actual:?}\n"
input,
expected,
actual
); );
} }
} }

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

@ -174,7 +174,7 @@ fn get_filesystem_type(scene: &TestScenario, path: &Path) -> String {
let regex = Regex::new(regex_str).unwrap(); let regex = Regex::new(regex_str).unwrap();
let m = regex.captures(&stdout_str).unwrap(); let m = regex.captures(&stdout_str).unwrap();
let fstype = m["fstype"].to_owned(); let fstype = m["fstype"].to_owned();
println!("detected fstype: {}", fstype); println!("detected fstype: {fstype}");
fstype fstype
} }
@ -4120,7 +4120,7 @@ fn test_ls_dired_recursive_multiple() {
let result = cmd.succeeds(); let result = cmd.succeeds();
let output = result.stdout_str().to_string(); let output = result.stdout_str().to_string();
println!("Output:\n{}", output); println!("Output:\n{output}");
let dired_line = output let dired_line = output
.lines() .lines()
@ -4143,7 +4143,7 @@ fn test_ls_dired_recursive_multiple() {
.unwrap() .unwrap()
.trim() .trim()
.to_string(); .to_string();
println!("Extracted filename: {}", filename); println!("Extracted filename: {filename}");
filename filename
}) })
.collect(); .collect();
@ -4229,8 +4229,8 @@ fn test_ls_dired_complex() {
.skip(1) .skip(1)
.map(|s| s.parse().unwrap()) .map(|s| s.parse().unwrap())
.collect(); .collect();
println!("{:?}", positions); println!("{positions:?}");
println!("Parsed byte positions: {:?}", positions); println!("Parsed byte positions: {positions:?}");
assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
let filenames: Vec<String> = positions let filenames: Vec<String> = positions
@ -4242,12 +4242,12 @@ fn test_ls_dired_complex() {
.unwrap() .unwrap()
.trim() .trim()
.to_string(); .to_string();
println!("Extracted filename: {}", filename); println!("Extracted filename: {filename}");
filename filename
}) })
.collect(); .collect();
println!("Extracted filenames: {:?}", filenames); println!("Extracted filenames: {filenames:?}");
assert_eq!(filenames, vec!["a1", "a22", "a333", "a4444", "d"]); assert_eq!(filenames, vec!["a1", "a22", "a333", "a4444", "d"]);
} }
@ -4269,7 +4269,7 @@ fn test_ls_subdired_complex() {
let result = cmd.succeeds(); let result = cmd.succeeds();
let output = result.stdout_str().to_string(); let output = result.stdout_str().to_string();
println!("Output:\n{}", output); println!("Output:\n{output}");
let dired_line = output let dired_line = output
.lines() .lines()
@ -4280,7 +4280,7 @@ fn test_ls_subdired_complex() {
.skip(1) .skip(1)
.map(|s| s.parse().unwrap()) .map(|s| s.parse().unwrap())
.collect(); .collect();
println!("Parsed byte positions: {:?}", positions); println!("Parsed byte positions: {positions:?}");
assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
let dirnames: Vec<String> = positions let dirnames: Vec<String> = positions
@ -4290,12 +4290,12 @@ fn test_ls_subdired_complex() {
let end_pos = chunk[1]; let end_pos = chunk[1];
let dirname = let dirname =
String::from_utf8(output.as_bytes()[start_pos..end_pos].to_vec()).unwrap(); String::from_utf8(output.as_bytes()[start_pos..end_pos].to_vec()).unwrap();
println!("Extracted dirname: {}", dirname); println!("Extracted dirname: {dirname}");
dirname dirname
}) })
.collect(); .collect();
println!("Extracted dirnames: {:?}", dirnames); println!("Extracted dirnames: {dirnames:?}");
#[cfg(unix)] #[cfg(unix)]
assert_eq!(dirnames, vec!["dir1", "dir1/c2", "dir1/d"]); assert_eq!(dirnames, vec!["dir1", "dir1/c2", "dir1/d"]);
#[cfg(windows)] #[cfg(windows)]
@ -4786,7 +4786,7 @@ fn test_acl_display() {
return; return;
} }
Err(e) => { Err(e) => {
println!("test skipped: setfacl failed with {}", e); println!("test skipped: setfacl failed with {e}");
return; return;
} }
} }
@ -4874,7 +4874,7 @@ fn test_ls_color_norm() {
let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[01mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[01mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
scene scene
.ucmd() .ucmd()
.env("LS_COLORS", format!("{}:fi=1", colors)) .env("LS_COLORS", format!("{colors}:fi=1"))
.env("TIME_STYLE", "+norm") .env("TIME_STYLE", "+norm")
.arg("-gGU") .arg("-gGU")
.arg("--color") .arg("--color")
@ -4889,7 +4889,7 @@ fn test_ls_color_norm() {
"\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
scene scene
.ucmd() .ucmd()
.env("LS_COLORS", format!("{}:fi=", colors)) .env("LS_COLORS", format!("{colors}:fi="))
.env("TIME_STYLE", "+norm") .env("TIME_STYLE", "+norm")
.arg("-gGU") .arg("-gGU")
.arg("--color") .arg("--color")
@ -4903,7 +4903,7 @@ fn test_ls_color_norm() {
"\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
scene scene
.ucmd() .ucmd()
.env("LS_COLORS", format!("{}:fi=0", colors)) .env("LS_COLORS", format!("{colors}:fi=0"))
.env("TIME_STYLE", "+norm") .env("TIME_STYLE", "+norm")
.arg("-gGU") .arg("-gGU")
.arg("--color") .arg("--color")

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

@ -1448,7 +1448,7 @@ fn test_mv_directory_into_subdirectory_of_itself_fails() {
// check that it also errors out with / // check that it also errors out with /
scene scene
.ucmd() .ucmd()
.arg(format!("{}/", dir1)) .arg(format!("{dir1}/"))
.arg(dir2) .arg(dir2)
.fails() .fails()
.stderr_contains( .stderr_contains(
@ -1601,7 +1601,7 @@ fn test_acl() {
return; return;
} }
Err(e) => { Err(e) => {
println!("test skipped: setfacl failed with {}", e); println!("test skipped: setfacl failed with {e}");
return; return;
} }
} }

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

@ -168,7 +168,7 @@ fn test_delimiter_list_ending_with_escaped_backslash() {
let (at, mut ucmd) = at_and_ucmd!(); let (at, mut ucmd) = at_and_ucmd!();
let mut ins = vec![]; let mut ins = vec![];
for (i, one_in) in ["a\n", "b\n"].iter().enumerate() { for (i, one_in) in ["a\n", "b\n"].iter().enumerate() {
let file = format!("in{}", i); let file = format!("in{i}");
at.write(&file, one_in); at.write(&file, one_in);
ins.push(file); ins.push(file);
} }

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

@ -1052,17 +1052,16 @@ fn test_batch_size_too_large() {
let large_batch_size = "18446744073709551616"; let large_batch_size = "18446744073709551616";
TestScenario::new(util_name!()) TestScenario::new(util_name!())
.ucmd() .ucmd()
.arg(format!("--batch-size={}", large_batch_size)) .arg(format!("--batch-size={large_batch_size}"))
.fails() .fails()
.code_is(2) .code_is(2)
.stderr_contains(format!( .stderr_contains(format!(
"--batch-size argument '{}' too large", "--batch-size argument '{large_batch_size}' too large"
large_batch_size
)); ));
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
TestScenario::new(util_name!()) TestScenario::new(util_name!())
.ucmd() .ucmd()
.arg(format!("--batch-size={}", large_batch_size)) .arg(format!("--batch-size={large_batch_size}"))
.fails() .fails()
.code_is(2) .code_is(2)
.stderr_contains("maximum --batch-size argument with current rlimit is"); .stderr_contains("maximum --batch-size argument with current rlimit is");

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

@ -3594,10 +3594,8 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
assert!(result.is_ok()); assert!(result.is_ok());
#[cfg(all(not(target_os = "freebsd"), not(target_os = "macos")))] #[cfg(all(not(target_os = "freebsd"), not(target_os = "macos")))]
let expected_stderr = format!( let expected_stderr =
"tail: cannot open '{}' for reading: No such device or address\n", format!("tail: cannot open '{socket}' for reading: No such device or address\n");
socket
);
#[cfg(target_os = "freebsd")] #[cfg(target_os = "freebsd")]
let expected_stderr = format!( let expected_stderr = format!(
"tail: cannot open '{}' for reading: Operation not supported\n", "tail: cannot open '{}' for reading: Operation not supported\n",
@ -3622,7 +3620,7 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
let result = file.write_all(random_string.as_bytes()); let result = file.write_all(random_string.as_bytes());
assert!(result.is_ok()); assert!(result.is_ok());
let expected_stdout = [format!("==> {} <==", path), random_string].join("\n"); let expected_stdout = [format!("==> {path} <=="), random_string].join("\n");
ts.ucmd() ts.ucmd()
.args(&["-c", "+0", path, socket]) .args(&["-c", "+0", path, socket])
.fails() .fails()