prefer float assoc consts over std module

diff --git a/tests/run-pass/float.rs b/tests/run-pass/float.rs
index 394e91ac9c3b8df24fc29de96541f533d7c57b06..5acaf6a2a97cddcc1b918533d9b344fcdc8bd2dc 100644 (file)
--- a/tests/run-pass/float.rs
+++ b/tests/run-pass/float.rs
@@ -34,37 +34,37 @@ fn main() {
     assert_eq(-5.0f32 as u32, 0);
     assert_eq(5.0f32 as i32, 5);
     assert_eq(-5.0f32 as i32, -5);
-    assert_eq(std::f32::MAX as i32, i32::MAX);
-    assert_eq(std::f32::INFINITY as i32, i32::MAX);
-    assert_eq(std::f32::MAX as u32, u32::MAX);
-    assert_eq(std::f32::INFINITY as u32, u32::MAX);
-    assert_eq(std::f32::MIN as i32, i32::MIN);
-    assert_eq(std::f32::NEG_INFINITY as i32, i32::MIN);
-    assert_eq(std::f32::MIN as u32, 0);
-    assert_eq(std::f32::NEG_INFINITY as u32, 0);
-    assert_eq(std::f32::NAN as i32, 0);
-    assert_eq(std::f32::NAN as u32, 0);
+    assert_eq(f32::MAX as i32, i32::MAX);
+    assert_eq(f32::INFINITY as i32, i32::MAX);
+    assert_eq(f32::MAX as u32, u32::MAX);
+    assert_eq(f32::INFINITY as u32, u32::MAX);
+    assert_eq(f32::MIN as i32, i32::MIN);
+    assert_eq(f32::NEG_INFINITY as i32, i32::MIN);
+    assert_eq(f32::MIN as u32, 0);
+    assert_eq(f32::NEG_INFINITY as u32, 0);
+    assert_eq(f32::NAN as i32, 0);
+    assert_eq(f32::NAN as u32, 0);
     assert_eq((u32::MAX-127) as f32 as u32, u32::MAX); // rounding loss
     assert_eq((u32::MAX-128) as f32 as u32, u32::MAX-255); // rounding loss
     assert_eq(127i8 as f32, 127.0f32);
     assert_eq(i128::MIN as f32, -170141183460469231731687303715884105728.0f32);
-    assert_eq(u128::MAX as f32, std::f32::INFINITY); // saturation
+    assert_eq(u128::MAX as f32, f32::INFINITY); // saturation
 
     // f64 <-> int casts
     assert_eq(5.0f64 as u64, 5);
     assert_eq(-5.0f64 as u64, 0);
     assert_eq(5.0f64 as i64, 5);
     assert_eq(-5.0f64 as i64, -5);
-    assert_eq(std::f64::MAX as i64, i64::MAX);
-    assert_eq(std::f64::INFINITY as i64, i64::MAX);
-    assert_eq(std::f64::MAX as u64, u64::MAX);
-    assert_eq(std::f64::INFINITY as u64, u64::MAX);
-    assert_eq(std::f64::MIN as i64, i64::MIN);
-    assert_eq(std::f64::NEG_INFINITY as i64, i64::MIN);
-    assert_eq(std::f64::MIN as u64, 0);
-    assert_eq(std::f64::NEG_INFINITY as u64, 0);
-    assert_eq(std::f64::NAN as i64, 0);
-    assert_eq(std::f64::NAN as u64, 0);
+    assert_eq(f64::MAX as i64, i64::MAX);
+    assert_eq(f64::INFINITY as i64, i64::MAX);
+    assert_eq(f64::MAX as u64, u64::MAX);
+    assert_eq(f64::INFINITY as u64, u64::MAX);
+    assert_eq(f64::MIN as i64, i64::MIN);
+    assert_eq(f64::NEG_INFINITY as i64, i64::MIN);
+    assert_eq(f64::MIN as u64, 0);
+    assert_eq(f64::NEG_INFINITY as u64, 0);
+    assert_eq(f64::NAN as i64, 0);
+    assert_eq(f64::NAN as u64, 0);
     assert_eq((u64::MAX-1023) as f64 as u64, u64::MAX); // rounding loss
     assert_eq((u64::MAX-1024) as f64 as u64, u64::MAX-2047); // rounding loss
     assert_eq(u128::MAX as f64 as u128, u128::MAX);
@@ -74,38 +74,38 @@ fn main() {
     // f32 <-> f64 casts
     assert_eq(5.0f64 as f32, 5.0f32);
     assert_eq(5.0f32 as f64, 5.0f64);
-    assert_eq(std::f64::MAX as f32, std::f32::INFINITY);
-    assert_eq(std::f64::MIN as f32, std::f32::NEG_INFINITY);
-    assert_eq(std::f32::INFINITY as f64, std::f64::INFINITY);
-    assert_eq(std::f32::NEG_INFINITY as f64, std::f64::NEG_INFINITY);
+    assert_eq(f64::MAX as f32, f32::INFINITY);
+    assert_eq(f64::MIN as f32, f32::NEG_INFINITY);
+    assert_eq(f32::INFINITY as f64, f64::INFINITY);
+    assert_eq(f32::NEG_INFINITY as f64, f64::NEG_INFINITY);
 
     // f32 min/max
     assert_eq((1.0 as f32).max(-1.0), 1.0);
     assert_eq((1.0 as f32).min(-1.0), -1.0);
-    assert_eq(std::f32::NAN.min(9.0), 9.0);
-    assert_eq(std::f32::NAN.max(-9.0), -9.0);
-    assert_eq((9.0 as f32).min(std::f32::NAN), 9.0);
-    assert_eq((-9.0 as f32).max(std::f32::NAN), -9.0);
+    assert_eq(f32::NAN.min(9.0), 9.0);
+    assert_eq(f32::NAN.max(-9.0), -9.0);
+    assert_eq((9.0 as f32).min(f32::NAN), 9.0);
+    assert_eq((-9.0 as f32).max(f32::NAN), -9.0);
 
     // f64 min/max
     assert_eq((1.0 as f64).max(-1.0), 1.0);
     assert_eq((1.0 as f64).min(-1.0), -1.0);
-    assert_eq(std::f64::NAN.min(9.0), 9.0);
-    assert_eq(std::f64::NAN.max(-9.0), -9.0);
-    assert_eq((9.0 as f64).min(std::f64::NAN), 9.0);
-    assert_eq((-9.0 as f64).max(std::f64::NAN), -9.0);
+    assert_eq(f64::NAN.min(9.0), 9.0);
+    assert_eq(f64::NAN.max(-9.0), -9.0);
+    assert_eq((9.0 as f64).min(f64::NAN), 9.0);
+    assert_eq((-9.0 as f64).max(f64::NAN), -9.0);
 
     // f32 copysign
     assert_eq(3.5_f32.copysign(0.42), 3.5_f32);
     assert_eq(3.5_f32.copysign(-0.42), -3.5_f32);
     assert_eq((-3.5_f32).copysign(0.42), 3.5_f32);
     assert_eq((-3.5_f32).copysign(-0.42), -3.5_f32);
-    assert!(std::f32::NAN.copysign(1.0).is_nan());
+    assert!(f32::NAN.copysign(1.0).is_nan());
 
     // f64 copysign
     assert_eq(3.5_f64.copysign(0.42), 3.5_f64);
     assert_eq(3.5_f64.copysign(-0.42), -3.5_f64);
     assert_eq((-3.5_f64).copysign(0.42), 3.5_f64);
     assert_eq((-3.5_f64).copysign(-0.42), -3.5_f64);
-    assert!(std::f64::NAN.copysign(1.0).is_nan());
+    assert!(f64::NAN.copysign(1.0).is_nan());
 }