Merge branch 'main' into core-1

Author: oech3

src/common/validation.rs

@@ -62,19 +62,6 @@ fn get_canonical_util_name(util_name: &str) -> &str {
     }
 }
 
-/// Finds a utility with a prefix (e.g., "uu_test" -> "test")
-pub fn find_prefixed_util<'a>(
-    binary_name: &str,
-    mut util_keys: impl Iterator<Item = &'a str>,
-) -> Option<&'a str> {
-    util_keys.find(|util| {
-        binary_name.ends_with(*util)
-            && binary_name.len() > util.len() // Ensure there's actually a prefix
-            && !binary_name[..binary_name.len() - (*util).len()]
-                .ends_with(char::is_alphanumeric)
-    })
-}
-
 /// Gets the binary path from command line arguments
 /// # Panics
 /// Panics if the binary path cannot be determined
@@ -123,35 +110,4 @@ mod tests {
         assert_eq!(name(Path::new("")), None);
         assert_eq!(name(Path::new("/")), None);
     }
-
-    #[test]
-    fn test_find_prefixed_util() {
-        let utils = ["test", "cat", "ls", "cp"];
-
-        // Test exact prefixed matches
-        assert_eq!(
-            find_prefixed_util("uu_test", utils.iter().copied()),
-            Some("test")
-        );
-        assert_eq!(
-            find_prefixed_util("my-cat", utils.iter().copied()),
-            Some("cat")
-        );
-        assert_eq!(
-            find_prefixed_util("prefix_ls", utils.iter().copied()),
-            Some("ls")
-        );
-
-        // Test non-alphanumeric separator requirement
-        assert_eq!(find_prefixed_util("prefixcat", utils.iter().copied()), None); // no separator
-        assert_eq!(find_prefixed_util("testcat", utils.iter().copied()), None); // no separator
-
-        // Test no match
-        assert_eq!(find_prefixed_util("unknown", utils.iter().copied()), None);
-        assert_eq!(find_prefixed_util("", utils.iter().copied()), None);
-
-        // Test exact util name (should not match as prefixed)
-        assert_eq!(find_prefixed_util("test", utils.iter().copied()), None);
-        assert_eq!(find_prefixed_util("cat", utils.iter().copied()), None);
-    }
 }

src/uu/nice/src/nice.rs

@@ -9,6 +9,7 @@ use clap::{Arg, ArgAction, Command};
 use libc::PRIO_PROCESS;
 use std::ffi::OsString;
 use std::io::{Error, ErrorKind, Write};
+use std::num::IntErrorKind;
 use std::os::unix::process::CommandExt;
 use std::process;
 
@@ -23,6 +24,8 @@ pub mod options {
     pub static COMMAND: &str = "COMMAND";
 }
 
+const NICE_BOUND_NO_OVERFLOW: i32 = 50;
+
 fn is_prefix_of(maybe_prefix: &str, target: &str, min_match: usize) -> bool {
     if maybe_prefix.len() < min_match || maybe_prefix.len() > target.len() {
         return false;
@@ -126,12 +129,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
             match nstr.parse::<i32>() {
                 Ok(num) => num,
-                Err(e) => {
-                    return Err(USimpleError::new(
-                        125,
-                        translate!("nice-error-invalid-number", "value" => nstr.clone(), "error" => e),
-                    ));
-                }
+                Err(e) => match e.kind() {
+                    IntErrorKind::PosOverflow => NICE_BOUND_NO_OVERFLOW,
+                    IntErrorKind::NegOverflow => -NICE_BOUND_NO_OVERFLOW,
+                    _ => {
+                        return Err(USimpleError::new(
+                            125,
+                            translate!("nice-error-invalid-number", "value" => nstr.clone(), "error" => e),
+                        ));
+                    }
+                },
             }
         }
         None => {

tests/by-util/test_nice.rs

@@ -90,3 +90,33 @@ fn test_trailing_empty_adjustment() {
         "error: The argument '--adjustment <adjustment>' requires a value but none was supplied",
     );
 }
+
+#[test]
+fn test_nice_huge() {
+    new_ucmd!()
+        .args(&[
+            "-n",
+            "99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999",
+            "true",
+        ])
+        .succeeds()
+        .no_stdout();
+}
+
+#[test]
+fn test_nice_huge_negative() {
+    new_ucmd!().args(&["-n", "-9999999999", "true"]).succeeds();
+    //.stderr_contains("Permission denied"); Depending on platform?
+}
+
+#[test]
+fn test_sign_middle() {
+    new_ucmd!()
+        .args(&["-n", "-2+4", "true"])
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_contains("invalid");
+}
+//uu: "-2+4" is not a valid number: invalid digit found in string
+//gnu: invalid adjustment `-2+4'
+//Both message is fine