printf: make negative values wrap around with unsigned/hex format

Author: eduardorittner

src/uucore/src/lib/features/parser/num_parser.rs

@@ -166,14 +166,19 @@ impl ExtendedParser for u64 {
                     let (digits, scale) = bd.into_bigint_and_scale();
                     if scale == 0 {
                         let negative = digits.sign() == Sign::Minus;
-                        match u64::try_from(digits) {
+
+                        match u64::try_from(digits.clone()) {
                             Ok(i) => Ok(i),
-                            _ => Err(ExtendedParserError::Overflow(if negative {
-                                // TODO: We should wrap around here #7488
-                                0
-                            } else {
-                                u64::MAX
-                            })),
+                            _ => {
+                                if negative {
+                                    match i64::try_from(digits) {
+                                        Ok(i) => Ok(u64::from_ne_bytes(i.to_ne_bytes())),
+                                        _ => Err(ExtendedParserError::Overflow(0)),
+                                    }
+                                } else {
+                                    Err(ExtendedParserError::Overflow(u64::MAX))
+                                }
+                            }
                         }
                     } else {
                         // Should not happen.
@@ -500,10 +505,14 @@ mod tests {
     fn test_decimal_u64() {
         assert_eq!(Ok(123), u64::extended_parse("123"));
         assert_eq!(Ok(u64::MAX), u64::extended_parse(&format!("{}", u64::MAX)));
-        // TODO: We should wrap around here #7488
+        assert_eq!(Ok(u64::MAX), u64::extended_parse("-1"));
+        assert_eq!(
+            Ok(u64::MAX / 2 - 1),
+            u64::extended_parse("-9223372036854775808")
+        );
         assert!(matches!(
-            u64::extended_parse("-123"),
-            Err(ExtendedParserError::Overflow(0))
+            u64::extended_parse("-9223372036854775809"),
+            Err(ExtendedParserError::Overflow(_))
         ));
         assert!(matches!(
             u64::extended_parse(""),

tests/by-util/test_printf.rs

@@ -1102,3 +1102,26 @@ fn float_arg_with_whitespace() {
         .fails()
         .stderr_contains("expected a numeric value");
 }
+
+#[test]
+fn unsigned_negative_wraparound() {
+    new_ucmd!()
+        .args(&["%x", "-0b100"])
+        .succeeds()
+        .stdout_only("fffffffffffffffc");
+
+    new_ucmd!()
+        .args(&["%x", "-0100"])
+        .succeeds()
+        .stdout_only("ffffffffffffffc0");
+
+    new_ucmd!()
+        .args(&["%x", "-100"])
+        .succeeds()
+        .stdout_only("ffffffffffffff9c");
+
+    new_ucmd!()
+        .args(&["%x", "-0x100"])
+        .succeeds()
+        .stdout_only("ffffffffffffff00");
+}