Add a test for incorrect rounding to even

Author: tgross35

src/etc/test-float-parse/src/validate.rs

@@ -246,7 +246,7 @@ impl<F: Float> FloatRes<F> {
     }
 }
 
-/// Decompose a float into its integral components.
+/// Decompose a float into its integral components. This includes the implicit bit.
 ///
 /// If `allow_nan` is `false`, panic if `NaN` values are reached.
 fn decode<F: Float>(f: F, allow_nan: bool) -> FloatRes<F> {

src/etc/test-float-parse/src/validate/tests.rs

@@ -66,7 +66,7 @@ fn test_validate() {
 }
 
 #[test]
-fn test_check() {
+fn test_validate_real() {
     // Most of the arbitrary values come from checking against <http://weitz.de/ieee/>.
     let r = &BigRational::from_float(10.0).unwrap();
     FloatRes::<f32>::validate_real(r.clone(), 10, 0).unwrap();
@@ -88,6 +88,61 @@ fn test_check() {
     FloatRes::<f32>::validate_real(r.clone(), -0b100110100101001000101100, -13).unwrap_err();
 }
 
+#[test]
+#[allow(unused)]
+fn test_validate_real_rounding() {
+    // Check that we catch when values don't round to even.
+
+    // For f32, the cutoff between 1.0 and the next value up (1.0000001) is
+    // 1.000000059604644775390625. Anything below it should round down, anything above it should
+    // round up, and the value itself should round _down_ because `1.0` has an even significand but
+    // 1.0000001 is odd.
+    let v1_low_down = Rational::parse("1.00000005960464477539062499999").expect_finite();
+    let v1_mid_down = Rational::parse("1.000000059604644775390625").expect_finite();
+    let v1_high_up = Rational::parse("1.00000005960464477539062500001").expect_finite();
+
+    let exp = -(f32::MAN_BITS as i32);
+    let v1_down_sig = 1 << f32::MAN_BITS;
+    let v1_up_sig = (1 << f32::MAN_BITS) | 0b1;
+
+    FloatRes::<f32>::validate_real(v1_low_down.clone(), v1_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(v1_mid_down.clone(), v1_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(v1_high_up.clone(), v1_up_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v1_low_down.clone(), -v1_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v1_mid_down.clone(), -v1_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v1_high_up.clone(), -v1_up_sig, exp).unwrap();
+
+    // 1.000000178813934326171875 is between 1.0000001 and the next value up, 1.0000002. The middle
+    // value here should round _up_ since 1.0000002 has an even mantissa.
+    let v2_low_down = Rational::parse("1.00000017881393432617187499999").expect_finite();
+    let v2_mid_up = Rational::parse("1.000000178813934326171875").expect_finite();
+    let v2_high_up = Rational::parse("1.00000017881393432617187500001").expect_finite();
+
+    let v2_down_sig = v1_up_sig;
+    let v2_up_sig = (1 << f32::MAN_BITS) | 0b10;
+
+    FloatRes::<f32>::validate_real(v2_low_down.clone(), v2_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(v2_mid_up.clone(), v2_up_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(v2_high_up.clone(), v2_up_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v2_low_down.clone(), -v2_down_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v2_mid_up.clone(), -v2_up_sig, exp).unwrap();
+    FloatRes::<f32>::validate_real(-v2_high_up.clone(), -v2_up_sig, exp).unwrap();
+
+    // Rounding the wrong direction should error
+    for res in [
+        FloatRes::<f32>::validate_real(v1_mid_down.clone(), v1_up_sig, exp),
+        FloatRes::<f32>::validate_real(v2_mid_up.clone(), v2_down_sig, exp),
+        FloatRes::<f32>::validate_real(-v1_mid_down.clone(), -v1_up_sig, exp),
+        FloatRes::<f32>::validate_real(-v2_mid_up.clone(), -v2_down_sig, exp),
+    ] {
+        let e = res.unwrap_err();
+        let CheckFailure::InvalidReal { incorrect_midpoint_rounding: true, .. } = e else {
+            panic!("{e:?}");
+        };
+    }
+}
+
+/// Just a quick check that the constants are what we expect.
 #[test]
 fn check_constants() {
     assert_eq!(f32::constants().max.to_f32().unwrap(), f32::MAX);