Precision bug fix when FormatType is None (RustPython#3975)

Author: gilteunchoi

Lib/test/test_float.py

@@ -775,8 +775,6 @@ def test_format_testfile(self):
                 self.assertEqual(fmt % float(arg), rhs)
                 self.assertEqual(fmt % -float(arg), '-' + rhs)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_issue5864(self):
         self.assertEqual(format(123.456, '.4'), '123.5')
         self.assertEqual(format(1234.56, '.4'), '1.235e+03')

common/src/float_ops.rs

@@ -188,14 +188,15 @@ pub fn format_general(
     magnitude: f64,
     case: Case,
     alternate_form: bool,
+    always_shows_fract: bool,
 ) -> String {
     match magnitude {
         magnitude if magnitude.is_finite() => {
             let r_exp = format!("{:.*e}", precision.saturating_sub(1), magnitude);
             let mut parts = r_exp.splitn(2, 'e');
             let base = parts.next().unwrap();
             let exponent = parts.next().unwrap().parse::<i64>().unwrap();
-            if exponent < -4 || exponent >= (precision as i64) {
+            if exponent < -4 || exponent + (always_shows_fract as i64) >= (precision as i64) {
                 let e = match case {
                     Case::Lower => 'e',
                     Case::Upper => 'E',

vm/src/cformat.rs

@@ -348,6 +348,7 @@ impl CFormatSpec {
                     magnitude,
                     case,
                     self.flags.contains(CConversionFlags::ALTERNATE_FORM),
+                    false,
                 )
             }
             _ => unreachable!(),

vm/src/format.rs

@@ -379,6 +379,7 @@ impl FormatSpec {
                     magnitude,
                     float_ops::Case::Upper,
                     false,
+                    false,
                 ))
             }
             Some(FormatType::GeneralFormatLower) => {
@@ -388,6 +389,7 @@ impl FormatSpec {
                     magnitude,
                     float_ops::Case::Lower,
                     false,
+                    false,
                 ))
             }
             Some(FormatType::ExponentUpper) => Ok(float_ops::format_exponent(
@@ -408,7 +410,19 @@ impl FormatSpec {
             None => match magnitude {
                 magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
                 magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
-                _ => Ok(float_ops::to_string(magnitude)),
+                _ => match self.precision {
+                    Some(_) => {
+                        let precision = self.precision.unwrap_or(magnitude.to_string().len() - 1);
+                        Ok(float_ops::format_general(
+                            precision,
+                            magnitude,
+                            float_ops::Case::Lower,
+                            false,
+                            true,
+                        ))
+                    }
+                    None => Ok(float_ops::to_string(magnitude)),
+                },
             },
         };