od: use "parse_size" from uucore

src/uu/od/src/parse_nrofbytes.rs

@@ -1,14 +1,18 @@
 pub fn parse_number_of_bytes(s: &str) -> Result<usize, &'static str> {
     let mut start = 0;
     let mut len = s.len();
-    let mut radix = 10;
+    let mut radix = 16;
     let mut multiply = 1;
 
     if s.starts_with("0x") || s.starts_with("0X") {
         start = 2;
-        radix = 16;
     } else if s.starts_with('0') {
         radix = 8;
+    } else {
+        return match uucore::parse_size::parse_size(&s[start..]) {
+            Ok(n) => Ok(n),
+            Err(_) => Err("parse failed"),
+        };
     }
 
     let mut ends_with = s.chars().rev();
@@ -75,22 +79,6 @@ fn parse_number_of_bytes_str(s: &str) -> Result<usize, &'static str> {
 
 #[test]
 fn test_parse_number_of_bytes() {
-    // normal decimal numbers
-    assert_eq!(0, parse_number_of_bytes_str("0").unwrap());
-    assert_eq!(5, parse_number_of_bytes_str("5").unwrap());
-    assert_eq!(999, parse_number_of_bytes_str("999").unwrap());
-    assert_eq!(2 * 512, parse_number_of_bytes_str("2b").unwrap());
-    assert_eq!(2 * 1024, parse_number_of_bytes_str("2k").unwrap());
-    assert_eq!(4 * 1024, parse_number_of_bytes_str("4K").unwrap());
-    assert_eq!(2 * 1048576, parse_number_of_bytes_str("2m").unwrap());
-    assert_eq!(4 * 1048576, parse_number_of_bytes_str("4M").unwrap());
-    assert_eq!(1073741824, parse_number_of_bytes_str("1G").unwrap());
-    assert_eq!(2000, parse_number_of_bytes_str("2kB").unwrap());
-    assert_eq!(4000, parse_number_of_bytes_str("4KB").unwrap());
-    assert_eq!(2000000, parse_number_of_bytes_str("2mB").unwrap());
-    assert_eq!(4000000, parse_number_of_bytes_str("4MB").unwrap());
-    assert_eq!(2000000000, parse_number_of_bytes_str("2GB").unwrap());
-
     // octal input
     assert_eq!(8, parse_number_of_bytes_str("010").unwrap());
     assert_eq!(8 * 512, parse_number_of_bytes_str("010b").unwrap());
@@ -103,31 +91,4 @@ fn test_parse_number_of_bytes() {
     assert_eq!(27, parse_number_of_bytes_str("0x1b").unwrap());
     assert_eq!(16 * 1024, parse_number_of_bytes_str("0x10k").unwrap());
     assert_eq!(16 * 1048576, parse_number_of_bytes_str("0x10m").unwrap());
-
-    // invalid input
-    parse_number_of_bytes_str("").unwrap_err();
-    parse_number_of_bytes_str("-1").unwrap_err();
-    parse_number_of_bytes_str("1e2").unwrap_err();
-    parse_number_of_bytes_str("xyz").unwrap_err();
-    parse_number_of_bytes_str("b").unwrap_err();
-    parse_number_of_bytes_str("1Y").unwrap_err();
-    parse_number_of_bytes_str("∞").unwrap_err();
-}
-
-#[test]
-#[cfg(target_pointer_width = "64")]
-fn test_parse_number_of_bytes_64bits() {
-    assert_eq!(1099511627776, parse_number_of_bytes_str("1T").unwrap());
-    assert_eq!(1125899906842624, parse_number_of_bytes_str("1P").unwrap());
-    assert_eq!(
-        1152921504606846976,
-        parse_number_of_bytes_str("1E").unwrap()
-    );
-
-    assert_eq!(2000000000000, parse_number_of_bytes_str("2TB").unwrap());
-    assert_eq!(2000000000000000, parse_number_of_bytes_str("2PB").unwrap());
-    assert_eq!(
-        2000000000000000000,
-        parse_number_of_bytes_str("2EB").unwrap()
-    );
 }

src/uucore/src/lib/parser/parse_size.rs

@@ -52,7 +52,7 @@ pub fn parse_size(size: &str) -> Result<usize, ParseSizeError> {
     let unit = &size[numeric_string.len()..];
     let (base, exponent): (u128, u32) = match unit {
         "" => (1, 0),
-        "b" => (512, 1), // (`head` and `tail` use "b")
+        "b" => (512, 1), // (`od`, `head` and `tail` use "b")
         "KiB" | "kiB" | "K" | "k" => (1024, 1),
         "MiB" | "miB" | "M" | "m" => (1024, 2),
         "GiB" | "giB" | "G" | "g" => (1024, 3),
@@ -210,7 +210,18 @@ mod tests {
 
     #[test]
     fn invalid_syntax() {
-        let test_strings = ["328hdsf3290", "5MiB nonsense", "5mib", "biB", "-", ""];
+        let test_strings = [
+            "328hdsf3290",
+            "5MiB nonsense",
+            "5mib",
+            "biB",
+            "-",
+            "+",
+            "",
+            "-1",
+            "1e2",
+            "∞",
+        ];
         for &test_string in &test_strings {
             assert_eq!(
                 parse_size(test_string).unwrap_err(),
@@ -228,6 +239,8 @@ mod tests {
     fn no_suffix() {
         assert_eq!(Ok(1234), parse_size("1234"));
         assert_eq!(Ok(0), parse_size("0"));
+        assert_eq!(Ok(5), parse_size("5"));
+        assert_eq!(Ok(999), parse_size("999"));
     }
 
     #[test]
@@ -239,6 +252,8 @@ mod tests {
         assert_eq!(Ok(0), parse_size("0KB"));
         assert_eq!(Ok(1000), parse_size("KB"));
         assert_eq!(Ok(1024), parse_size("K"));
+        assert_eq!(Ok(2000), parse_size("2kB"));
+        assert_eq!(Ok(4000), parse_size("4KB"));
     }
 
     #[test]
@@ -247,5 +262,26 @@ mod tests {
         assert_eq!(Ok(123 * 1000 * 1000), parse_size("123MB"));
         assert_eq!(Ok(1024 * 1024), parse_size("M"));
         assert_eq!(Ok(1000 * 1000), parse_size("MB"));
+        assert_eq!(Ok(2 * 1_048_576), parse_size("2m"));
+        assert_eq!(Ok(4 * 1_048_576), parse_size("4M"));
+        assert_eq!(Ok(2_000_000), parse_size("2mB"));
+        assert_eq!(Ok(4_000_000), parse_size("4MB"));
+    }
+
+    #[test]
+    fn gigabytes_suffix() {
+        assert_eq!(Ok(1_073_741_824), parse_size("1G"));
+        assert_eq!(Ok(2_000_000_000), parse_size("2GB"));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn x64() {
+        assert_eq!(Ok(1_099_511_627_776), parse_size("1T"));
+        assert_eq!(Ok(1_125_899_906_842_624), parse_size("1P"));
+        assert_eq!(Ok(1_152_921_504_606_846_976), parse_size("1E"));
+        assert_eq!(Ok(2_000_000_000_000), parse_size("2TB"));
+        assert_eq!(Ok(2_000_000_000_000_000), parse_size("2PB"));
+        assert_eq!(Ok(2_000_000_000_000_000_000), parse_size("2EB"));
     }
 }