From 19376dce3275ae4b2930ecb9a22af3aff7c71f1c Mon Sep 17 00:00:00 2001 From: Brendan Zabarauskas Date: Sun, 14 Jul 2013 15:32:43 +1000 Subject: [PATCH] Divide vec unit tests into separate functions --- src/math/vec.rs | 210 ++++++++++++++++++++++-------------------------- 1 file changed, 94 insertions(+), 116 deletions(-) diff --git a/src/math/vec.rs b/src/math/vec.rs index b829e25..bbfad58 100644 --- a/src/math/vec.rs +++ b/src/math/vec.rs @@ -510,41 +510,27 @@ mod vec2_tests { static F2: float = 0.5; #[test] - fn test_vec2() { + fn test_swap() { let mut mut_a = A; - assert_eq!(Vec2::new::(1.0, 2.0), A); - assert_eq!(Vec2::from_value(1.0), Vec2::new::(1.0, 1.0)); - - assert_eq!(Vec2::zero(), Vec2::new::(0.0, 0.0)); - assert_eq!(Vec2::unit_x(), Vec2::new::(1.0, 0.0)); - assert_eq!(Vec2::unit_y(), Vec2::new::(0.0, 1.0)); - assert_eq!(Vec2::identity(), Vec2::new::(1.0, 1.0)); - - *mut_a.index_mut(0) = 42.0; - *mut_a.index_mut(1) = 43.0; - assert_eq!(mut_a, Vec2::new::(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); - assert_eq!(A.y, 2.0); - assert_eq!(*A.index(0), 1.0); - assert_eq!(*A.index(1), 2.0); + #[test] + fn test_num() { + let mut mut_a = A; assert_eq!(-A, Vec2::new::(-1.0, -2.0)); assert_eq!(A.neg(), Vec2::new::(-1.0, -2.0)); - assert_eq!(A.mul_t(F1), Vec2::new::( 1.5, 3.0)); - assert_eq!(A.div_t(F2), Vec2::new::( 2.0, 4.0)); + assert_eq!(A.mul_t(F1), Vec2::new::(1.5, 3.0)); + assert_eq!(A.div_t(F2), Vec2::new::(2.0, 4.0)); - assert_eq!(A.add_v(&B), Vec2::new::( 4.0, 6.0)); - assert_eq!(A.sub_v(&B), Vec2::new::( -2.0, -2.0)); - assert_eq!(A.mul_v(&B), Vec2::new::( 3.0, 8.0)); + assert_eq!(A.add_v(&B), Vec2::new::(4.0, 6.0)); + assert_eq!(A.sub_v(&B), Vec2::new::(-2.0, -2.0)); + assert_eq!(A.mul_v(&B), Vec2::new::(3.0, 8.0)); assert_eq!(A.div_v(&B), Vec2::new::(1.0/3.0, 2.0/4.0)); mut_a.neg_self(); @@ -576,29 +562,38 @@ mod vec2_tests { } #[test] - fn test_vec2_approx_eq() { + fn test_approx_eq() { assert!(!Vec2::new::(0.000001, 0.000001).approx_eq(&Vec2::new::(0.0, 0.0))); assert!(Vec2::new::(0.0000001, 0.0000001).approx_eq(&Vec2::new::(0.0, 0.0))); } - static E_A: Vec2 = Vec2 { x: 5.0, y: 12.0 }; // (5, 12, 13) Pythagorean triple - static E_B: Vec2 = Vec2 { x: 3.0, y: 4.0 }; // (3, 4, 5) Pythagorean triple + #[test] + 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() { - 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); - + fn test_angle() { assert!(Vec2::new::(1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&Real::frac_pi_2())); assert!(Vec2::new::(10.0, 0.0).angle(&Vec2::new::(0.0, 5.0)).approx_eq(&Real::frac_pi_2())); assert!(Vec2::new::(-1.0, 0.0).angle(&Vec2::new::(0.0, 1.0)).approx_eq(&-Real::frac_pi_2::())); + } + #[test] + fn test_normalize() { assert!(Vec2::new::(3.0, 4.0).normalize().approx_eq(&Vec2::new::(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::(-2.0, -1.0); let d = Vec2::new::( 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::(1.0, 2.0, 3.0), A); - assert_eq!(Vec3::from_value(1.0), Vec3::new::(1.0, 1.0, 1.0)); - - assert_eq!(Vec3::zero(), Vec3::new::(0.0, 0.0, 0.0)); - assert_eq!(Vec3::unit_x(), Vec3::new::(1.0, 0.0, 0.0)); - assert_eq!(Vec3::unit_y(), Vec3::new::(0.0, 1.0, 0.0)); - assert_eq!(Vec3::unit_z(), Vec3::new::(0.0, 0.0, 1.0)); - assert_eq!(Vec3::identity(), Vec3::new::(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::(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,30 +1112,31 @@ 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); - assert_eq!(A.y, 2.0); - assert_eq!(A.z, 3.0); - assert_eq!(*A.index(0), 1.0); - assert_eq!(*A.index(1), 2.0); - assert_eq!(*A.index(2), 3.0); + #[test] + fn test_cross() { + let mut mut_a = A; assert_eq!(A.cross(&B), Vec3::new::(-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::(-1.0, -2.0, -3.0)); assert_eq!(A.neg(), Vec3::new::(-1.0, -2.0, -3.0)); - assert_eq!(A.mul_t(F1), Vec3::new::( 1.5, 3.0, 4.5)); - assert_eq!(A.div_t(F2), Vec3::new::( 2.0, 4.0, 6.0)); + assert_eq!(A.mul_t(F1), Vec3::new::(1.5, 3.0, 4.5)); + assert_eq!(A.div_t(F2), Vec3::new::(2.0, 4.0, 6.0)); - assert_eq!(A.add_v(&B), Vec3::new::( 5.0, 7.0, 9.0)); - assert_eq!(A.sub_v(&B), Vec3::new::( -3.0, -3.0, -3.0)); - assert_eq!(A.mul_v(&B), Vec3::new::( 4.0, 10.0, 18.0)); + assert_eq!(A.add_v(&B), Vec3::new::(5.0, 7.0, 9.0)); + assert_eq!(A.sub_v(&B), Vec3::new::(-3.0, -3.0, -3.0)); + assert_eq!(A.mul_v(&B), Vec3::new::(4.0, 10.0, 18.0)); assert_eq!(A.div_v(&B), Vec3::new::(1.0/4.0, 2.0/5.0, 3.0/6.0)); mut_a.neg_self(); @@ -1187,29 +1168,39 @@ mod vec3_tests{ } #[test] - fn test_vec3_approx_eq() { + fn test_approx_eq() { assert!(!Vec3::new::(0.000001, 0.000001, 0.000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); assert!(Vec3::new::(0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec3::new::(0.0, 0.0, 0.0))); } - static E_A: Vec3 = Vec3 { x: 2.0, y: 3.0, z: 6.0 }; // (2, 3, 6, 7) Pythagorean quadruple - static E_B: Vec3 = Vec3 { x: 1.0, y: 4.0, z: 8.0 }; // (1, 4, 8, 9) Pythagorean quadruple #[test] - fn test_vec3_euclidean() { - assert_eq!(E_A.magnitude(), 7.0); - assert_eq!(E_A.magnitude2(), 7.0 * 7.0); + fn test_magnitude() { + let a = Vec3::new(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple + 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!(E_B.magnitude2(), 9.0 * 9.0); + assert_eq!(a.magnitude(), 7.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::(1.0, 0.0, 1.0).angle(&Vec3::new::(1.0, 1.0, 0.0)).approx_eq(&Real::frac_pi_3())); assert!(Vec3::new::(10.0, 0.0, 10.0).angle(&Vec3::new::(5.0, 5.0, 0.0)).approx_eq(&Real::frac_pi_3())); assert!(Vec3::new::(-1.0, 0.0, -1.0).angle(&Vec3::new::(1.0, -1.0, 0.0)).approx_eq(&(2.0 * Real::frac_pi_3()))); + } + #[test] + fn test_normalize() { assert!(Vec3::new::(2.0, 3.0, 6.0).normalize().approx_eq(&Vec3::new::(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::(-2.0, -1.0, 1.0); let d = Vec3::new::( 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::(1.0, 2.0, 3.0, 4.0), A); - assert_eq!(Vec4::from_value(1.0), Vec4::new::(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::(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,33 +1733,21 @@ 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::(0.0, 0.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_x(), Vec4::new::(1.0, 0.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_y(), Vec4::new::(0.0, 1.0, 0.0, 0.0)); - assert_eq!(Vec4::unit_z(), Vec4::new::(0.0, 0.0, 1.0, 0.0)); - assert_eq!(Vec4::unit_w(), Vec4::new::(0.0, 0.0, 0.0, 1.0)); - assert_eq!(Vec4::identity(), Vec4::new::(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); + #[test] + fn test_num() { + let mut mut_a = A; assert_eq!(-A, Vec4::new::(-1.0, -2.0, -3.0, -4.0)); assert_eq!(A.neg(), Vec4::new::(-1.0, -2.0, -3.0, -4.0)); - assert_eq!(A.mul_t(F1), Vec4::new::( 1.5, 3.0, 4.5, 6.0)); - assert_eq!(A.div_t(F2), Vec4::new::( 2.0, 4.0, 6.0, 8.0)); + assert_eq!(A.mul_t(F1), Vec4::new::(1.5, 3.0, 4.5, 6.0)); + assert_eq!(A.div_t(F2), Vec4::new::(2.0, 4.0, 6.0, 8.0)); - assert_eq!(A.add_v(&B), Vec4::new::( 6.0, 8.0, 10.0, 12.0)); - assert_eq!(A.sub_v(&B), Vec4::new::( -4.0, -4.0, -4.0, -4.0)); - assert_eq!(A.mul_v(&B), Vec4::new::( 5.0, 12.0, 21.0, 32.0)); + assert_eq!(A.add_v(&B), Vec4::new::(6.0, 8.0, 10.0, 12.0)); + assert_eq!(A.sub_v(&B), Vec4::new::(-4.0, -4.0, -4.0, -4.0)); + assert_eq!(A.mul_v(&B), Vec4::new::(5.0, 12.0, 21.0, 32.0)); assert_eq!(A.div_v(&B), Vec4::new::(1.0/5.0, 2.0/6.0, 3.0/7.0, 4.0/8.0)); assert_eq!(A.dot(&B), 70.0); @@ -1812,29 +1781,38 @@ mod vec4_tests { } #[test] - fn test_vec4_approx_eq() { + fn test_approx_eq() { assert!(!Vec4::new::(0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); assert!(Vec4::new::(0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&Vec4::new::(0.0, 0.0, 0.0, 0.0))); } - static E_A: Vec4 = Vec4 { x: 1.0, y: 2.0, z: 4.0, w: 10.0 }; // (1, 2, 4, 10, 11) Pythagorean quintuple - static E_B: Vec4 = Vec4 { x: 1.0, y: 2.0, z: 8.0, w: 10.0 }; // (1, 2, 8, 10, 13) Pythagorean quintuple + #[test] + 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() { - 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); - + fn test_angle() { assert!(Vec4::new::(1.0, 0.0, 1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); assert!(Vec4::new::(10.0, 0.0, 10.0, 0.0).angle(&Vec4::new::(0.0, 5.0, 0.0, 5.0)).approx_eq(&Real::frac_pi_2())); assert!(Vec4::new::(-1.0, 0.0, -1.0, 0.0).angle(&Vec4::new::(0.0, 1.0, 0.0, 1.0)).approx_eq(&Real::frac_pi_2())); + } + #[test] + fn test_normalize() { assert!(Vec4::new::(1.0, 2.0, 4.0, 10.0).normalize().approx_eq(&Vec4::new::(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::(-2.0, -1.0, 1.0, 2.0); let d = Vec4::new::( 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);