uucore/num_format: properly display 10ᵖ where p is the precision

`seq --format %.2g 10 10` would display `1` because the precision would
not allow room for the decimal point, and the `0` in `10` would be
trimmed as an insignificant trailing `0`.

This has been fixed by only trimming trailing `0` in the presence of a
decimal point.

src/uucore/src/lib/features/format/num_format.rs

@@ -411,7 +411,7 @@ fn format_float_shortest(
         let mut normalized = format!("{normalized:.*}", precision);
 
         if force_decimal == ForceDecimal::No {
-            strip_zeros_and_dot(&mut normalized);
+            strip_fractional_zeroes_and_dot(&mut normalized);
         }
 
         let exp_char = match case {
@@ -424,7 +424,8 @@ fn format_float_shortest(
         // Decimal-ish notation with a few differences:
         //  - The precision works differently and specifies the total number
         //    of digits instead of the digits in the fractional part.
-        //  - If we don't force the decimal, '0' and `.` are trimmed.
+        //  - If we don't force the decimal, `.` and trailing `0` in the fractional part
+        //    are trimmed.
         let decimal_places = (precision as i32 - exponent) as usize;
         let mut formatted = if decimal_places == 0 && force_decimal == ForceDecimal::Yes {
             format!("{f:.0}.")
@@ -433,7 +434,7 @@ fn format_float_shortest(
         };
 
         if force_decimal == ForceDecimal::No {
-            strip_zeros_and_dot(&mut formatted);
+            strip_fractional_zeroes_and_dot(&mut formatted);
         }
 
         formatted
@@ -469,12 +470,16 @@ fn format_float_hexadecimal(
     s
 }
 
-fn strip_zeros_and_dot(s: &mut String) {
+fn strip_fractional_zeroes_and_dot(s: &mut String) {
-    while s.ends_with('0') {
+    let mut trim_to = s.len();
-        s.pop();
+    for (pos, c) in s.char_indices().rev() {
-    }
+        if pos + c.len_utf8() == trim_to && (c == '0' || c == '.') {
-    if s.ends_with('.') {
+            trim_to = pos;
-        s.pop();
+        }
+        if c == '.' {
+            s.truncate(trim_to);
+            break;
+        }
     }
 }
 
@@ -580,4 +585,18 @@ mod test {
         assert_eq!(f(1000000.0), "1.e+06");
         assert_eq!(f(99999999.0), "1.e+08");
     }
+
+    #[test]
+    fn strip_insignificant_end() {
+        use super::strip_fractional_zeroes_and_dot;
+        let f = |s| {
+            let mut s = String::from(s);
+            strip_fractional_zeroes_and_dot(&mut s);
+            s
+        };
+        assert_eq!(&f("1000"), "1000");
+        assert_eq!(&f("1000."), "1000");
+        assert_eq!(&f("1000.02030"), "1000.0203");
+        assert_eq!(&f("1000.00000"), "1000");
+    }
 }

tests/by-util/test_seq.rs

@@ -766,3 +766,23 @@ fn test_invalid_zero_increment_value() {
         .no_stdout()
         .usage_error("invalid Zero increment value: '0'");
 }
+
+#[test]
+fn test_power_of_ten_display() {
+    new_ucmd!()
+        .args(&["-f", "%.2g", "10", "10"])
+        .succeeds()
+        .stdout_only("10\n");
+}
+
+#[test]
+fn test_default_g_precision() {
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e5", "1e5"])
+        .succeeds()
+        .stdout_only("0000100000\n");
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e6", "1e6"])
+        .succeeds()
+        .stdout_only("000001e+06\n");
+}