Change tests to understand different values of NaN

Author: mattico

src/float/add.rs

@@ -130,8 +130,8 @@ macro_rules! add {
                 // If partial cancellation occured, we need to left-shift the result
                 // and adjust the exponent:
                 if a_significand < implicit_bit << 3 {
-                    let shift = (a_significand.0.leading_zeros() 
-                        - (implicit_bit << 3).0.leading_zeros()) as i32;
+                    let shift = a_significand.0.leading_zeros() as i32
+                        - (implicit_bit << 3).0.leading_zeros() as i32;
                     a_significand <<= shift as usize;
                     a_exponent -= Wrapping(shift);
                 }
@@ -205,15 +205,33 @@ mod test {
     // TODO: Add F32/F64 to qc so that they print the right values (at the very least)
     quickcheck! {
         fn addsf3(a: U32, b: U32) -> bool {
-            let (a, b) = (a.0, b.0);
-            let r = super::__addsf3(f32::from_repr(a), f32::from_repr(b));
-            r.repr() == (f32::from_repr(a) + f32::from_repr(b)).repr()
+            let (a, b) = (f32::from_repr(a.0), f32::from_repr(b.0));
+            let x = super::__addsf3(a, b);
+            let y = a + b;
+            if x.is_nan() == y.is_nan() {
+                if x.is_nan() {
+                    true
+                } else {
+                    x.repr() == y.repr()
+                }
+            } else {
+                false
+            }
         }
 
         fn adddf3(a: U64, b: U64) -> bool {
-            let (a, b) = (a.0, b.0);
-            let r = super::__adddf3(f64::from_repr(a), f64::from_repr(b));
-            r.repr() == (f64::from_repr(a) + f64::from_repr(b)).repr()
+            let (a, b) = (f64::from_repr(a.0), f64::from_repr(b.0));
+            let x = super::__adddf3(a, b);
+            let y = a + b;
+            if x.is_nan() == y.is_nan() {
+                if x.is_nan() {
+                    true
+                } else {
+                    x.repr() == y.repr()
+                }
+            } else {
+                false
+            }
         }
     }
 
@@ -262,19 +280,26 @@ mod test {
     }
 
     #[test]
-    fn test_float_tiny_plus_large() {
+    fn test_float_different_nan() {
         let a = f32::from_repr(1);
-        let b = f32::from_repr(4286990935);
-        let r = super::__addsf3(a, b);
-        assert_eq!(r.repr(), (a + b).repr());
+        let b = f32::from_repr(0b11111111100100010001001010101010);
+        let x = super::__addsf3(a, b);
+        let y = a + b;
+        if !(x.is_nan() && y.is_nan()) {
+            assert_eq!(x.repr(), (a + b).repr());
+        }
     }
 
     #[test]
-    fn test_double_tiny_plus_large() {
+    fn test_double_different_nan() {
         let a = f64::from_repr(1);
-        let b = f64::from_repr(4286990935);
-        let r = super::__adddf3(a, b);
-        assert_eq!(r.repr(), (a + b).repr());
+        let b = f64::from_repr(
+            0b1111111111110010001000100101010101001000101010000110100011101011);
+        let x = super::__adddf3(a, b);
+        let y = a + b;
+        if !(x.is_nan() && y.is_nan()) {
+            assert_eq!(x.repr(), (a + b).repr());
+        }
     }
 
     #[test]