hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Don't use index operator in tests

Browse source
This commit is contained in:
Brendan Zabarauskas 2013-06-01 09:12:30 +10:00
parent a913be0373
commit 36039228b6
3 changed files with 71 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
src/test/test_mat.rs
View file

@ -15,7 +15,6 @@
use mat::*;
use vec::*;
use std::cmp::FuzzyEq;
// TODO
@ -38,8 +37,8 @@ fn test_mat2() {
assert!(mat2::from_value(4.0) == mat2::new(4.0, 0.0,
0.0, 4.0));
assert!(a[0] == vec2::new(1.0, 3.0));
assert!(a[1] == vec2::new(2.0, 4.0));
assert!(*a.col(0) == vec2::new(1.0, 3.0));
assert!(*a.col(1) == vec2::new(2.0, 4.0));
assert!(a.row(0) == vec2::new(1.0, 2.0));
assert!(a.row(1) == vec2::new(3.0, 4.0));
@ -169,11 +168,11 @@ fn test_mat2_mut() {
}
#[test]
fn test_mat2_fuzzy_eq() {
fn test_mat2_approx_eq() {
assert!(!mat2::new(0.000001, 0.000001,
0.000001, 0.000001).fuzzy_eq(&mat2::zero()));
0.000001, 0.000001).approx_eq(&mat2::zero()));
assert!(mat2::new(0.0000001, 0.0000001,
0.0000001, 0.0000001).fuzzy_eq(&mat2::zero()));
0.0000001, 0.0000001).approx_eq(&mat2::zero()));
}
#[test]
@ -196,9 +195,9 @@ fn test_mat3() {
vec3::new(2.0, 5.0, 8.0),
vec3::new(3.0, 6.0, 9.0)));
assert!(a[0] == vec3::new(1.0, 4.0, 7.0));
assert!(a[1] == vec3::new(2.0, 5.0, 8.0));
assert!(a[2] == vec3::new(3.0, 6.0, 9.0));
assert!(*a.col(0) == vec3::new(1.0, 4.0, 7.0));
assert!(*a.col(1) == vec3::new(2.0, 5.0, 8.0));
assert!(*a.col(2) == vec3::new(3.0, 6.0, 9.0));
assert!(a.row(0) == vec3::new(1.0, 2.0, 3.0));
assert!(a.row(1) == vec3::new(4.0, 5.0, 6.0));
@ -358,13 +357,13 @@ fn test_mat3_mut() {
}
#[test]
fn test_mat3_fuzzy_eq() {
fn test_mat3_approx_eq() {
assert!(!mat3::new(0.000001, 0.000001, 0.000001,
0.000001, 0.000001, 0.000001,
0.000001, 0.000001, 0.000001).fuzzy_eq(&mat3::zero()));
0.000001, 0.000001, 0.000001).approx_eq(&mat3::zero()));
assert!(mat3::new(0.0000001, 0.0000001, 0.0000001,
0.0000001, 0.0000001, 0.0000001,
0.0000001, 0.0000001, 0.0000001).fuzzy_eq(&mat3::zero()));
0.0000001, 0.0000001, 0.0000001).approx_eq(&mat3::zero()));
}
#[test]
@ -400,10 +399,10 @@ fn test_mat4() {
0.0, 0.0, 4.0, 0.0,
0.0, 0.0, 0.0, 4.0));
assert!(a[0] == vec4::new(1.0, 5.0, 9.0, 13.0));
assert!(a[1] == vec4::new(2.0, 6.0, 10.0, 14.0));
assert!(a[2] == vec4::new(3.0, 7.0, 11.0, 15.0));
assert!(a[3] == vec4::new(4.0, 8.0, 12.0, 16.0));
assert!(*a.col(0) == vec4::new(1.0, 5.0, 9.0, 13.0));
assert!(*a.col(1) == vec4::new(2.0, 6.0, 10.0, 14.0));
assert!(*a.col(2) == vec4::new(3.0, 7.0, 11.0, 15.0));
assert!(*a.col(3) == vec4::new(4.0, 8.0, 12.0, 16.0));
assert!(a.row(0) == vec4::new( 1.0, 2.0, 3.0, 4.0));
assert!(a.row(1) == vec4::new( 5.0, 6.0, 7.0, 8.0));
@ -460,7 +459,7 @@ fn test_mat4() {
13.0, 14.0, 15.0, 16.0));
assert!(c.inverse().unwrap()
.fuzzy_eq(&mat4::new( 5.0, -4.0, 1.0, 0.0,
.approx_eq(&mat4::new( 5.0, -4.0, 1.0, 0.0,
-4.0, 8.0, -4.0, 0.0,
4.0, -8.0, 4.0, 8.0,
-3.0, 4.0, 1.0, -8.0).mul_t(0.125)));
@ -567,13 +566,13 @@ fn test_mat4_mut() {
}
#[test]
fn test_mat4_fuzzy_eq() {
fn test_mat4_approx_eq() {
assert!(!mat4::new(0.000001, 0.000001, 0.000001, 0.000001,
0.000001, 0.000001, 0.000001, 0.000001,
0.000001, 0.000001, 0.000001, 0.000001,
0.000001, 0.000001, 0.000001, 0.000001).fuzzy_eq(&mat4::zero()));
0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&mat4::zero()));
assert!(mat4::new(0.0000001, 0.0000001, 0.0000001, 0.0000001,
0.0000001, 0.0000001, 0.0000001, 0.0000001,
0.0000001, 0.0000001, 0.0000001, 0.0000001,
0.0000001, 0.0000001, 0.0000001, 0.0000001).fuzzy_eq(&mat4::zero()));
0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&mat4::zero()));
}

