Divide vec unit tests into separate functions
This commit is contained in:
Brendan Zabarauskas
parent
e321b1046b
commit
19376dce32
1 changed files with 94 additions and 116 deletions
210
src/math/vec.rs
210
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::<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);
|
||||
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::<float>(-1.0, -2.0));
|
||||
assert_eq!(A.neg(), Vec2::new::<float>(-1.0, -2.0));
|
||||
|
||||
assert_eq!(A.mul_t(F1), Vec2::new::<float>( 1.5, 3.0));
|
||||
assert_eq!(A.div_t(F2), Vec2::new::<float>( 2.0, 4.0));
|
||||
assert_eq!(A.mul_t(F1), Vec2::new::<float>(1.5, 3.0));
|
||||
assert_eq!(A.div_t(F2), Vec2::new::<float>(2.0, 4.0));
|
||||
|
||||
assert_eq!(A.add_v(&B), Vec2::new::<float>( 4.0, 6.0));
|
||||
assert_eq!(A.sub_v(&B), Vec2::new::<float>( -2.0, -2.0));
|
||||
assert_eq!(A.mul_v(&B), Vec2::new::<float>( 3.0, 8.0));
|
||||
assert_eq!(A.add_v(&B), Vec2::new::<float>(4.0, 6.0));
|
||||
assert_eq!(A.sub_v(&B), Vec2::new::<float>(-2.0, -2.0));
|
||||
assert_eq!(A.mul_v(&B), Vec2::new::<float>(3.0, 8.0));
|
||||
assert_eq!(A.div_v(&B), Vec2::new::<float>(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::<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
|
||||
static E_B: Vec2<float> = 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::<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,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::<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));
|
||||
|
||||
assert_eq!(A.mul_t(F1), Vec3::new::<float>( 1.5, 3.0, 4.5));
|
||||
assert_eq!(A.div_t(F2), Vec3::new::<float>( 2.0, 4.0, 6.0));
|
||||
assert_eq!(A.mul_t(F1), Vec3::new::<float>(1.5, 3.0, 4.5));
|
||||
assert_eq!(A.div_t(F2), Vec3::new::<float>(2.0, 4.0, 6.0));
|
||||
|
||||
assert_eq!(A.add_v(&B), Vec3::new::<float>( 5.0, 7.0, 9.0));
|
||||
assert_eq!(A.sub_v(&B), Vec3::new::<float>( -3.0, -3.0, -3.0));
|
||||
assert_eq!(A.mul_v(&B), Vec3::new::<float>( 4.0, 10.0, 18.0));
|
||||
assert_eq!(A.add_v(&B), Vec3::new::<float>(5.0, 7.0, 9.0));
|
||||
assert_eq!(A.sub_v(&B), Vec3::new::<float>(-3.0, -3.0, -3.0));
|
||||
assert_eq!(A.mul_v(&B), Vec3::new::<float>(4.0, 10.0, 18.0));
|
||||
assert_eq!(A.div_v(&B), Vec3::new::<float>(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::<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() {
|
||||
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::<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,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::<float>(0.0, 0.0, 0.0, 0.0));
|
||||
assert_eq!(Vec4::unit_x(), Vec4::new::<float>(1.0, 0.0, 0.0, 0.0));
|
||||
assert_eq!(Vec4::unit_y(), Vec4::new::<float>(0.0, 1.0, 0.0, 0.0));
|
||||
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);
|
||||
#[test]
|
||||
fn test_num() {
|
||||
let mut mut_a = A;
|
||||
|
||||
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));
|
||||
|
||||
assert_eq!(A.mul_t(F1), Vec4::new::<float>( 1.5, 3.0, 4.5, 6.0));
|
||||
assert_eq!(A.div_t(F2), Vec4::new::<float>( 2.0, 4.0, 6.0, 8.0));
|
||||
assert_eq!(A.mul_t(F1), Vec4::new::<float>(1.5, 3.0, 4.5, 6.0));
|
||||
assert_eq!(A.div_t(F2), Vec4::new::<float>(2.0, 4.0, 6.0, 8.0));
|
||||
|
||||
assert_eq!(A.add_v(&B), Vec4::new::<float>( 6.0, 8.0, 10.0, 12.0));
|
||||
assert_eq!(A.sub_v(&B), Vec4::new::<float>( -4.0, -4.0, -4.0, -4.0));
|
||||
assert_eq!(A.mul_v(&B), Vec4::new::<float>( 5.0, 12.0, 21.0, 32.0));
|
||||
assert_eq!(A.add_v(&B), Vec4::new::<float>(6.0, 8.0, 10.0, 12.0));
|
||||
assert_eq!(A.sub_v(&B), Vec4::new::<float>(-4.0, -4.0, -4.0, -4.0));
|
||||
assert_eq!(A.mul_v(&B), Vec4::new::<float>(5.0, 12.0, 21.0, 32.0));
|
||||
assert_eq!(A.div_v(&B), Vec4::new::<float>(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::<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
|
||||
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
|
||||
#[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::<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);
|
||||
|
|
|
|||
Loading…
Reference in a new issue