coretests: add abs() and copysign() tests, and remove now-unnecessary ui test

2 files changed, 56 insertions, 91 deletions

diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index cdde5b883aa..1212d36a1b1 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -747,19 +747,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).min(9.0), -0.0);
                 $fassert!((-0.0 as $fty).min(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).min(-9.0), -9.0);
-                $fassert!((<$fty>::INFINITY as $fty).min(9.0), 9.0);
+                $fassert!(<$fty>::INFINITY.min(9.0), 9.0);
                 $fassert!((9.0 as $fty).min(<$fty>::INFINITY), 9.0);
-                $fassert!((<$fty>::INFINITY as $fty).min(-9.0), -9.0);
+                $fassert!(<$fty>::INFINITY.min(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).min(<$fty>::INFINITY), -9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).min(9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.min(9.0), <$fty>::NEG_INFINITY);
                 $fassert!((9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).min(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.min(-9.0), <$fty>::NEG_INFINITY);
                 $fassert!((-9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NAN as $fty).min(9.0), 9.0);
-                $fassert!((<$fty>::NAN as $fty).min(-9.0), -9.0);
+                $fassert!(<$fty>::NAN.min(9.0), 9.0);
+                $fassert!(<$fty>::NAN.min(-9.0), -9.0);
                 $fassert!((9.0 as $fty).min(<$fty>::NAN), 9.0);
                 $fassert!((-9.0 as $fty).min(<$fty>::NAN), -9.0);
-                $fassert!((<$fty>::NAN as $fty).min(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.min(<$fty>::NAN).is_nan());
             }
             #[test]
             fn max() {
@@ -777,19 +777,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).max(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).max(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).max(-9.0).is_sign_negative());
-                $fassert!((<$fty>::INFINITY as $fty).max(9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.max(9.0), <$fty>::INFINITY);
                 $fassert!((9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::INFINITY as $fty).max(-9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.max(-9.0), <$fty>::INFINITY);
                 $fassert!((-9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).max(9.0), 9.0);
+                $fassert!(<$fty>::NEG_INFINITY.max(9.0), 9.0);
                 $fassert!((9.0 as $fty).max(<$fty>::NEG_INFINITY), 9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).max(-9.0), -9.0);
+                $fassert!(<$fty>::NEG_INFINITY.max(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).max(<$fty>::NEG_INFINITY), -9.0);
-                $fassert!((<$fty>::NAN as $fty).max(9.0), 9.0);
-                $fassert!((<$fty>::NAN as $fty).max(-9.0), -9.0);
+                $fassert!(<$fty>::NAN.max(9.0), 9.0);
+                $fassert!(<$fty>::NAN.max(-9.0), -9.0);
                 $fassert!((9.0 as $fty).max(<$fty>::NAN), 9.0);
                 $fassert!((-9.0 as $fty).max(<$fty>::NAN), -9.0);
-                $fassert!((<$fty>::NAN as $fty).max(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.max(<$fty>::NAN).is_nan());
             }
             #[test]
             fn minimum() {
@@ -806,19 +806,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).minimum(9.0), -0.0);
                 $fassert!((-0.0 as $fty).minimum(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).minimum(-9.0), -9.0);
-                $fassert!((<$fty>::INFINITY as $fty).minimum(9.0), 9.0);
+                $fassert!(<$fty>::INFINITY.minimum(9.0), 9.0);
                 $fassert!((9.0 as $fty).minimum(<$fty>::INFINITY), 9.0);
