fixup! float: Enable some f16 and f128 rounding tests on miri

Author: tgross35

library/coretests/tests/floats/f128.rs

@@ -1,12 +1,9 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(target_has_reliable_f128)]
 
+use core::ops::{Add, Div, Mul, Sub};
 use std::f128::consts;
 use std::num::FpCategory as Fp;
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-use std::ops::Rem;
-use std::ops::{Add, Div, Mul, Sub};
 
 // Note these tolerances make sense around zero, but not for more extreme exponents.
 
@@ -49,47 +46,36 @@ fn test_num_f128() {
     assert_biteq!(ten.sub(two), ten - two);
     assert_biteq!(ten.mul(two), ten * two);
     assert_biteq!(ten.div(two), ten / two);
+    #[cfg(any(miri, target_has_reliable_f128_math))]
+    assert_biteq!(core::ops::Rem::rem(ten, two), ten % two);
 }
 
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_num_f128_rem() {
-    let ten = 10f128;
-    let two = 2f128;
-    assert_biteq!(ten.rem(two), ten % two);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_min_nan() {
     assert_biteq!(f128::NAN.min(2.0), 2.0);
     assert_biteq!(2.0f128.min(f128::NAN), 2.0);
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_max_nan() {
     assert_biteq!(f128::NAN.max(2.0), 2.0);
     assert_biteq!(2.0f128.max(f128::NAN), 2.0);
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_minimum() {
     assert!(f128::NAN.minimum(2.0).is_nan());
     assert!(2.0f128.minimum(f128::NAN).is_nan());
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_maximum() {
     assert!(f128::NAN.maximum(2.0).is_nan());
     assert!(2.0f128.maximum(f128::NAN).is_nan());
@@ -262,7 +248,7 @@ fn test_floor() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_ceil() {
     assert_biteq!(1.0f128.ceil(), 1.0f128);
     assert_biteq!(1.3f128.ceil(), 2.0f128);
@@ -277,7 +263,7 @@ fn test_ceil() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_round() {
     assert_biteq!(2.5f128.round(), 3.0f128);
     assert_biteq!(1.0f128.round(), 1.0f128);
@@ -293,7 +279,7 @@ fn test_round() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_round_ties_even() {
     assert_biteq!(2.5f128.round_ties_even(), 2.0f128);
     assert_biteq!(1.0f128.round_ties_even(), 1.0f128);
@@ -309,7 +295,7 @@ fn test_round_ties_even() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_trunc() {
     assert_biteq!(1.0f128.trunc(), 1.0f128);
     assert_biteq!(1.3f128.trunc(), 1.0f128);
@@ -324,7 +310,7 @@ fn test_trunc() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_fract() {
     assert_biteq!(1.0f128.fract(), 0.0f128);
     assert_biteq!(1.3f128.fract(), 0.300000000000000000000000000000000039f128);
@@ -339,7 +325,7 @@ fn test_fract() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_abs() {
     assert_biteq!(f128::INFINITY.abs(), f128::INFINITY);
     assert_biteq!(1f128.abs(), 1f128);
@@ -457,8 +443,7 @@ fn test_mul_add() {
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
+#[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_recip() {
     let nan: f128 = f128::NAN;
     let inf: f128 = f128::INFINITY;

library/coretests/tests/floats/f16.rs

@@ -50,32 +50,28 @@ fn test_num_f16() {
 // the intrinsics.
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_min_nan() {
     assert_biteq!(f16::NAN.min(2.0), 2.0);
     assert_biteq!(2.0f16.min(f16::NAN), 2.0);
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_max_nan() {
     assert_biteq!(f16::NAN.max(2.0), 2.0);
     assert_biteq!(2.0f16.max(f16::NAN), 2.0);
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_minimum() {
     assert!(f16::NAN.minimum(2.0).is_nan());
     assert!(2.0f16.minimum(f16::NAN).is_nan());
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_maximum() {
     assert!(f16::NAN.maximum(2.0).is_nan());
     assert!(2.0f16.maximum(f16::NAN).is_nan());
@@ -233,7 +229,7 @@ fn test_classify() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_floor() {
     assert_biteq!(1.0f16.floor(), 1.0f16);
     assert_biteq!(1.3f16.floor(), 1.0f16);
@@ -248,7 +244,7 @@ fn test_floor() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_ceil() {
     assert_biteq!(1.0f16.ceil(), 1.0f16);
     assert_biteq!(1.3f16.ceil(), 2.0f16);
@@ -263,7 +259,7 @@ fn test_ceil() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_round() {
     assert_biteq!(2.5f16.round(), 3.0f16);
     assert_biteq!(1.0f16.round(), 1.0f16);
@@ -279,7 +275,7 @@ fn test_round() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_round_ties_even() {
     assert_biteq!(2.5f16.round_ties_even(), 2.0f16);
     assert_biteq!(1.0f16.round_ties_even(), 1.0f16);
@@ -295,7 +291,7 @@ fn test_round_ties_even() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_trunc() {
     assert_biteq!(1.0f16.trunc(), 1.0f16);
     assert_biteq!(1.3f16.trunc(), 1.0f16);
@@ -310,7 +306,7 @@ fn test_trunc() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_fract() {
     assert_biteq!(1.0f16.fract(), 0.0f16);
     assert_biteq!(1.3f16.fract(), 0.2998f16);
@@ -325,7 +321,7 @@ fn test_fract() {
 }
 
 #[test]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_abs() {
     assert_biteq!(f16::INFINITY.abs(), f16::INFINITY);
     assert_biteq!(1f16.abs(), 1f16);
@@ -443,8 +439,7 @@ fn test_mul_add() {
 }
 
 #[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
+#[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_recip() {
     let nan: f16 = f16::NAN;
     let inf: f16 = f16::INFINITY;