Add exhaustive testing of the 32-bit APIs

Author: gnzlbg

crates/libm-test/build.rs

@@ -2,11 +2,23 @@ use std::env;
 
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
-
+    let target = env::var("TARGET").expect("TARGET was not set");
+    let profile = env::var("PROFILE").unwrap_or(String::new());
+    let opt_level: i32 = env::var("OPT_LEVEL").unwrap().parse().unwrap();
     if !cfg!(feature = "checked") {
-        let lvl = env::var("OPT_LEVEL").unwrap();
-        if lvl != "0" {
+        if opt_level != 0 {
             println!("cargo:rustc-cfg=assert_no_panic");
         }
     }
+
+    if profile == "release" || opt_level > 0 {
+        match target.as_str() {
+            "x86_64-unknown-linux-gnu" |
+            "x86_64-apple-darwin" |
+            "x86_64-pc-windows-msvc" => {
+                println!("cargo:rustc-cfg=exhaustive32");
+            }
+            _ => (),
+        }
+    }
 }

crates/libm-test/src/lib.rs

@@ -101,6 +101,20 @@ macro_rules! adjust_input {
         // to execute, so check if their higher bits are set and
         // zero them:
         let p = &mut $arg as *mut _ as *mut i32;
-        unsafe { p.write(p.read() & 0xff_ffff) }
+        unsafe { p.write(p.read() & 0xffff) }
     };
 }
+
+#[macro_export]
+macro_rules! assert_approx_eq {
+    ($result:ident == $expected:ident,
+     id: $id:ident, arg: $arg:ident, ulp: $ulps:expr) => {
+        if !$crate::WithinUlps::within_ulps($result, $expected, $ulps) {
+            let f = format!(
+                "{}{:?} returns = {:?} != {:?} (expected)",
+                stringify!($id), $arg, $result, $expected
+            );
+            panic!(f);
+        }
+    }
+}

crates/libm-test/tests/exhaustive32.rs

@@ -0,0 +1,82 @@
+//! Exhaustively test unary APIs taking 32-bit wide arguments.
+#![cfg(test)]
+#![cfg(exhaustive32)]
+use libm_test::{assert_approx_eq};
+
+macro_rules! exhaustive32 {
+    // Skip those parts of the API that are not
+    // exposed by the system libm library:
+    //
+    // FIXME: maybe we can skip them as part of libm-analyze?
+    (
+        id: j0f;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    (
+        id: j1f;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    (
+        id: y0f;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    (
+        id: y1f;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    (
+        id: exp10f;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    // Too expensive:
+    (
+        id: jn;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) =>  {};
+    // match only unary functions taking f32:
+    (
+        id: $id:ident;
+        arg_tys: f32;
+        arg_ids: $arg_id:ident;
+        ret_ty: $ret_ty:ty;
+    ) => {
+        #[test]
+        #[allow(unused)]
+        fn $id() {
+            extern "C" {
+                // The system's libm function:
+                fn $id($arg_id: f32) -> $ret_ty;
+            }
+
+            for i in 0..u32::max_value() {
+                let arg: f32 = unsafe { std::mem::transmute(i) };
+                let result = libm::$id(arg);
+                let expected = unsafe { $id(arg) };
+                assert_approx_eq!(
+                    result == expected,
+                    id: $id, arg: arg, ulp: 4
+                );
+            }
+        }
+    };
+    (
+        id: $id:ident;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) => {};
+}
+
+libm_analyze::for_each_api!(exhaustive32);

crates/libm-test/tests/system_libm.rs

@@ -2,7 +2,7 @@
 #![cfg(test)]
 #![cfg(feature = "system_libm")]
 
-use libm_test::{adjust_input, Call, WithinUlps};
+use libm_test::{adjust_input, Call, assert_approx_eq};
 
 // Number of tests to generate for each function
 const NTESTS: usize = 500;
@@ -77,7 +77,9 @@ macro_rules! system_libm {
             let mut rng = rand::thread_rng();
             for _ in 0..NTESTS {
                 // Type of the system libm fn:
-                type FnTy = unsafe extern "C" fn ($($arg_ids: $arg_tys),*) -> $ret_ty;
+                type FnTy
+                    = unsafe extern "C" fn ($($arg_ids: $arg_tys),*) -> $ret_ty;
+
                 // FIXME: extern "C" wrapper over our libm functions
                 // Shouldn't be needed once they are all extern "C"
                 extern "C" fn libm_fn($($arg_ids: $arg_tys),*) -> $ret_ty {
@@ -89,18 +91,19 @@ macro_rules! system_libm {
                 }
 
                 // Generate a tuple of arguments containing random values:
-                let mut args: ( $($arg_tys,)+ ) = ( $(<$arg_tys as Rand>::gen(&mut rng),)+ );
+                let mut args: ( $($arg_tys,)+ )
+                    = ( $(<$arg_tys as Rand>::gen(&mut rng),)+ );
 
                 // Some APIs need their inputs to be "adjusted" (see macro):
                 // correct_input!(fn: $id, input: args);
                 adjust_input!(fn: $id, input: args);
 
                 let result = args.call(libm_fn as FnTy);
                 let expected = args.call($id as FnTy);
-                if !result.within_ulps(expected, ULP_TOL) {
-                    eprintln!("{}{:?} returns = {:?} != {:?} (expected)", stringify!($id), args, result, expected);
-                    panic!();
-                }
+                assert_approx_eq!(
+                    result == expected,
+                    id: $id, arg: args, ulp: ULP_TOL
+                );
             }
         }
     }