Move std float unit tests to integration tests

12 files changed, 59 insertions, 71 deletions

diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index da58d7c13bd..9c1b04b2742 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -130,6 +130,10 @@ name = "pipe-subprocess"
 path = "tests/pipe_subprocess.rs"
 harness = false
 
+[[test]]
+name = "floats"
+path = "tests/floats/lib.rs"
+
 [[bench]]
 name = "stdbenches"
 path = "benches/lib.rs"
diff --git a/library/std/src/f128.rs b/library/std/src/f128.rs
index 4f37e18a8cd..5a3626ccc1f 100644
--- a/library/std/src/f128.rs
+++ b/library/std/src/f128.rs
@@ -4,9 +4,6 @@
 //!
 //! Mathematically significant numbers are provided in the `consts` sub-module.
 
-#[cfg(test)]
-mod tests;
-
 #[unstable(feature = "f128", issue = "116909")]
 pub use core::f128::consts;
 
diff --git a/library/std/src/f16.rs b/library/std/src/f16.rs
index 42cd6e3fe2a..56b11ae170f 100644
--- a/library/std/src/f16.rs
+++ b/library/std/src/f16.rs
@@ -4,9 +4,6 @@
 //!
 //! Mathematically significant numbers are provided in the `consts` sub-module.
 
-#[cfg(test)]
-mod tests;
-
 #[unstable(feature = "f16", issue = "116909")]
 pub use core::f16::consts;
 
diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs
index 438d77b1626..1842a079dbc 100644
--- a/library/std/src/f32.rs
+++ b/library/std/src/f32.rs
@@ -12,9 +12,6 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 #![allow(missing_docs)]
 
-#[cfg(test)]
-mod tests;
-
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated, deprecated_in_future)]
 pub use core::f32::{
diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs
index 9bb4bfbab2a..cb62b2cc9df 100644
--- a/library/std/src/f64.rs
+++ b/library/std/src/f64.rs
@@ -12,9 +12,6 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 #![allow(missing_docs)]
 
-#[cfg(test)]
-mod tests;
-
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated, deprecated_in_future)]
 pub use core::f64::{
diff --git a/library/std/src/macros.rs b/library/std/src/macros.rs
index 1b0d7f3dbf2..e0f9f0bb5ce 100644
--- a/library/std/src/macros.rs
+++ b/library/std/src/macros.rs
@@ -372,18 +372,3 @@ macro_rules! dbg {
         ($($crate::dbg!($val)),+,)
     };
 }
-
-/// Verify that floats are within a tolerance of each other, 1.0e-6 by default.
-#[cfg(test)]
-macro_rules! assert_approx_eq {
-    ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, 1.0e-6) }};
-    ($a:expr, $b:expr, $lim:expr) => {{
-        let (a, b) = (&$a, &$b);
-        let diff = (*a - *b).abs();
-        assert!(
-            diff < $lim,
-            "{a:?} is not approximately equal to {b:?} (threshold {lim:?}, difference {diff:?})",
-            lim = $lim
-        );
-    }};
-}
diff --git a/library/std/src/num.rs b/library/std/src/num.rs
index d2f679e7dde..dd76081532f 100644
--- a/library/std/src/num.rs
+++ b/library/std/src/num.rs
@@ -29,28 +29,3 @@ pub use core::num::{FpCategory, ParseFloatError, ParseIntError, TryFromIntError}
 pub use core::num::{NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, NonZeroIsize};
 #[stable(feature = "nonzero", since = "1.28.0")]
 pub use core::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroUsize};
-
-#[cfg(test)]
-use crate::fmt;
-#[cfg(test)]
-use crate::ops::{Add, Div, Mul, Rem, Sub};
-
-/// Helper function for testing numeric operations
-#[cfg(test)]
-pub fn test_num<T>(ten: T, two: T)
-where
-    T: PartialEq
-        + Add<Output = T>
-        + Sub<Output = T>
-        + Mul<Output = T>
-        + Div<Output = T>
-        + Rem<Output = T>
-        + fmt::Debug
-        + Copy,
-{
-    assert_eq!(ten.add(two), ten + two);
-    assert_eq!(ten.sub(two), ten - two);
-    assert_eq!(ten.mul(two), ten * two);
-    assert_eq!(ten.div(two), ten / two);
-    assert_eq!(ten.rem(two), ten % two);
-}
diff --git a/library/std/src/f128/tests.rs b/library/std/tests/floats/f128.rs
index cbcf9f96239..d0e8b157e6b 100644
--- a/library/std/src/f128/tests.rs
+++ b/library/std/tests/floats/f128.rs
@@ -1,11 +1,11 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(reliable_f128)]
 
-use crate::f128::consts;
-use crate::num::FpCategory as Fp;
+use std::f128::consts;
+use std::num::FpCategory as Fp;
 #[cfg(reliable_f128_math)]
-use crate::ops::Rem;
-use crate::ops::{Add, Div, Mul, Sub};
+use std::ops::Rem;
+use std::ops::{Add, Div, Mul, Sub};
 
 // Note these tolerances make sense around zero, but not for more extreme exponents.
 
