change the way we test non-determinism

Author: LorrensP-2158466

tests/pass/float.rs

@@ -1275,51 +1275,35 @@ fn test_non_determinism() {
     use std::{f32, f64};
     // FIXME(powi_powf): add when supported
 
-    // TODO: should we do an `assert_ne!` on res1 and res2?
-    // it is possible that the same error is applied on
-    // seperate operations (unlikely but possible)
-    // and thus this `assert_ne!` can "sometimes" fail.
-    macro_rules! test_operation {
-        ($a:expr, $b:expr, $op:path $(, $ulp:expr)?) => {
-            // 5 times enough?
-            let results: [_; 5] = ::core::array::from_fn(|i| (i, $op($a, $b)));
-            for (idx1, res1) in results {
-                for (idx2, res2) in results {
-                    if idx1 == idx2 {
-                        continue;
-                    }
-                    assert_approx_eq!(res1, res2$(, $ulp)?);
-                }
-            }
-        };
-        ($a:expr, $op:path $(, $ulp:expr)?) => {
-            // 5 times enough?
-            let results: [_; 5] = ::core::array::from_fn(|i| (i, $op($a)));
-            for (idx1, res1) in results {
-                for (idx2, res2) in results {
-                    if idx1 == idx2 {
-                        continue;
-                    }
-                    assert_approx_eq!(res1, res2 $(, $ulp)?);
-                }
+    /// Ensure that the operation is non-deterministic
+    #[track_caller]
+    fn ensure<T: PartialEq + std::fmt::Debug>(f: impl Fn() -> T) {
+        let rounds = 16;
+        let first = f();
+        for _ in 1..rounds {
+            if f() != first {
+                // We saw two different values!
+                return;
             }
-        };
+        }
+        // We saw the same thing N times.
+        panic!("expected non-determinism, got {rounds} times the same result: {first:?}");
     }
 
     macro_rules! test_operations_f {
         ($a:expr, $b:expr) => {
-            test_operation!($a, $b, fadd_algebraic);
-            test_operation!($a, $b, fsub_algebraic);
-            test_operation!($a, $b, fmul_algebraic);
-            test_operation!($a, $b, fdiv_algebraic);
-            test_operation!($a, $b, frem_algebraic);
+            ensure(|| fadd_algebraic($a, $b));
+            ensure(|| fsub_algebraic($a, $b));
+            ensure(|| fmul_algebraic($a, $b));
+            ensure(|| fdiv_algebraic($a, $b));
+            ensure(|| frem_algebraic($a, $b));
 
             unsafe {
-                test_operation!($a, $b, fadd_fast);
-                test_operation!($a, $b, fsub_fast);
-                test_operation!($a, $b, fmul_fast);
-                test_operation!($a, $b, fdiv_fast);
-                test_operation!($a, $b, frem_fast);
+                ensure(|| fadd_fast($a, $b));
+                ensure(|| fsub_fast($a, $b));
+                ensure(|| fmul_fast($a, $b));
+                ensure(|| fdiv_fast($a, $b));
+                ensure(|| frem_fast($a, $b));
             }
         };
     }
@@ -1329,63 +1313,61 @@ fn test_non_determinism() {
     }
     pub fn test_operations_f32(a: f32, b: f32) {
         test_operations_f!(a, b);
-        // custom ulp for log
-        test_operation!(a, b, f32::log, 128);
-        test_operation!(a, f32::exp);
+        ensure(|| a.log(b));
+        ensure(|| a.exp());
     }
     pub fn test_operations_f64(a: f64, b: f64) {
         test_operations_f!(a, b);
-        // custom ulp for log
-        test_operation!(a, b, f64::log, 128);
-        test_operation!(a, f64::exp);
+        ensure(|| a.log(b));
+        ensure(|| a.exp());
     }
     pub fn test_operations_f128(a: f128, b: f128) {
         test_operations_f!(a, b);
     }
 
     pub fn test_extras() {
         // f32
-        test_operation!(10f32, f32::exp2);
-        test_operation!(f32::consts::E, f32::ln);
-        test_operation!(0f32, f32::ln_1p);
-        test_operation!(10f32, f32::log10);
-        test_operation!(8f32, f32::log2);
-        test_operation!(27.0f32, f32::cbrt);
-        test_operation!(3.0f32, 4.0f32, f32::hypot);
-        test_operation!(0f32, f32::sin);
-        test_operation!(0f32, f32::cos);
-        test_operation!(1.0f32, f32::sinh);
-        test_operation!(1.0f32, f32::asinh);
-        test_operation!(1.0f32, f32::cosh);
-        test_operation!(2.0f32, f32::acosh);
-        test_operation!(1.0f32, f32::tan);
-        test_operation!(1.0f32, f32::tanh);
-        test_operation!(1.0f32, 2.0f32, f32::atan2);
-        test_operation!(0.5f32, f32::atanh);
-        test_operation!(5.0f32, f32::gamma);
+        ensure(|| 10f32.exp2());
+        ensure(|| f32::consts::E.ln());
+        ensure(|| 1f32.ln_1p());
+        ensure(|| 10f32.log10());
+        ensure(|| 8f32.log2());
+        ensure(|| 27.0f32.cbrt());
+        ensure(|| 3.0f32.hypot(4.0f32));
+        ensure(|| 1f32.sin());
+        ensure(|| 0f32.cos());
+        ensure(|| 1.0f32.sinh());
+        ensure(|| 1.0f32.asinh());
+        ensure(|| 1.0f32.cosh());
+        ensure(|| 2.0f32.acosh());
+        ensure(|| 1.0f32.tan());
+        ensure(|| 1.0f32.tanh());
+        ensure(|| 1.0f32.atan2(2.0f32));
+        ensure(|| 0.5f32.atanh());
+        ensure(|| 5.0f32.gamma());
 
         // f64
-        test_operation!(50f64, f64::exp2);
-        test_operation!(1f64, f64::ln);
-        test_operation!(0f64, f64::ln_1p);
-        test_operation!(f64::consts::E, f64::log10);
-        test_operation!(f64::consts::E, f64::log2);
-        test_operation!(0f64, f64::sin);
-        test_operation!(0f64, f64::cos);
-        test_operation!(27.0f64, f64::cbrt);
-        test_operation!(3.0f64, 4.0f64, f64::hypot);
-        test_operation!(1.0f64, f64::sinh);
-        test_operation!(1.0f64, f64::asinh);
-        test_operation!(1.0f64, f64::cosh);
-        test_operation!(3.0f64, f64::acosh);
-        test_operation!(1.0f64, f64::tan);
-        test_operation!(1.0f64, f64::tanh);
-        test_operation!(0.5f64, f64::atanh);
-        test_operation!(5.0f64, f64::gamma);
+        ensure(|| 50f64.exp2());
+        ensure(|| 3f64.ln());
+        ensure(|| 1f64.ln_1p());
+        ensure(|| f64::consts::E.log10());
+        ensure(|| f64::consts::E.log2());
+        ensure(|| 1f64.sin());
+        ensure(|| 0f64.cos());
+        ensure(|| 27.0f64.cbrt());
+        ensure(|| 3.0f64.hypot(4.0f64));
+        ensure(|| 1.0f64.sinh());
+        ensure(|| 1.0f64.asinh());
+        ensure(|| 1.0f64.cosh());
+        ensure(|| 3.0f64.acosh());
+        ensure(|| 1.0f64.tan());
+        ensure(|| 1.0f64.tanh());
+        ensure(|| 0.5f64.atanh());
+        ensure(|| 5.0f64.gamma());
     }
 
     test_operations_f16(5., 7.);
-    test_operations_f32(12., 4.);
+    test_operations_f32(12., 5.);
     test_operations_f64(19., 11.);
     test_operations_f128(25., 18.);
     test_extras();