-                $fassert!((<$fty>::INFINITY as $fty).minimum(-9.0), -9.0);
+                $fassert!(<$fty>::INFINITY.minimum(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).minimum(<$fty>::INFINITY), -9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.minimum(9.0), <$fty>::NEG_INFINITY);
                 $fassert!((9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.minimum(-9.0), <$fty>::NEG_INFINITY);
                 $fassert!((-9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NAN as $fty).minimum(9.0).is_nan());
-                $fassert!((<$fty>::NAN as $fty).minimum(-9.0).is_nan());
+                $fassert!(<$fty>::NAN.minimum(9.0).is_nan());
+                $fassert!(<$fty>::NAN.minimum(-9.0).is_nan());
                 $fassert!((9.0 as $fty).minimum(<$fty>::NAN).is_nan());
                 $fassert!((-9.0 as $fty).minimum(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).minimum(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.minimum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn maximum() {
@@ -838,19 +838,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).maximum(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).maximum(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).maximum(-9.0).is_sign_negative());
-                $fassert!((<$fty>::INFINITY as $fty).maximum(9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.maximum(9.0), <$fty>::INFINITY);
                 $fassert!((9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::INFINITY as $fty).maximum(-9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.maximum(-9.0), <$fty>::INFINITY);
                 $fassert!((-9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(9.0), 9.0);
+                $fassert!(<$fty>::NEG_INFINITY.maximum(9.0), 9.0);
                 $fassert!((9.0 as $fty).maximum(<$fty>::NEG_INFINITY), 9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(-9.0), -9.0);
+                $fassert!(<$fty>::NEG_INFINITY.maximum(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).maximum(<$fty>::NEG_INFINITY), -9.0);
-                $fassert!((<$fty>::NAN as $fty).maximum(9.0).is_nan());
-                $fassert!((<$fty>::NAN as $fty).maximum(-9.0).is_nan());
+                $fassert!(<$fty>::NAN.maximum(9.0).is_nan());
+                $fassert!(<$fty>::NAN.maximum(-9.0).is_nan());
                 $fassert!((9.0 as $fty).maximum(<$fty>::NAN).is_nan());
                 $fassert!((-9.0 as $fty).maximum(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).maximum(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.maximum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn midpoint() {
@@ -863,20 +863,17 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).midpoint(0.0), 0.0);
                 $fassert!((-0.0 as $fty).midpoint(-0.0), -0.0);
                 $fassert!((-5.0 as $fty).midpoint(5.0), 0.0);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN), 0.0);
-                $fassert!((<$fty>::MIN as $fty).midpoint(<$fty>::MAX), -0.0);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
-                $fassert!((-<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
-                $fassert!((<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
-                $fassert!(
-                    (-<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE),
-                    -<$fty>::MAX / 2.
-                );
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MIN), 0.0);
+                $fassert!(<$fty>::MIN.midpoint(<$fty>::MAX), -0.0);
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MAX).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
+                $fassert!(<$fty>::MAX.midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MAX).midpoint(-<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
                 $fassert!((<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
                 $fassert!((<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
                 $fassert!((-<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
                 $fassert!((-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MAX), <$fty>::MAX);
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MAX), <$fty>::MAX);
                 $fassert!(
                     (<$fty>::MIN_POSITIVE).midpoint(<$fty>::MIN_POSITIVE),
                     <$fty>::MIN_POSITIVE
@@ -885,16 +882,16 @@ macro_rules! test_float {
                     (-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MIN_POSITIVE),
                     -<$fty>::MIN_POSITIVE
                 );
-                $fassert!((<$fty>::MAX as $fty).midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
-                $fassert!((<$fty>::MAX as $fty).midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
-                $fassert!((<$fty>::INFINITY as $fty).midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!(<$fty>::MAX.midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
+                $fassert!(<$fty>::MAX.midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
+                $fassert!(<$fty>::INFINITY.midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
                 $fassert!(
-                    (<$fty>::NEG_INFINITY as $fty).midpoint(<$fty>::NEG_INFINITY),
+                    <$fty>::NEG_INFINITY.midpoint(<$fty>::NEG_INFINITY),
                     <$fty>::NEG_INFINITY
                 );
-                $fassert!((<$fty>::NAN as $fty).midpoint(1.0).is_nan());
+                $fassert!(<$fty>::NAN.midpoint(1.0).is_nan());
                 $fassert!((1.0 as $fty).midpoint(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).midpoint(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.midpoint(<$fty>::NAN).is_nan());
 
                 // test if large differences in magnitude are still correctly computed.
                 // NOTE: that because of how small x and y are, x + y can never overflow
@@ -903,7 +900,7 @@ macro_rules! test_float {
                 // be safely doubled, while j is significantly smaller.
                 for i in <$fty>::MAX_EXP.saturating_sub(64)..<$fty>::MAX_EXP {
                     for j in 0..64u8 {
-                        let large = <$fty>::from(2.0f32).powi(i);
+                        let large = (2.0 as $fty).powi(i);
                         // a much smaller number, such that there is no chance of overflow to test
                         // potential double rounding in midpoint's implementation.
                         let small = (2.0 as $fty).powi(<$fty>::MAX_EXP - 1)
@@ -918,6 +915,20 @@ macro_rules! test_float {
                 }
             }
             #[test]
+            fn abs() {
+                $fassert!((-1.0 as $fty).abs(), 1.0);
+                $fassert!((1.0 as $fty).abs(), 1.0);
+                $fassert!(<$fty>::NEG_INFINITY.abs(), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.abs(), <$fty>::INFINITY);
+            }
+            #[test]
+            fn copysign() {
+                $fassert!((1.0 as $fty).copysign(-2.0), -1.0);
+                $fassert!((-1.0 as $fty).copysign(2.0), 1.0);
+                $fassert!(<$fty>::INFINITY.copysign(-0.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.copysign(0.0), <$fty>::INFINITY);
+            }
+            #[test]
             fn rem_euclid() {
                 // FIXME: Use $fassert when rem_euclid becomes const
                 assert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
diff --git a/tests/ui/consts/const-eval/float_methods.rs b/tests/ui/consts/const-eval/float_methods.rs
deleted file mode 100644
index 853f75825ac..00000000000
--- a/tests/ui/consts/const-eval/float_methods.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ run-pass
-//! Tests the float intrinsics: min, max, abs, copysign
-
-#![feature(f16, f128)]
-
-const F16_MIN: f16 = 1.0_f16.min(0.5_f16);
-const F16_MAX: f16 = 1.0_f16.max(0.5_f16);
-const F16_ABS: f16 = (-1.0_f16).abs();
-const F16_COPYSIGN: f16 = 1.0_f16.copysign(-2.0_f16);
-
-const F32_MIN: f32 = 1.0_f32.min(0.5_f32);
-const F32_MAX: f32 = 1.0_f32.max(0.5_f32);
-const F32_ABS: f32 = (-1.0_f32).abs();
-const F32_COPYSIGN: f32 = 1.0_f32.copysign(-2.0_f32);
-
-const F64_MIN: f64 = 1.0_f64.min(0.5_f64);
-const F64_MAX: f64 = 1.0_f64.max(0.5_f64);
-const F64_ABS: f64 = (-1.0_f64).abs();
-const F64_COPYSIGN: f64 = 1.0_f64.copysign(-2.0_f64);
-
-const F128_MIN: f128 = 1.0_f128.min(0.5_f128);
-const F128_MAX: f128 = 1.0_f128.max(0.5_f128);
-const F128_ABS: f128 = (-1.0_f128).abs();
-const F128_COPYSIGN: f128 = 1.0_f128.copysign(-2.0_f128);
-
-fn main() {
-    assert_eq!(F16_MIN, 0.5);
-    assert_eq!(F16_MAX, 1.0);
-    assert_eq!(F16_ABS, 1.0);
-    assert_eq!(F16_COPYSIGN, -1.0);
-
-    assert_eq!(F32_MIN, 0.5);
-    assert_eq!(F32_MAX, 1.0);
-    assert_eq!(F32_ABS, 1.0);
-    assert_eq!(F32_COPYSIGN, -1.0);
-
-    assert_eq!(F64_MIN, 0.5);
-    assert_eq!(F64_MAX, 1.0);
-    assert_eq!(F64_ABS, 1.0);
-    assert_eq!(F64_COPYSIGN, -1.0);
-
-    assert_eq!(F128_MIN, 0.5);
-    assert_eq!(F128_MAX, 1.0);
-    assert_eq!(F128_ABS, 1.0);
-    assert_eq!(F128_COPYSIGN, -1.0);
-}