Add fuzzy_eq tests

src/test/test_mat.rs

@@ -4,7 +4,7 @@ use vec::*;
 // TODO
 
 #[test]
-fn test_Mat2() {
+fn test_mat2() {
     let a = Mat2 { x: Vec2 { x: 1f, y: 3f },
                    y: Vec2 { x: 2f, y: 4f } };
     let b = Mat2 { x: Vec2 { x: 2f, y: 4f },
@@ -65,10 +65,6 @@ fn test_Mat2() {
     assert Mat2::new(0f, 2f,
                      0f, 5f).inverse().is_none();
     
-    // exact_eq
-    // fuzzy_eq
-    // eq
-    
     // let ident: Mat2<float> = Matrix::identity();     // FIXME: there's something wrong with static functions here!
     let ident: Mat2<float> = Mat2::identity();
     
@@ -104,7 +100,7 @@ fn test_Mat2() {
                                     0f, 0f, 0f, 1f);
 }
 
-fn test_Mat2_mut() {
+fn test_mat2_mut() {
     let a = Mat2 { x: Vec2 { x: 1f, y: 3f },
                    y: Vec2 { x: 2f, y: 4f } };
     let b = Mat2 { x: Vec2 { x: 2f, y: 4f },
@@ -158,7 +154,15 @@ fn test_Mat2_mut() {
 }
 
 #[test]
-fn test_Mat3() {
+fn test_mat2_fuzzy_eq() {
+    assert !Mat2::new(0.000001, 0.000001,
+                      0.000001, 0.000001).fuzzy_eq(&Mat2::zero());
+    assert Mat2::new(0.0000001, 0.0000001,
+                     0.0000001, 0.0000001).fuzzy_eq(&Mat2::zero());
+}
+
+#[test]
+fn test_mat3() {
     let a = Mat3 { x: Vec3 { x: 1f, y: 4f, z:  7f },
                    y: Vec3 { x: 2f, y: 5f, z:  8f },
                    z: Vec3 { x: 3f, y: 6f, z:  9f } };
@@ -239,10 +243,6 @@ fn test_Mat3() {
 
     assert option::unwrap(ident.inverse()) == ident;
     
-    // exact_eq
-    // fuzzy_eq
-    // eq
-    
     assert ident.is_identity();
     assert ident.is_symmetric();
     assert ident.is_diagonal();
@@ -274,7 +274,7 @@ fn test_Mat3() {
     // to_Quaternion
 }
 
-fn test_Mat3_mut() {
+fn test_mat3_mut() {
     let a = Mat3 { x: Vec3 { x: 1f, y: 4f, z:  7f },
                    y: Vec3 { x: 2f, y: 5f, z:  8f },
                    z: Vec3 { x: 3f, y: 6f, z:  9f } };
@@ -344,7 +344,17 @@ fn test_Mat3_mut() {
 }
 
 #[test]
-fn test_Mat4() {
+fn test_mat3_fuzzy_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());
+    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());
+}
+
+#[test]
+fn test_mat4() {
     let a = Mat4 { x: Vec4 { x: 1f, y: 5f, z:  9f, w: 13f },
                    y: Vec4 { x: 2f, y: 6f, z: 10f, w: 14f },
                    z: Vec4 { x: 3f, y: 7f, z: 11f, w: 15f },
@@ -446,10 +456,6 @@ fn test_Mat4() {
 
     assert option::unwrap(ident.inverse()) == ident;
     
-    // exact_eq
-    // fuzzy_eq
-    // eq
-    
     assert ident.is_identity();
     assert ident.is_symmetric();
     assert ident.is_diagonal();
@@ -475,7 +481,7 @@ fn test_Mat4() {
     assert Mat4::from_value(6f).is_diagonal();
 }
 
-fn test_Mat4_mut() {
+fn test_mat4_mut() {
     let a = Mat4 { x: Vec4 { x: 1f, y: 5f, z:  9f, w: 13f },
                    y: Vec4 { x: 2f, y: 6f, z: 10f, w: 14f },
                    z: Vec4 { x: 3f, y: 7f, z: 11f, w: 15f },
@@ -546,3 +552,15 @@ fn test_Mat4_mut() {
     assert mut_a == a.transpose();
     // mut_a = a;
 }
+
+#[test]
+fn test_mat4_fuzzy_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());
+    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());
+}

src/test/test_quat.rs

@@ -8,7 +8,7 @@ use vec::*;
 // TODO
 
 #[test]
-fn test_Quat() {
+fn test_quat() {
     let a = Quat { s: 1f, v: Vec3 { x: 2f, y: 3f, z: 4f } };
     
     assert a == Quat::from_sv(1f, Vec3::new(2f, 3f, 4f));
@@ -42,3 +42,9 @@ fn test_quat_2() {
                                            -1.0/sqrt(&2.0), 1.0/sqrt(&2.0), 0.0,
                                                        0.0,            0.0, 1.0));
 }
+
+#[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));
+}

src/test/test_vec.rs

@@ -7,7 +7,7 @@ use vec::*;
 // TODO
 
 #[test]
-fn test_Vec2() {
+fn test_vec2() {
     // assert Vec2::dim == 2;
     
     let a = Vec2 { x: 1f, y: 2f };
@@ -69,17 +69,19 @@ fn test_Vec2() {
     assert mut_a == a.sub_v(&b);
     // mut_a = a;
     
-    // exact_eq
-    // fuzzy_eq
-    // eq
-    
     // assert c.abs()       == Vec2::new( 2.0f,  1.0f);
     // assert c.min(&d)      == Vec2::new(-2.0f, -1.0f);
     // assert c.max(&d)      == Vec2::new( 1.0f,  0.0f);
 }
 
 #[test]
-fn test_Vec2_euclidean() {
+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));
+}
+
+#[test]
+fn test_vec2_euclidean() {
     let a = Vec2::new(5f, 12f); // (5, 12, 13) Pythagorean triple
     let b0 = Vec2::new(3f, 4f); // (3, 4, 5) Pythagorean triple
     let b = a.add_v(&b0);
@@ -111,7 +113,7 @@ fn test_Vec2_euclidean() {
 }
 
 #[test]
-fn test_Vec2_boolean() {
+fn test_vec2_boolean() {
     let tf = Vec2::new(true, false);
     let ff = Vec2::new(false, false);
     let tt = Vec2::new(true, true);
@@ -130,7 +132,7 @@ fn test_Vec2_boolean() {
 }
 
 #[test]
-fn test_Vec3() {
+fn test_vec3() {
     // assert Vec3::dim == 3;
     
     let a = Vec3 { x: 1f, y: 2f, z: 3f };
@@ -217,7 +219,13 @@ fn test_Vec3() {
 }
 
 #[test]
-fn test_Vec3_euclidean() {
+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));
+}
+
+#[test]
+fn test_vec3_euclidean() {
     let a = Vec3::new(2f, 3f, 6f); // (2, 3, 6, 7) Pythagorean quadruple
     let b0 = Vec3::new(1f, 4f, 8f); // (1, 4, 8, 9) Pythagorean quadruple
     let b = a.add_v(&b0);
@@ -249,7 +257,7 @@ fn test_Vec3_euclidean() {
 }
 
 #[test]
-fn test_Vec3_boolean() {
+fn test_vec3_boolean() {
     let tft = Vec3::new(true, false, true);
     let fff = Vec3::new(false, false, false);
     let ttt = Vec3::new(true, true, true);
@@ -268,7 +276,7 @@ fn test_Vec3_boolean() {
 }
 
 #[test]
-fn test_Vec4() {
+fn test_vec4() {
     // assert Vec4::dim == 4;
     
     let a = Vec4 { x: 1f, y: 2f, z: 3f, w: 4f };
@@ -345,17 +353,19 @@ fn test_Vec4() {
     assert mut_a == a.sub_v(&b);
     // mut_a = a;
     
-    // exact_eq
-    // fuzzy_eq
-    // eq
-    
     // assert c.abs()        == Vec4::new( 2.0f,  1.0f, 1.0f, 2.0f);
     // assert c.min(&d)      == Vec4::new(-2.0f, -1.0f, 0.5f, 1.0f);
     // assert c.max(&d)      == Vec4::new( 1.0f,  0.0f, 1.0f, 2.0f);
 }
 
 #[test]
-fn test_Vec4_euclidean() {
+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));
+}
+
+#[test]
+fn test_vec4_euclidean() {
     let a = Vec4::new(1f, 2f, 4f, 10f); // (1, 2, 4, 10, 11) Pythagorean quintuple
     let b0 = Vec4::new(1f, 2f, 8f, 10f); // (1, 2, 8, 10, 13) Pythagorean quintuple
     let b = a.add_v(&b0);
@@ -387,7 +397,7 @@ fn test_Vec4_euclidean() {
 }
 
 #[test]
-fn test_Vec4_boolean() {
+fn test_vec4_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);