Merge branch 'main' into link-edge-case-tests

Author: anihal

Cargo.toml

@@ -605,9 +605,6 @@ required-features = ["uudoc"]
 lto = true
 panic = "abort"
 codegen-units = 1
-# FIXME: https://github.com/uutils/coreutils/issues/10654
-[profile.release.package.uu_expand]
-codegen-units = 16
 
 # A release-like profile that is as small as possible.
 [profile.release-small]

src/uu/expand/src/expand.rs

@@ -362,39 +362,29 @@ enum CharType {
 fn classify_char(buf: &[u8], byte: usize, utf8: bool) -> (CharType, usize, usize) {
     use self::CharType::{Backspace, Other, Tab};
 
-    if utf8 {
-        let nbytes = char::from(buf[byte]).len_utf8();
+    let b = buf[byte];
+    if b.is_ascii() {
+        return match b {
+            b'\t' => (Tab, 0, 1),
+            b'\x08' => (Backspace, 0, 1),
+            _ => (Other, 1, 1),
+        };
+    }
 
+    if utf8 {
+        let nbytes = char::from(b).len_utf8();
         let Some(slice) = buf.get(byte..byte + nbytes) else {
             // don't overrun buffer because of invalid UTF-8
             return (Other, 1, 1);
         };
 
         if let Ok(t) = from_utf8(slice) {
-            match t.chars().next() {
-                Some('\t') => (Tab, 0, 1),
-                Some('\x08') => (Backspace, 0, 1),
-                Some(c) => (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes),
-                None => {
-                    // no valid char at start of t, so take 1 byte
-                    (Other, 1, 1)
-                }
+            if let Some(c) = t.chars().next() {
+                return (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes);
             }
-        } else {
-            (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
         }
-    } else {
-        (
-            match buf.get(byte) {
-                // always take exactly 1 byte in strict ASCII mode
-                Some(0x09) => Tab,
-                Some(0x08) => Backspace,
-                _ => Other,
-            },
-            0,
-            1,
-        )
     }
+    (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
 }
 
 /// Write spaces for a tab expansion.

src/uu/mktemp/src/mktemp.rs

@@ -131,8 +131,10 @@ impl Options {
                 (tmpdir, OsString::from(template))
             }
             Some(template) => {
-                let tmpdir = if env::var(TMPDIR_ENV_VAR).is_ok() && matches.get_flag(OPT_T) {
-                    env::var_os(TMPDIR_ENV_VAR).map(Into::into)
+                let tmpdir = if let Some(tmpdir) = env::var_os(TMPDIR_ENV_VAR)
+                    && matches.get_flag(OPT_T)
+                {
+                    Some(PathBuf::from(tmpdir))
                 } else if tmpdir.is_some() {
                     tmpdir
                 } else if matches.get_flag(OPT_T) || matches.contains_id(OPT_TMPDIR) {
@@ -390,7 +392,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // application logic.
     let options = Options::from(&matches);
 
-    if env::var("POSIXLY_CORRECT").is_ok() {
+    if env::var_os("POSIXLY_CORRECT").is_some() {
         // If POSIXLY_CORRECT was set, template MUST be the last argument.
         if matches.contains_id(ARG_TEMPLATE) {
             // Template argument was provided, check if was the last one.

src/uu/test/src/test.rs

@@ -341,12 +341,15 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
         PathCondition::Sticky => false,
         PathCondition::UserOwns => unimplemented!(),
         PathCondition::Fifo => false,
-        PathCondition::Readable => false, // TODO
+        PathCondition::Readable => true,
         PathCondition::Socket => false,
         PathCondition::NonEmpty => stat.len() > 0,
         PathCondition::UserIdFlag => false,
-        PathCondition::Writable => false,   // TODO
-        PathCondition::Executable => false, // TODO
+        PathCondition::Writable => !stat.permissions().readonly(),
+        PathCondition::Executable => std::path::Path::new(path)
+            .extension()
+            .and_then(|e| e.to_str())
+            .is_some_and(|e| matches!(e, "exe" | "bat" | "cmd" | "com")),
     }
 }
 

src/uucore/src/lib/features/safe_traversal.rs

@@ -24,7 +24,7 @@ use std::path::{Path, PathBuf};
 use nix::dir::Dir;
 use nix::fcntl::{OFlag, openat};
 use nix::libc;
-use nix::sys::stat::{FchmodatFlags, FileStat, Mode, fchmodat, fstatat};
+use nix::sys::stat::{FchmodatFlags, FileStat, Mode, fchmodat, fstatat, mkdirat};
 use nix::unistd::{Gid, Uid, UnlinkatFlags, fchown, fchownat, unlinkat};
 use os_display::Quotable;
 
@@ -323,12 +323,10 @@ impl DirFd {
     pub fn mkdir_at(&self, name: &OsStr, mode: u32) -> io::Result<()> {
         let name_cstr =
             CString::new(name.as_bytes()).map_err(|_| SafeTraversalError::PathContainsNull)?;
-        let mode = mode as libc::mode_t;
-        let fd = self.fd.as_raw_fd();
+        let mode = Mode::from_bits_truncate(mode as libc::mode_t);
 
-        let result = unsafe { libc::mkdirat(fd, name_cstr.as_ptr(), mode) };
-        if result == -1 {
-            let err = io::Error::last_os_error();
+        if let Err(e) = mkdirat(self.fd.as_fd(), name_cstr.as_c_str(), mode) {
+            let err = io::Error::from_raw_os_error(e as i32);
             return Err(SafeTraversalError::OpenFailed {
                 path: name.into(),
                 source: err,

tests/by-util/test_hostid.rs

@@ -6,11 +6,20 @@ use regex::Regex;
 use uutests::new_ucmd;
 
 #[test]
-fn test_normal() {
-    let re = Regex::new(r"^[0-9a-f]{8}").unwrap();
+fn test_output_format() {
+    // Output must be exactly 8 lowercase hex digits followed by a newline.
+    let re = Regex::new(r"^[0-9a-f]{8}\n$").unwrap();
     new_ucmd!().succeeds().stdout_matches(&re);
 }
 
+#[test]
+fn test_help() {
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .stdout_contains("Print the numeric identifier");
+}
+
 #[test]
 fn test_invalid_flag() {
     new_ucmd!()

tests/by-util/test_test.rs

@@ -454,7 +454,6 @@ fn test_file_exists_and_is_regular() {
 }
 
 #[test]
-#[cfg(not(windows))] // FIXME: implement on Windows
 fn test_file_is_readable() {
     new_ucmd!().args(&["-r", "regular_file"]).succeeds();
 }
@@ -473,7 +472,6 @@ fn test_file_is_not_readable() {
 }
 
 #[test]
-#[cfg(not(windows))] // FIXME: implement on Windows
 fn test_file_is_writable() {
     new_ucmd!().args(&["-w", "regular_file"]).succeeds();
 }
@@ -517,7 +515,7 @@ fn test_file_is_not_executable() {
 }
 
 #[test]
-#[cfg(not(windows))] // FIXME: implement on Windows
+#[cfg(not(windows))]
 fn test_file_is_executable() {
     let scenario = TestScenario::new(util_name!());
     let mut chmod = scenario.cmd("chmod");
@@ -527,6 +525,27 @@ fn test_file_is_executable() {
     scenario.ucmd().args(&["-x", "regular_file"]).succeeds();
 }
 
+#[test]
+#[cfg(windows)]
+fn test_file_is_not_writable_windows() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("readonly_file");
+    let mut perms = std::fs::metadata(at.plus("readonly_file"))
+        .unwrap()
+        .permissions();
+    perms.set_readonly(true);
+    std::fs::set_permissions(at.plus("readonly_file"), perms).unwrap();
+    ucmd.args(&["!", "-w", "readonly_file"]).succeeds();
+}
+
+#[test]
+#[cfg(windows)]
+fn test_file_is_executable_windows() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("program.exe");
+    ucmd.args(&["-x", "program.exe"]).succeeds();
+}
+
 #[test]
 fn test_is_not_empty() {
     new_ucmd!().args(&["-s", "non_empty_file"]).succeeds();