20
src/test/test_quat.rs
View file

@ -13,8 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use std::cmp::FuzzyEq;
use mat::*;
use quat::*;
use vec::*;
@ -35,10 +33,10 @@ fn test_quat() {
assert!(a.v.x == 2.0);
assert!(a.v.y == 3.0);
assert!(a.v.z == 4.0);
assert!(a[0] == 1.0);
assert!(a[1] == 2.0);
assert!(a[2] == 3.0);
assert!(a[3] == 4.0);
assert!(*a.index(0) == 1.0);
assert!(*a.index(1) == 2.0);
assert!(*a.index(2) == 3.0);
assert!(*a.index(3) == 4.0);
// TODO
}
@ -49,15 +47,15 @@ fn test_quat_2() {
let q = quat::from_angle_axis((-45f32).radians(), &vec3::new(0f32, 0f32, -1f32));
// http://www.wolframalpha.com/input/?i={1,0}+rotate+-45+degrees
assert!(q.mul_v(&v).fuzzy_eq(&vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)));
assert!(q.mul_v(&v).approx_eq(&vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)));
assert!(q.mul_v(&v).length() == v.length());
assert!(q.to_mat3().fuzzy_eq(&mat3::new( 1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
assert!(q.to_mat3().approx_eq(&mat3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
-1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
0f32, 0f32, 1f32)));
}
#[test]
fn test_quat_fuzzy_eq() {
assert!(!quat::new(0.000001, 0.000001, 0.000001, 0.000001).fuzzy_eq(&quat::new(0.0, 0.0, 0.0, 0.0)));
assert!(quat::new(0.0000001, 0.0000001, 0.0000001, 0.0000001).fuzzy_eq(&quat::new(0.0, 0.0, 0.0, 0.0)));
fn test_quat_approx_eq() {
assert!(!quat::new(0.000001, 0.000001, 0.000001, 0.000001).approx_eq(&quat::new(0.0, 0.0, 0.0, 0.0)));
assert!(quat::new(0.0000001, 0.0000001, 0.0000001, 0.0000001).approx_eq(&quat::new(0.0, 0.0, 0.0, 0.0)));
}

85
src/test/test_vec.rs
View file

@ -13,9 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use std::cmp::FuzzyEq;
use std::num::Real::{frac_pi_2, frac_pi_3};
use vec::*;
// TODO
@ -45,14 +42,14 @@ fn test_vec2() {
mut_a = a;
mut_a.swap(0, 1);
assert!(mut_a[0] == a[1]);
assert!(mut_a[1] == a[0]);
assert!(*mut_a.index(0) == *a.index(1));
assert!(*mut_a.index(1) == *a.index(0));
mut_a = a;
assert!(a.x == 1.0);
assert!(a.y == 2.0);
assert!(a[0] == 1.0);
assert!(a[1] == 2.0);
assert!(*a.index(0) == 1.0);
assert!(*a.index(1) == 2.0);
assert!(-a == vec2::new(-1.0, -2.0));
assert!(a.neg() == vec2::new(-1.0, -2.0));
@ -102,9 +99,9 @@ fn test_vec2() {
}
#[test]
fn test_vec2_fuzzy_eq() {
assert!(!vec2::new(0.000001, 0.000001).fuzzy_eq(&vec2::new(0.0, 0.0)));
assert!(vec2::new(0.0000001, 0.0000001).fuzzy_eq(&vec2::new(0.0, 0.0)));
fn test_vec2_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)));
}
#[test]
@ -122,11 +119,11 @@ fn test_vec2_euclidean() {
assert!(a.distance(&b) == 5.0);
assert!(a.distance2(&b) == 5.0 * 5.0);
assert!(vec2::new(1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
assert!(vec2::new(10.0, 0.0).angle(&vec2::new(0.0, 5.0)).fuzzy_eq(&frac_pi_2()));
assert!(vec2::new(-1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&-frac_pi_2::<f32>()));
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(&-frac_pi_2::<f32>()));
assert!(vec2::new(3.0, 4.0).normalize().fuzzy_eq(&vec2::new(3.0/5.0, 4.0/5.0)));
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
let c = vec2::new(-2.0, -1.0);
@ -185,21 +182,21 @@ fn test_vec3() {
mut_a = a;
mut_a.swap(0, 2);
assert!(mut_a[0] == a[2]);
assert!(mut_a[2] == a[0]);
assert!(*mut_a.index(0) == *a.index(2));
assert!(*mut_a.index(2) == *a.index(0));
mut_a = a;
mut_a.swap(1, 2);
assert!(mut_a[1] == a[2]);
assert!(mut_a[2] == a[1]);
assert!(*mut_a.index(1) == *a.index(2));
assert!(*mut_a.index(2) == *a.index(1));
mut_a = a;
assert!(a.x == 1.0);
assert!(a.y == 2.0);
assert!(a.z == 3.0);
assert!(a[0] == 1.0);
assert!(a[1] == 2.0);
assert!(a[2] == 3.0);
assert!(*a.index(0) == 1.0);
assert!(*a.index(1) == 2.0);
assert!(*a.index(2) == 3.0);
assert!(a.cross(&b) == vec3::new(-3.0, 6.0, -3.0));
@ -250,7 +247,7 @@ fn test_vec3() {
// mut_a = a;
// exact_eq
// fuzzy_eq
// approx_eq
// eq
// assert!(c.abs() == vec3::new( 2.0, 1.0, 1.0));
@ -259,9 +256,9 @@ fn test_vec3() {
}
#[test]
fn test_vec3_fuzzy_eq() {
assert!(!vec3::new(0.000001, 0.000001, 0.000001).fuzzy_eq(&vec3::new(0.0, 0.0, 0.0)));
assert!(vec3::new(0.0000001, 0.0000001, 0.0000001).fuzzy_eq(&vec3::new(0.0, 0.0, 0.0)));
fn test_vec3_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)));
}
#[test]
@ -279,11 +276,11 @@ fn test_vec3_euclidean() {
assert!(a.distance(&b) == 9.0);
assert!(a.distance2(&b) == 9.0 * 9.0);
assert!(vec3::new(1.0, 0.0, 1.0).angle(&vec3::new(1.0, 1.0, 0.0)).fuzzy_eq(&frac_pi_3()));
assert!(vec3::new(10.0, 0.0, 10.0).angle(&vec3::new(5.0, 5.0, 0.0)).fuzzy_eq(&frac_pi_3()));
assert!(vec3::new(-1.0, 0.0, -1.0).angle(&vec3::new(1.0, -1.0, 0.0)).fuzzy_eq(&(2.0 * frac_pi_3())));
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())));
assert!(vec3::new(2.0, 3.0, 6.0).normalize().fuzzy_eq(&vec3::new(2.0/7.0, 3.0/7.0, 6.0/7.0)));
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
let c = vec3::new(-2.0, -1.0, 1.0);
@ -337,13 +334,13 @@ fn test_vec4() {
mut_a = a;
mut_a.swap(0, 3);
assert!(mut_a[0] == a[3]);
assert!(mut_a[3] == a[0]);
assert!(*mut_a.index(0) == *a.index(3));
assert!(*mut_a.index(3) == *a.index(0));
mut_a = a;
mut_a.swap(1, 2);
assert!(mut_a[1] == a[2]);
assert!(mut_a[2] == a[1]);
assert!(*mut_a.index(1) == *a.index(2));
assert!(*mut_a.index(2) == *a.index(1));
mut_a = a;
assert!(vec4::zero() == vec4::new(0.0, 0.0, 0.0, 0.0));
@ -357,10 +354,10 @@ fn test_vec4() {
assert!(a.y == 2.0);
assert!(a.z == 3.0);
assert!(a.w == 4.0);
assert!(a[0] == 1.0);
assert!(a[1] == 2.0);
assert!(a[2] == 3.0);
assert!(a[3] == 4.0);
assert!(*a.index(0) == 1.0);
assert!(*a.index(1) == 2.0);
assert!(*a.index(2) == 3.0);
assert!(*a.index(3) == 4.0);
assert!(-a == vec4::new(-1.0, -2.0, -3.0, -4.0));
assert!(a.neg() == vec4::new(-1.0, -2.0, -3.0, -4.0));
@ -412,9 +409,9 @@ fn test_vec4() {
}
#[test]
fn test_vec4_fuzzy_eq() {
assert!(!vec4::new(0.000001, 0.000001, 0.000001, 0.000001).fuzzy_eq(&vec4::new(0.0, 0.0, 0.0, 0.0)));
assert!(vec4::new(0.0000001, 0.0000001, 0.0000001, 0.0000001).fuzzy_eq(&vec4::new(0.0, 0.0, 0.0, 0.0)));
fn test_vec4_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)));
}
#[test]
@ -432,11 +429,11 @@ fn test_vec4_euclidean() {
assert!(a.distance(&b) == 13.0);
assert!(a.distance2(&b) == 13.0 * 13.0);
assert!(vec4::new(1.0, 0.0, 1.0, 0.0).angle(&vec4::new(0.0, 1.0, 0.0, 1.0)).fuzzy_eq(&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)).fuzzy_eq(&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)).fuzzy_eq(&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()));
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()));
assert!(vec4::new(1.0, 2.0, 4.0, 10.0).normalize().fuzzy_eq(&vec4::new(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0)));
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
let c = vec4::new(-2.0, -1.0, 1.0, 2.0);