Create Test trait to do type specific comparisons.

Handles equality and approximate equality for all underlying storage types. Tests don't need to be type specific or include approximation logic for floating point numbers. Part of #29.
iliekturtles · Dec 21, 2017 · 7058f33 · 7058f33
1 parent fcfd9f6
commit 7058f33
Show file tree

Hide file tree

Showing 8 changed files with 358 additions and 281 deletions.
diff --git a/src/si/acceleration.rs b/src/si/acceleration.rs
@@ -61,13 +61,12 @@ quantity! {
 #[cfg(test)]
 mod tests {
     storage_types! {
-        types: Float;
-
         use num::One;
         use si::quantities::*;
         use si::acceleration as a;
         use si::length as l;
         use si::time as t;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
@@ -101,10 +100,10 @@ mod tests {
 
             // TODO #17 Convert to == once PartialEq is implemented.
             fn test<L: l::Conversion<V>, A: a::Conversion<V>>(_l: L, a: A) {
-                assert_eq!(V::one(),
-                        (Length::new::<L>(V::one()) /
-                            (Time::new::<t::second>(V::one()) * Time::new::<t::second>(V::one())))
-                                .get(a));
+                Test::assert_eq(&V::one(),
+                    &(Length::new::<L>(V::one()) /
+                        (Time::new::<t::second>(V::one()) * Time::new::<t::second>(V::one())))
+                            .get(a));
             }
         }
     }

diff --git a/src/si/area.rs b/src/si/area.rs
@@ -61,13 +61,12 @@ quantity! {
 #[cfg(test)]
 mod tests {
     storage_types! {
-        types: Float;
-
         use stdlib::any::TypeId;
-        use num::{Float, One};
+        use num::One;
         use si::quantities::*;
         use si::area as a;
         use si::length as l;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
@@ -108,9 +107,8 @@ mod tests {
 
             // TODO #17 Convert to == once PartialEq is implemented.
             fn test<L: l::Conversion<V>, A: a::Conversion<V>>(_l: L, a: A) {
-                assert_ulps_eq!(V::one(),
-                    (Length::new::<L>(V::one()) * Length::new::<L>(V::one())).get(a),
-                    epsilon = V::epsilon());
+                Test::assert_eq(&V::one(),
+                    &(Length::new::<L>(V::one()) * Length::new::<L>(V::one())).get(a));
             }
         }
     }

diff --git a/src/si/force.rs b/src/si/force.rs
@@ -41,14 +41,13 @@ quantity! {
 #[cfg(test)]
 mod tests {
     storage_types! {
-        types: Float;
-
-        use num::{Float, One};
+        use num::One;
         use si::quantities::*;
         use si::force as f;
         use si::length as l;
         use si::mass as m;
         use si::time as t;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
@@ -121,10 +120,9 @@ mod tests {
                 _t: T,
                 f: F
             ) {
-                assert_ulps_eq!(V::one(), ((Mass::new::<M>(V::one())
+                Test::assert_approx_eq(&V::one(), &((Mass::new::<M>(V::one())
                         * Length::new::<L>(V::one()))
-                        / (Time::new::<T>(V::one()) * Time::new::<T>(V::one()))).get(f),
-                    epsilon = V::epsilon());
+                        / (Time::new::<T>(V::one()) * Time::new::<T>(V::one()))).get(f));
             }
         }
     }

diff --git a/src/si/frequency.rs b/src/si/frequency.rs
@@ -41,12 +41,11 @@ quantity! {
 #[cfg(test)]
 mod tests {
     storage_types! {
-        types: Float;
-
-        use num::{Float, One};
+        use num::One;
         use si::quantities::*;
         use si::frequency as f;
         use si::time as t;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
@@ -80,10 +79,10 @@ mod tests {
 
             // TODO #17 Convert to == once PartialEq is implemented.
             fn test<T: t::Conversion<V>, F: f::Conversion<V>>(t: T, f: F) {
-                assert_ulps_eq!((V::one() / Time::new::<T>(V::one())).get(f),
-                    Frequency::new::<F>(V::one()).get(f), epsilon = V::epsilon());
-                assert_ulps_eq!(Time::new::<T>(V::one()).get(t),
-                    (V::one() / Frequency::new::<F>(V::one())).get(t), epsilon = V::epsilon());
+                Test::assert_approx_eq(&(V::one() / Time::new::<T>(V::one())).get(f),
+                    &Frequency::new::<F>(V::one()).get(f));
+                Test::assert_approx_eq(&Time::new::<T>(V::one()).get(t),
+                    &(V::one() / Frequency::new::<F>(V::one())).get(t));
             }
         }
     }

diff --git a/src/si/length.rs b/src/si/length.rs
@@ -86,11 +86,13 @@ mod tests {
 
         use si::quantities::*;
         use si::length::meter;
+        use tests::Test;
 
         quickcheck! {
             #[allow(trivial_casts)]
             fn hypot(l: V, r: V) -> bool {
-                l.hypot(r) == Length::new::<meter>(l).hypot(Length::new::<meter>(r)).get(meter)
+                Test::eq(&l.hypot(r),
+                    &Length::new::<meter>(l).hypot(Length::new::<meter>(r)).get(meter))
             }
         }
     }

diff --git a/src/si/velocity.rs b/src/si/velocity.rs
@@ -60,17 +60,17 @@ quantity! {
 #[cfg(test)]
 mod test {
     storage_types! {
-        types: Float;
-
         use num::One;
         use si::quantities::*;
         use si::length as l;
         use si::time as t;
         use si::velocity as v;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
-            let _: Velocity<V> = Length::new::<l::meter>(V::one()) / Time::new::<t::second>(V::one());
+            let _: Velocity<V> = Length::new::<l::meter>(V::one())
+                / Time::new::<t::second>(V::one());
         }
 
         #[test]
@@ -99,8 +99,8 @@ mod test {
 
             // TODO #17 Convert to == once PartialEq is implemented.
             fn test<L: l::Conversion<V>, E: v::Conversion<V>>(_l: L, v: E) {
-                assert_eq!(V::one(),
-                    (Length::new::<L>(V::one()) / Time::new::<t::second>(V::one())).get(v));
+                Test::assert_eq(&V::one(),
+                    &(Length::new::<L>(V::one()) / Time::new::<t::second>(V::one())).get(v));
             }
         }
     }

diff --git a/src/si/volume.rs b/src/si/volume.rs
@@ -60,14 +60,13 @@ quantity! {
 #[cfg(test)]
 mod tests {
     storage_types! {
-        types: Float;
-
         use stdlib::any::TypeId;
-        use num::{Float, One};
+        use num::One;
         use si::quantities::*;
         use si::area as a;
         use si::volume as v;
         use si::length as l;
+        use tests::Test;
 
         #[test]
         fn check_dimension() {
@@ -112,11 +111,10 @@ mod tests {
 
             // TODO #17 Convert to == once PartialEq is implemented.
             fn test<L: l::Conversion<V>, O: v::Conversion<V>>(_l: L, v: O) {
-                assert_ulps_eq!(V::one(),
-                    (Length::new::<L>(V::one())
+                Test::assert_eq(&V::one(),
+                    &(Length::new::<L>(V::one())
                         * Length::new::<L>(V::one())
-                        * Length::new::<L>(V::one())).get(v),
-                    epsilon = V::epsilon());
+                        * Length::new::<L>(V::one())).get(v));
             }
         }
     }