@@ -762,8 +762,6 @@ fn test_ln_gamma() {
 
 #[test]
 fn test_real_consts() {
-    use super::consts;
-
     let pi: f128 = consts::PI;
     let frac_pi_2: f128 = consts::FRAC_PI_2;
     let frac_pi_3: f128 = consts::FRAC_PI_3;
diff --git a/library/std/src/f16/tests.rs b/library/std/tests/floats/f16.rs
index 684ee3f3855..5180f3d40f3 100644
--- a/library/std/src/f16/tests.rs
+++ b/library/std/tests/floats/f16.rs
@@ -1,8 +1,8 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(reliable_f16)]
 
-use crate::f16::consts;
-use crate::num::{FpCategory as Fp, *};
+use std::f16::consts;
+use std::num::FpCategory as Fp;
 
 /// Tolerance for results on the order of 10.0e-2
 #[allow(unused)]
@@ -54,7 +54,7 @@ macro_rules! assert_f16_biteq {
 
 #[test]
 fn test_num_f16() {
-    test_num(10f16, 2f16);
+    crate::test_num(10f16, 2f16);
 }
 
 #[test]
@@ -734,7 +734,6 @@ fn test_ln_gamma() {
 #[test]
 fn test_real_consts() {
     // FIXME(f16_f128): add math tests when available
-    use super::consts;
 
     let pi: f16 = consts::PI;
     let frac_pi_2: f16 = consts::FRAC_PI_2;
diff --git a/library/std/src/f32/tests.rs b/library/std/tests/floats/f32.rs
index 99cfcfb231d..bf7641986ad 100644
--- a/library/std/src/f32/tests.rs
+++ b/library/std/tests/floats/f32.rs
@@ -1,5 +1,5 @@
-use crate::f32::consts;
-use crate::num::{FpCategory as Fp, *};
+use std::f32::consts;
+use std::num::FpCategory as Fp;
 
 /// Smallest number
 const TINY_BITS: u32 = 0x1;
@@ -35,7 +35,7 @@ macro_rules! assert_f32_biteq {
 
 #[test]
 fn test_num_f32() {
-    test_num(10f32, 2f32);
+    crate::test_num(10f32, 2f32);
 }
 
 #[test]
@@ -700,8 +700,6 @@ fn test_ln_gamma() {
 
 #[test]
 fn test_real_consts() {
-    use super::consts;
-
     let pi: f32 = consts::PI;
     let frac_pi_2: f32 = consts::FRAC_PI_2;
     let frac_pi_3: f32 = consts::FRAC_PI_3;
diff --git a/library/std/src/f64/tests.rs b/library/std/tests/floats/f64.rs
index f5ba2c7b594..cbbfcd15efd 100644
--- a/library/std/src/f64/tests.rs
+++ b/library/std/tests/floats/f64.rs
@@ -1,5 +1,5 @@
-use crate::f64::consts;
-use crate::num::{FpCategory as Fp, *};
+use std::f64::consts;
+use std::num::FpCategory as Fp;
 
 /// Smallest number
 const TINY_BITS: u64 = 0x1;
@@ -35,7 +35,7 @@ macro_rules! assert_f64_biteq {
 
 #[test]
 fn test_num_f64() {
-    test_num(10f64, 2f64);
+    crate::test_num(10f64, 2f64);
 }
 
 #[test]
@@ -680,7 +680,6 @@ fn test_ln_gamma() {
 
 #[test]
 fn test_real_consts() {
-    use super::consts;
     let pi: f64 = consts::PI;
     let frac_pi_2: f64 = consts::FRAC_PI_2;
     let frac_pi_3: f64 = consts::FRAC_PI_3;
diff --git a/library/std/tests/floats/lib.rs b/library/std/tests/floats/lib.rs
new file mode 100644
index 00000000000..79813871ed9
--- /dev/null
+++ b/library/std/tests/floats/lib.rs
@@ -0,0 +1,42 @@
+#![feature(f16, f128, float_gamma, float_next_up_down, float_minimum_maximum)]
+
+use std::fmt;
+use std::ops::{Add, Div, Mul, Rem, Sub};
+
+/// Verify that floats are within a tolerance of each other, 1.0e-6 by default.
+macro_rules! assert_approx_eq {
+    ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, 1.0e-6) }};
+    ($a:expr, $b:expr, $lim:expr) => {{
+        let (a, b) = (&$a, &$b);
+        let diff = (*a - *b).abs();
+        assert!(
+            diff < $lim,
+            "{a:?} is not approximately equal to {b:?} (threshold {lim:?}, difference {diff:?})",
+            lim = $lim
+        );
+    }};
+}
+
+/// Helper function for testing numeric operations
+pub fn test_num<T>(ten: T, two: T)
+where
+    T: PartialEq
+        + Add<Output = T>
+        + Sub<Output = T>
+        + Mul<Output = T>
+        + Div<Output = T>
+        + Rem<Output = T>
+        + fmt::Debug
+        + Copy,
+{
+    assert_eq!(ten.add(two), ten + two);
+    assert_eq!(ten.sub(two), ten - two);
+    assert_eq!(ten.mul(two), ten * two);
+    assert_eq!(ten.div(two), ten / two);
+    assert_eq!(ten.rem(two), ten % two);
+}
+
+mod f128;
+mod f16;
+mod f32;
+mod f64;