Divide vec unit tests into separate functions

src/math/vec.rs

@@ -510,31 +510,17 @@ mod vec2_tests {
     static F2: float = 0.5;
 
     #[test]
-    fn test_vec2() {
+    fn test_swap() {
         let mut mut_a = A;
 
-        assert_eq!(Vec2::new::<float>(1.0, 2.0), A);
-        assert_eq!(Vec2::from_value(1.0), Vec2::new::<float>(1.0, 1.0));
-
-        assert_eq!(Vec2::zero(), Vec2::new::<float>(0.0, 0.0));
-        assert_eq!(Vec2::unit_x(), Vec2::new::<float>(1.0, 0.0));
-        assert_eq!(Vec2::unit_y(), Vec2::new::<float>(0.0, 1.0));
-        assert_eq!(Vec2::identity(), Vec2::new::<float>(1.0, 1.0));
-
-        *mut_a.index_mut(0) = 42.0;
-        *mut_a.index_mut(1) = 43.0;
-        assert_eq!(mut_a, Vec2::new::<float>(42.0, 43.0));
-        mut_a = A;
-
         mut_a.swap(0, 1);
         assert_eq!(*mut_a.index(0), *A.index(1));
         assert_eq!(*mut_a.index(1), *A.index(0));
-        mut_a = A;
+    }
 
-        assert_eq!(A.x, 1.0);
+    #[test]
-        assert_eq!(A.y, 2.0);
+    fn test_num() {
-        assert_eq!(*A.index(0), 1.0);
+        let mut mut_a = A;
-        assert_eq!(*A.index(1), 2.0);
 
         assert_eq!(-A, Vec2::new::<float>(-1.0, -2.0));
         assert_eq!(A.neg(), Vec2::new::<float>(-1.0, -2.0));
@@ -576,29 +562,38 @@ mod vec2_tests {
     }
 
     #[test]
-    fn test_vec2_approx_eq() {
+    fn test_approx_eq() {
         assert!(!Vec2::new::<float>(0.000001, 0.000001).approx_eq(&Vec2::new::<float>(0.0, 0.0)));
         assert!(Vec2::new::<float>(0.0000001, 0.0000001).approx_eq(&Vec2::new::<float>(0.0, 0.0)));
     }
 
-    static E_A: Vec2<float> = Vec2 { x: 5.0, y: 12.0 }; // (5, 12, 13) Pythagorean triple
+    #[test]
-    static E_B: Vec2<float> = Vec2 { x: 3.0, y: 4.0 }; // (3, 4, 5) Pythagorean triple
+    fn test_magnitude() {
+        let a = Vec2::new(5.0, 12.0); // (5, 12, 13) Pythagorean triple
+        let b = Vec2::new(3.0, 4.0); // (3, 4, 5) Pythagorean triple
+
+        assert_eq!(a.magnitude(), 13.0);
+        assert_eq!(a.magnitude2(), 13.0 * 13.0);
+
+        assert_eq!(b.magnitude(), 5.0);
+        assert_eq!(b.magnitude2(), 5.0 * 5.0);
+    }
 
     #[test]
-    fn test_vec2_euclidean() {
+    fn test_angle() {
-        assert_eq!(E_A.magnitude(), 13.0);
-        assert_eq!(E_A.magnitude2(), 13.0 * 13.0);
-
-        assert_eq!(E_B.magnitude(), 5.0);
-        assert_eq!(E_B.magnitude2(), 5.0 * 5.0);
-
         assert!(Vec2::new::<float>(1.0, 0.0).angle(&Vec2::new::<float>(0.0, 1.0)).approx_eq(&Real::frac_pi_2()));
         assert!(Vec2::new::<float>(10.0, 0.0).angle(&Vec2::new::<float>(0.0, 5.0)).approx_eq(&Real::frac_pi_2()));
         assert!(Vec2::new::<float>(-1.0, 0.0).angle(&Vec2::new::<float>(0.0, 1.0)).approx_eq(&-Real::frac_pi_2::<float>()));
+    }
 
+    #[test]
+    fn test_normalize() {
         assert!(Vec2::new::<float>(3.0, 4.0).normalize().approx_eq(&Vec2::new::<float>(3.0/5.0, 4.0/5.0)));
         // TODO: test normalize_to, normalize_self, and normalize_self_to
+    }
 
+    #[test]
+    fn test_lerp() {
         let c = Vec2::new::<float>(-2.0, -1.0);
         let d = Vec2::new::<float>( 1.0,  0.0);
 
@@ -610,7 +605,7 @@ mod vec2_tests {
     }
 
     #[test]
-    fn test_vec2_boolean() {
+    fn test_boolean() {
         let tf = Vec2::new(true, false);
         let ff = Vec2::new(false, false);
         let tt = Vec2::new(true, true);
@@ -1106,24 +1101,9 @@ mod vec3_tests{
     static F2: float = 0.5;
 
     #[test]
-    fn test_vec3() {
+    fn test_swap() {
         let mut mut_a = A;
 
-        assert_eq!(Vec3::new::<float>(1.0, 2.0, 3.0), A);
-        assert_eq!(Vec3::from_value(1.0), Vec3::new::<float>(1.0, 1.0, 1.0));
-
-        assert_eq!(Vec3::zero(), Vec3::new::<float>(0.0, 0.0, 0.0));
-        assert_eq!(Vec3::unit_x(), Vec3::new::<float>(1.0, 0.0, 0.0));
-        assert_eq!(Vec3::unit_y(), Vec3::new::<float>(0.0, 1.0, 0.0));
-        assert_eq!(Vec3::unit_z(), Vec3::new::<float>(0.0, 0.0, 1.0));
-        assert_eq!(Vec3::identity(), Vec3::new::<float>(1.0, 1.0, 1.0));
-
-        *mut_a.index_mut(0) = 42.0;
-        *mut_a.index_mut(1) = 43.0;
-        *mut_a.index_mut(2) = 44.0;
-        assert_eq!(mut_a, Vec3::new::<float>(42.0, 43.0, 44.0));
-        mut_a = A;
-
         mut_a.swap(0, 2);
         assert_eq!(*mut_a.index(0), *A.index(2));
         assert_eq!(*mut_a.index(2), *A.index(0));
@@ -1132,20 +1112,21 @@ mod vec3_tests{
         mut_a.swap(1, 2);
         assert_eq!(*mut_a.index(1), *A.index(2));
         assert_eq!(*mut_a.index(2), *A.index(1));
-        mut_a = A;
+    }
 
-        assert_eq!(A.x, 1.0);
+    #[test]
-        assert_eq!(A.y, 2.0);
+    fn test_cross() {
-        assert_eq!(A.z, 3.0);
+        let mut mut_a = A;
-        assert_eq!(*A.index(0), 1.0);
-        assert_eq!(*A.index(1), 2.0);
-        assert_eq!(*A.index(2), 3.0);
 
         assert_eq!(A.cross(&B), Vec3::new::<float>(-3.0, 6.0, -3.0));
 
         mut_a.cross_self(&B);
         assert_eq!(mut_a, A.cross(&B));
-        mut_a = A;
+    }
+
+    #[test]
+    fn test_num() {
+        let mut mut_a = A;
 
         assert_eq!(-A, Vec3::new::<float>(-1.0, -2.0, -3.0));
         assert_eq!(A.neg(), Vec3::new::<float>(-1.0, -2.0, -3.0));
@@ -1187,29 +1168,39 @@ mod vec3_tests{
     }
 
     #[test]
-    fn test_vec3_approx_eq() {
+    fn test_approx_eq() {
         assert!(!Vec3::new::<float>(0.000001, 0.000001, 0.000001).approx_eq(&Vec3::new::<float>(0.0, 0.0, 0.0)));
         assert!(Vec3::new::<float>(0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec3::new::<float>(0.0, 0.0, 0.0)));
     }
 
-    static E_A: Vec3<float> = Vec3 { x: 2.0, y: 3.0, z: 6.0 }; // (2, 3, 6, 7) Pythagorean quadruple
-    static E_B: Vec3<float> = Vec3 { x: 1.0, y: 4.0, z: 8.0 }; // (1, 4, 8, 9) Pythagorean quadruple
 
     #[test]
-    fn test_vec3_euclidean() {
+    fn test_magnitude() {
-        assert_eq!(E_A.magnitude(), 7.0);
+        let a = Vec3::new(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple
-        assert_eq!(E_A.magnitude2(), 7.0 * 7.0);
+        let b = Vec3::new(1.0, 4.0, 8.0); // (1, 4, 8, 9) Pythagorean quadruple
 
-        assert_eq!(E_B.magnitude(), 9.0);
+        assert_eq!(a.magnitude(), 7.0);
-        assert_eq!(E_B.magnitude2(), 9.0 * 9.0);
+        assert_eq!(a.magnitude2(), 7.0 * 7.0);
 
+        assert_eq!(b.magnitude(), 9.0);
+        assert_eq!(b.magnitude2(), 9.0 * 9.0);
+    }
+
+    #[test]
+    fn test_angle() {
         assert!(Vec3::new::<float>(1.0, 0.0, 1.0).angle(&Vec3::new::<float>(1.0, 1.0, 0.0)).approx_eq(&Real::frac_pi_3()));
         assert!(Vec3::new::<float>(10.0, 0.0, 10.0).angle(&Vec3::new::<float>(5.0, 5.0, 0.0)).approx_eq(&Real::frac_pi_3()));
         assert!(Vec3::new::<float>(-1.0, 0.0, -1.0).angle(&Vec3::new::<float>(1.0, -1.0, 0.0)).approx_eq(&(2.0 * Real::frac_pi_3())));
+    }
 
+    #[test]
+    fn test_normalize() {
         assert!(Vec3::new::<float>(2.0, 3.0, 6.0).normalize().approx_eq(&Vec3::new::<float>(2.0/7.0, 3.0/7.0, 6.0/7.0)));
         // TODO: test normalize_to, normalize_self, and normalize_self_to
+    }
 
+    #[test]
+    fn test_lerp() {
         let c = Vec3::new::<float>(-2.0, -1.0, 1.0);
         let d = Vec3::new::<float>( 1.0,  0.0, 0.5);
 
@@ -1221,7 +1212,7 @@ mod vec3_tests{
     }
 
     #[test]
-    fn test_vec3_boolean() {
+    fn test_boolean() {
         let tft = Vec3::new(true, false, true);
         let fff = Vec3::new(false, false, false);
         let ttt = Vec3::new(true, true, true);
@@ -1731,19 +1722,9 @@ mod vec4_tests {
     static F2: float = 0.5;
 
     #[test]
-    fn test_vec4() {
+    fn test_swap() {
         let mut mut_a = A;
 
-        assert_eq!(Vec4::new::<float>(1.0, 2.0, 3.0, 4.0), A);
-        assert_eq!(Vec4::from_value(1.0), Vec4::new::<float>(1.0, 1.0, 1.0, 1.0));
-
-        *mut_a.index_mut(0) = 42.0;
-        *mut_a.index_mut(1) = 43.0;
-        *mut_a.index_mut(2) = 44.0;
-        *mut_a.index_mut(3) = 45.0;
-        assert_eq!(mut_a, Vec4::new::<float>(42.0, 43.0, 44.0, 45.0));
-        mut_a = A;
-
         mut_a.swap(0, 3);
         assert_eq!(*mut_a.index(0), *A.index(3));
         assert_eq!(*mut_a.index(3), *A.index(0));
@@ -1752,23 +1733,11 @@ mod vec4_tests {
         mut_a.swap(1, 2);
         assert_eq!(*mut_a.index(1), *A.index(2));
         assert_eq!(*mut_a.index(2), *A.index(1));
-        mut_a = A;
+    }
 
-        assert_eq!(Vec4::zero(), Vec4::new::<float>(0.0, 0.0, 0.0, 0.0));
+    #[test]
-        assert_eq!(Vec4::unit_x(), Vec4::new::<float>(1.0, 0.0, 0.0, 0.0));
+    fn test_num() {
-        assert_eq!(Vec4::unit_y(), Vec4::new::<float>(0.0, 1.0, 0.0, 0.0));
+        let mut mut_a = A;
-        assert_eq!(Vec4::unit_z(), Vec4::new::<float>(0.0, 0.0, 1.0, 0.0));
-        assert_eq!(Vec4::unit_w(), Vec4::new::<float>(0.0, 0.0, 0.0, 1.0));
-        assert_eq!(Vec4::identity(), Vec4::new::<float>(1.0, 1.0, 1.0, 1.0));
-
-        assert_eq!(A.x, 1.0);
-        assert_eq!(A.y, 2.0);
-        assert_eq!(A.z, 3.0);
-        assert_eq!(A.w, 4.0);
-        assert_eq!(*A.index(0), 1.0);
-        assert_eq!(*A.index(1), 2.0);
-        assert_eq!(*A.index(2), 3.0);
-        assert_eq!(*A.index(3), 4.0);
 
         assert_eq!(-A, Vec4::new::<float>(-1.0, -2.0, -3.0, -4.0));
         assert_eq!(A.neg(), Vec4::new::<float>(-1.0, -2.0, -3.0, -4.0));
@@ -1812,29 +1781,38 @@ mod vec4_tests {
     }
 
     #[test]
-    fn test_vec4_approx_eq() {
+    fn test_approx_eq() {
         assert!(!Vec4::new::<float>(0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&Vec4::new::<float>(0.0, 0.0, 0.0, 0.0)));
         assert!(Vec4::new::<float>(0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec4::new::<float>(0.0, 0.0, 0.0, 0.0)));
     }
 
-    static E_A: Vec4<float> = Vec4 { x: 1.0, y: 2.0, z: 4.0, w: 10.0 }; // (1, 2, 4, 10, 11) Pythagorean quintuple
+    #[test]
-    static E_B: Vec4<float> = Vec4 { x: 1.0, y: 2.0, z: 8.0, w: 10.0 }; // (1, 2, 8, 10, 13) Pythagorean quintuple
+    fn test_magnitude() {
+        let a = Vec4::new(1.0, 2.0, 4.0, 10.0); // (1, 2, 4, 10, 11) Pythagorean quintuple
+        let b = Vec4::new(1.0, 2.0, 8.0, 10.0); // (1, 2, 8, 10, 13) Pythagorean quintuple
+
+        assert_eq!(a.magnitude(), 11.0);
+        assert_eq!(a.magnitude2(), 11.0 * 11.0);
+
+        assert_eq!(b.magnitude(), 13.0);
+        assert_eq!(b.magnitude2(), 13.0 * 13.0);
+    }
 
     #[test]
-    fn test_vec4_euclidean() {
+    fn test_angle() {
-        assert_eq!(E_A.magnitude(), 11.0);
-        assert_eq!(E_A.magnitude2(), 11.0 * 11.0);
-
-        assert_eq!(E_B.magnitude(), 13.0);
-        assert_eq!(E_B.magnitude2(), 13.0 * 13.0);
-
         assert!(Vec4::new::<float>(1.0, 0.0, 1.0, 0.0).angle(&Vec4::new::<float>(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2()));
         assert!(Vec4::new::<float>(10.0, 0.0, 10.0, 0.0).angle(&Vec4::new::<float>(0.0, 5.0, 0.0, 5.0)).approx_eq(&Real::frac_pi_2()));
         assert!(Vec4::new::<float>(-1.0, 0.0, -1.0, 0.0).angle(&Vec4::new::<float>(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2()));
+    }
 
+    #[test]
+    fn test_normalize() {
         assert!(Vec4::new::<float>(1.0, 2.0, 4.0, 10.0).normalize().approx_eq(&Vec4::new::<float>(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0)));
         // TODO: test normalize_to, normalize_self, and normalize_self_to
+    }
 
+    #[test]
+    fn test_lerp() {
         let c = Vec4::new::<float>(-2.0, -1.0, 1.0, 2.0);
         let d = Vec4::new::<float>( 1.0,  0.0, 0.5, 1.0);
 
@@ -1846,7 +1824,7 @@ mod vec4_tests {
     }
 
     #[test]
-    fn test_vec4_boolean() {
+    fn test_boolean() {
         let tftf = Vec4::new(true, false, true, false);
         let ffff = Vec4::new(false, false, false, false);
         let tttt = Vec4::new(true, true, true, true);