diff --git a/test/src/test_bezier.c b/test/src/test_bezier.c
index 8c22e65..3089dd5 100644
--- a/test/src/test_bezier.c
+++ b/test/src/test_bezier.c
@@ -49,7 +49,7 @@ TEST_IMPL(bezier) {
   Bs       = glm_bezier(s, p0, c0, c1, p1);
   Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
 
-  ASSERT(glm_eq(Bs,  Bs_plain));
+  ASSERT(test_eq(Bs,  Bs_plain));
   ASSERTIFY(test_assert_eqf(smc, Bs_plain))
   ASSERTIFY(test_assert_eqf(Bs,  smc))
 
@@ -58,9 +58,9 @@ TEST_IMPL(bezier) {
   Bs       = glm_hermite(s, p0, c0, c1, p1);
   Bs_plain = test_hermite_plain(s, p0, c0, c1, p1);
 
-  ASSERT(glm_eq(Bs,  Bs_plain));
-  ASSERT(glm_eq(smc, Bs_plain));
-  ASSERT(glm_eq(Bs,  smc));
+  ASSERT(test_eq(Bs,  Bs_plain));
+  ASSERT(test_eq(smc, Bs_plain));
+  ASSERT(test_eq(Bs,  smc));
   
   TEST_SUCCESS
 }
diff --git a/test/src/test_common.c b/test/src/test_common.c
index 7c808be..5741a37 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -159,9 +159,9 @@ test_assert_mat3_eq_identity(mat3 m3) {
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
       if (i == j) {
-        ASSERT(glm_eq(m3[i][j], 1.0f))
+        ASSERT(test_eq(m3[i][j], 1.0f))
       } else {
-        ASSERT(glm_eq(m3[i][j], 0.0f))
+        ASSERT(test_eq(m3[i][j], 0.0f))
       }
     }
   }
@@ -175,7 +175,7 @@ test_assert_mat3_eq_zero(mat3 m3) {
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      ASSERT(glm_eq(m3[i][j], 0.0f))
+      ASSERT(test_eq(m3[i][j], 0.0f))
     }
   }
 
@@ -189,9 +189,9 @@ test_assert_mat4_eq_identity(mat4 m4) {
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
       if (i == j) {
-        ASSERT(glm_eq(m4[i][j], 1.0f))
+        ASSERT(test_eq(m4[i][j], 1.0f))
       } else {
-        ASSERT(glm_eq(m4[i][j], 0.0f))
+        ASSERT(test_eq(m4[i][j], 0.0f))
       }
     }
   }
@@ -205,7 +205,7 @@ test_assert_mat4_eq_zero(mat4 m4) {
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      ASSERT(glm_eq(m4[i][j], 0.0f))
+      ASSERT(test_eq(m4[i][j], 0.0f))
     }
   }
 
diff --git a/test/src/test_common.h b/test/src/test_common.h
index 2ebe227..a3dee7b 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -82,4 +82,10 @@ test_rand(void);
 void
 test_rand_quat(versor q);
 
+CGLM_INLINE
+bool
+test_eq(float a, float b) {
+  return fabsf(a - b) <= 1e-6;
+}
+
 #endif /* test_common_h */
diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h
index 0659a2e..87947df 100644
--- a/test/src/test_mat3.h
+++ b/test/src/test_mat3.h
@@ -107,7 +107,7 @@ TEST_IMPL(GLM_PREFIX, mat3_mulv) {
   GLM(mat3_mulv)(mat, v, res);
 
   for (i = 0; i < 3; i++) {
-    ASSERT(glm_eq(res[i],
+    ASSERT(test_eq(res[i],
                   v[0] * mat[0][i]
                   + v[1] * mat[1][i]
                   + v[2] * mat[2][i]))
@@ -122,7 +122,7 @@ TEST_IMPL(GLM_PREFIX, mat3_trace) {
 
   trace = GLM(mat3_trace)(mat);
 
-  ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
 
   TEST_SUCCESS
 }
@@ -148,7 +148,7 @@ TEST_IMPL(GLM_PREFIX, mat3_quat) {
 
   GLM(mat4_pick3)(m2, m3);
 
-  ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4))
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4))
   ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
   ASSERTIFY(test_assert_vec4_eq(q1, q2))
   ASSERTIFY(test_assert_mat3_eq(m1, m3))
@@ -192,7 +192,7 @@ TEST_IMPL(GLM_PREFIX, mat3_scale) {
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
       for (k = 0; k < 3; k++)
-        ASSERT(glm_eq(m1[i][j], m2[i][j] * scale))
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
     }
   }
 
@@ -215,7 +215,7 @@ TEST_IMPL(GLM_PREFIX, mat3_det) {
   det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e);
   det2 = GLM(mat3_det)(mat);
 
-  ASSERT(glm_eq(det1, det2))
+  ASSERT(test_eq(det1, det2))
 
   TEST_SUCCESS
 }
@@ -257,31 +257,31 @@ TEST_IMPL(GLM_PREFIX, mat3_swap_row) {
 
   GLM(mat3_swap_row)(m1, 0, 1);
 
-  ASSERT(glm_eq(m1[0][0], m2[0][1]))
-  ASSERT(glm_eq(m1[0][1], m2[0][0]))
-  ASSERT(glm_eq(m1[0][2], m2[0][2]))
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+  ASSERT(test_eq(m1[0][2], m2[0][2]))
 
-  ASSERT(glm_eq(m1[1][0], m2[1][1]))
-  ASSERT(glm_eq(m1[1][1], m2[1][0]))
-  ASSERT(glm_eq(m1[1][2], m2[1][2]))
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+  ASSERT(test_eq(m1[1][2], m2[1][2]))
 
-  ASSERT(glm_eq(m1[2][0], m2[2][1]))
-  ASSERT(glm_eq(m1[2][1], m2[2][0]))
-  ASSERT(glm_eq(m1[2][2], m2[2][2]))
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][0]))
+  ASSERT(test_eq(m1[2][2], m2[2][2]))
 
   GLM(mat3_swap_row)(m1, 1, 2);
 
-  ASSERT(glm_eq(m1[0][0], m2[0][1]))
-  ASSERT(glm_eq(m1[0][1], m2[0][2]))
-  ASSERT(glm_eq(m1[0][2], m2[0][0]))
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][2]))
+  ASSERT(test_eq(m1[0][2], m2[0][0]))
 
-  ASSERT(glm_eq(m1[1][0], m2[1][1]))
-  ASSERT(glm_eq(m1[1][1], m2[1][2]))
-  ASSERT(glm_eq(m1[1][2], m2[1][0]))
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][2]))
+  ASSERT(test_eq(m1[1][2], m2[1][0]))
 
-  ASSERT(glm_eq(m1[2][0], m2[2][1]))
-  ASSERT(glm_eq(m1[2][1], m2[2][2]))
-  ASSERT(glm_eq(m1[2][2], m2[2][0]))
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][2]))
+  ASSERT(test_eq(m1[2][2], m2[2][0]))
 
   TEST_SUCCESS
 }
@@ -303,7 +303,7 @@ TEST_IMPL(GLM_PREFIX, mat3_rmc) {
 
   r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2];
 
-  ASSERT(glm_eq(r1, r2))
+  ASSERT(test_eq(r1, r2))
 
   TEST_SUCCESS
 }
diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h
index db95167..9463714 100644
--- a/test/src/test_mat4.h
+++ b/test/src/test_mat4.h
@@ -117,10 +117,10 @@ TEST_IMPL(GLM_PREFIX, mat4_ins3) {
     }
   }
 
-  ASSERT(glm_eq(m1[3][0], 0.0f))
-  ASSERT(glm_eq(m1[3][1], 0.0f))
-  ASSERT(glm_eq(m1[3][2], 0.0f))
-  ASSERT(glm_eq(m1[3][3], 1.0f))
+  ASSERT(test_eq(m1[3][0], 0.0f))
+  ASSERT(test_eq(m1[3][1], 0.0f))
+  ASSERT(test_eq(m1[3][2], 0.0f))
+  ASSERT(test_eq(m1[3][3], 1.0f))
 
   TEST_SUCCESS
 }
@@ -184,7 +184,7 @@ TEST_IMPL(GLM_PREFIX, mat4_mulv) {
   GLM(mat4_mulv)(mat, v, res);
 
   for (i = 0; i < 4; i++) {
-    ASSERT(glm_eq(res[i],
+    ASSERT(test_eq(res[i],
                   v[0] * mat[0][i]
                 + v[1] * mat[1][i]
                 + v[2] * mat[2][i]
@@ -206,7 +206,7 @@ TEST_IMPL(GLM_PREFIX, mat4_mulv3) {
   GLM(mat4_mulv3)(mat, v, last, res);
 
   for (i = 0; i < 3; i++) {
-    ASSERT(glm_eq(res[i],
+    ASSERT(test_eq(res[i],
                   v[0] * mat[0][i]
                   + v[1] * mat[1][i]
                   + v[2] * mat[2][i]
@@ -222,7 +222,7 @@ TEST_IMPL(GLM_PREFIX, mat4_trace) {
 
   trace = GLM(mat4_trace)(mat);
 
-  ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3]))
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3]))
 
   TEST_SUCCESS
 }
@@ -233,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, mat4_trace3) {
 
   trace = GLM(mat4_trace3)(mat);
 
-  ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
 
   TEST_SUCCESS
 }
@@ -256,7 +256,7 @@ TEST_IMPL(GLM_PREFIX, mat4_quat) {
   GLM(vec3_normalize)(axis1);
   GLM(vec3_normalize)(axis2);
   
-  ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4))
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4))
   ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
   ASSERTIFY(test_assert_vec4_eq(q1, q2))
   ASSERTIFY(test_assert_mat4_eq(m1, m2))
@@ -300,7 +300,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale_p) {
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
       for (k = 0; k < 4; k++)
-        ASSERT(glm_eq(m1[i][j], m2[i][j] * scale))
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
     }
   }
 
@@ -319,7 +319,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale) {
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
       for (k = 0; k < 4; k++)
-        ASSERT(glm_eq(m1[i][j], m2[i][j] * scale))
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
     }
   }
 
@@ -356,7 +356,7 @@ TEST_IMPL(GLM_PREFIX, mat4_det) {
 
   det2 = GLM(mat4_det(mat));
 
-  ASSERT(glm_eq(det1, det2))
+  ASSERT(test_eq(det1, det2))
 
   TEST_SUCCESS
 }
@@ -441,22 +441,22 @@ TEST_IMPL(GLM_PREFIX, mat4_swap_row) {
   GLM(mat4_swap_row)(m1, 0, 1);
   GLM(mat4_swap_row)(m1, 2, 3);
   
-  ASSERT(glm_eq(m1[0][0], m2[0][1]))
-  ASSERT(glm_eq(m1[0][1], m2[0][0]))
-  ASSERT(glm_eq(m1[0][2], m2[0][3]))
-  ASSERT(glm_eq(m1[0][3], m2[0][2]))
-  ASSERT(glm_eq(m1[1][0], m2[1][1]))
-  ASSERT(glm_eq(m1[1][1], m2[1][0]))
-  ASSERT(glm_eq(m1[1][2], m2[1][3]))
-  ASSERT(glm_eq(m1[1][3], m2[1][2]))
-  ASSERT(glm_eq(m1[2][0], m2[2][1]))
-  ASSERT(glm_eq(m1[2][1], m2[2][0]))
-  ASSERT(glm_eq(m1[2][2], m2[2][3]))
-  ASSERT(glm_eq(m1[2][3], m2[2][2]))
-  ASSERT(glm_eq(m1[3][0], m2[3][1]))
-  ASSERT(glm_eq(m1[3][1], m2[3][0]))
-  ASSERT(glm_eq(m1[3][2], m2[3][3]))
-  ASSERT(glm_eq(m1[3][3], m2[3][2]))
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+  ASSERT(test_eq(m1[0][2], m2[0][3]))
+  ASSERT(test_eq(m1[0][3], m2[0][2]))
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+  ASSERT(test_eq(m1[1][2], m2[1][3]))
+  ASSERT(test_eq(m1[1][3], m2[1][2]))
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][0]))
+  ASSERT(test_eq(m1[2][2], m2[2][3]))
+  ASSERT(test_eq(m1[2][3], m2[2][2]))
+  ASSERT(test_eq(m1[3][0], m2[3][1]))
+  ASSERT(test_eq(m1[3][1], m2[3][0]))
+  ASSERT(test_eq(m1[3][2], m2[3][3]))
+  ASSERT(test_eq(m1[3][3], m2[3][2]))
 
   TEST_SUCCESS
 }
@@ -479,7 +479,7 @@ TEST_IMPL(GLM_PREFIX, mat4_rmc) {
   
   r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2] + v[3] * v1[3];
 
-  ASSERT(glm_eq(r1, r2))
+  ASSERT(test_eq(r1, r2))
 
   TEST_SUCCESS
 }
diff --git a/test/src/test_project.h b/test/src/test_project.h
index 3add32b..41bdecd 100644
--- a/test/src/test_project.h
+++ b/test/src/test_project.h
@@ -84,9 +84,9 @@ TEST_IMPL(GLM_PREFIX, project) {
   GLM(project)(pos, mvp, viewport, projected);
   GLM(unproject)(projected, mvp, viewport, unprojected);
 
-  ASSERT(glm_eq(pos[0], unprojected[0]))
-  ASSERT(glm_eq(pos[1], unprojected[1]))
-  ASSERT(glm_eq(pos[2], unprojected[2]))
+  ASSERT(test_eq(pos[0], unprojected[0]))
+  ASSERT(test_eq(pos[1], unprojected[1]))
+  ASSERT(test_eq(pos[2], unprojected[2]))
 
   TEST_SUCCESS
 }
diff --git a/test/src/test_quat.c b/test/src/test_quat.c
index 44725ee..98bd8a1 100644
--- a/test/src/test_quat.c
+++ b/test/src/test_quat.c
@@ -24,7 +24,7 @@ TEST_IMPL(quat) {
 
   /* 0. test identiy quat */
   glm_quat_identity(q4);
-  ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
+  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
 
   glm_quat_mat4(q4, rot1);
   ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f))
@@ -121,7 +121,7 @@ TEST_IMPL(quat) {
   /* 9. test imag, real */
 
   /* 9.1 real */
-  ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)))
+  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)))
 
   /* 9.1 imag */
   glm_quat_imag(q4, imag);
diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h
index 227fa18..3c4edfa 100644
--- a/test/src/test_vec3.h
+++ b/test/src/test_vec3.h
@@ -17,9 +17,9 @@
 TEST_IMPL(MACRO_GLM_VEC3_ONE_INIT) {
   vec3 v = GLM_VEC3_ONE_INIT;
   
-  ASSERT(glm_eq(v[0], 1.0f))
-  ASSERT(glm_eq(v[1], 1.0f))
-  ASSERT(glm_eq(v[2], 1.0f))
+  ASSERT(test_eq(v[0], 1.0f))
+  ASSERT(test_eq(v[1], 1.0f))
+  ASSERT(test_eq(v[2], 1.0f))
   
   TEST_SUCCESS
 }
@@ -27,49 +27,49 @@ TEST_IMPL(MACRO_GLM_VEC3_ONE_INIT) {
 TEST_IMPL(MACRO_GLM_VEC3_ZERO_INIT) {
   vec3 v = GLM_VEC3_ZERO_INIT;
   
-  ASSERT(glm_eq(v[0], 0.0f))
-  ASSERT(glm_eq(v[1], 0.0f))
-  ASSERT(glm_eq(v[2], 0.0f))
+  ASSERT(test_eq(v[0], 0.0f))
+  ASSERT(test_eq(v[1], 0.0f))
+  ASSERT(test_eq(v[2], 0.0f))
   
   TEST_SUCCESS
 }
 
 TEST_IMPL(MACRO_GLM_VEC3_ONE) {
-  ASSERT(glm_eq(GLM_VEC3_ONE[0], 1.0f))
-  ASSERT(glm_eq(GLM_VEC3_ONE[1], 1.0f))
-  ASSERT(glm_eq(GLM_VEC3_ONE[2], 1.0f))
+  ASSERT(test_eq(GLM_VEC3_ONE[0], 1.0f))
+  ASSERT(test_eq(GLM_VEC3_ONE[1], 1.0f))
+  ASSERT(test_eq(GLM_VEC3_ONE[2], 1.0f))
   
   TEST_SUCCESS
 }
 
 TEST_IMPL(MACRO_GLM_VEC3_ZERO) {
-  ASSERT(glm_eq(GLM_VEC3_ZERO[0], 0.0f))
-  ASSERT(glm_eq(GLM_VEC3_ZERO[1], 0.0f))
-  ASSERT(glm_eq(GLM_VEC3_ZERO[2], 0.0f))
+  ASSERT(test_eq(GLM_VEC3_ZERO[0], 0.0f))
+  ASSERT(test_eq(GLM_VEC3_ZERO[1], 0.0f))
+  ASSERT(test_eq(GLM_VEC3_ZERO[2], 0.0f))
   
   TEST_SUCCESS
 }
 
 TEST_IMPL(MACRO_GLM_YUP) {
-  ASSERT(glm_eq(GLM_YUP[0], 0.0f))
-  ASSERT(glm_eq(GLM_YUP[1], 1.0f))
-  ASSERT(glm_eq(GLM_YUP[2], 0.0f))
+  ASSERT(test_eq(GLM_YUP[0], 0.0f))
+  ASSERT(test_eq(GLM_YUP[1], 1.0f))
+  ASSERT(test_eq(GLM_YUP[2], 0.0f))
   
   TEST_SUCCESS
 }
 
 TEST_IMPL(MACRO_GLM_ZUP) {
-  ASSERT(glm_eq(GLM_ZUP[0], 0.0f))
-  ASSERT(glm_eq(GLM_ZUP[1], 0.0f))
-  ASSERT(glm_eq(GLM_ZUP[2], 1.0f))
+  ASSERT(test_eq(GLM_ZUP[0], 0.0f))
+  ASSERT(test_eq(GLM_ZUP[1], 0.0f))
+  ASSERT(test_eq(GLM_ZUP[2], 1.0f))
   
   TEST_SUCCESS
 }
 
 TEST_IMPL(MACRO_GLM_XUP) {
-  ASSERT(glm_eq(GLM_XUP[0], 1.0f))
-  ASSERT(glm_eq(GLM_XUP[1], 0.0f))
-  ASSERT(glm_eq(GLM_XUP[2], 0.0f))
+  ASSERT(test_eq(GLM_XUP[0], 1.0f))
+  ASSERT(test_eq(GLM_XUP[1], 0.0f))
+  ASSERT(test_eq(GLM_XUP[2], 0.0f))
   
   TEST_SUCCESS
 }
@@ -182,9 +182,9 @@ TEST_IMPL(MACRO_glm_vec3_mulv) {
 
   ASSERTIFY(test_assert_vec3_eq(v3, v4))
 
-  ASSERT(glm_eq(v1[0] * v2[0], v3[0]))
-  ASSERT(glm_eq(v1[1] * v2[1], v3[1]))
-  ASSERT(glm_eq(v1[2] * v2[2], v3[2]))
+  ASSERT(test_eq(v1[0] * v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] * v2[1], v3[1]))
+  ASSERT(test_eq(v1[2] * v2[2], v3[2]))
   
   TEST_SUCCESS
 }
@@ -199,9 +199,9 @@ TEST_IMPL(GLM_PREFIX, vec3) {
   
   GLM(vec3)(v4, v3);
   
-  ASSERT(glm_eq(v3[0], v4[0]))
-  ASSERT(glm_eq(v3[1], v4[1]))
-  ASSERT(glm_eq(v3[2], v4[2]))
+  ASSERT(test_eq(v3[0], v4[0]))
+  ASSERT(test_eq(v3[1], v4[1]))
+  ASSERT(test_eq(v3[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -251,7 +251,7 @@ TEST_IMPL(GLM_PREFIX, vec3_dot) {
   dot1 = GLM(vec3_dot)(a, b);
   dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
   
-  ASSERT(glm_eq(dot1, dot2))
+  ASSERT(test_eq(dot1, dot2))
   
   TEST_SUCCESS
 }
@@ -263,7 +263,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm2) {
   n1 = GLM(vec3_norm2)(a);
   n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
 
-  ASSERT(glm_eq(n1, n2))
+  ASSERT(test_eq(n1, n2))
 
   TEST_SUCCESS
 }
@@ -275,7 +275,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm) {
   n1 = GLM(vec3_norm)(a);
   n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
 
-  ASSERT(glm_eq(n1, n2))
+  ASSERT(test_eq(n1, n2))
 
   TEST_SUCCESS
 }
@@ -287,7 +287,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_one) {
   n1 = GLM(vec3_norm_one)(a);
   n2 = fabsf(a[0]) + fabsf(a[1]) + fabsf(a[2]);
 
-  ASSERT(glm_eq(n1, n2))
+  ASSERT(test_eq(n1, n2))
 
   TEST_SUCCESS
 }
@@ -305,7 +305,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
   if (fabsf(a[1]) < fabsf(a[2]))
     n2 = fabsf(a[2]);
   
-  ASSERT(glm_eq(n1, n2))
+  ASSERT(test_eq(n1, n2))
 
   TEST_SUCCESS
 }
@@ -381,9 +381,9 @@ TEST_IMPL(GLM_PREFIX, vec3_mul) {
   
   GLM(vec3_mul)(v1, v2, v3);
 
-  ASSERT(glm_eq(v1[0] * v2[0], v3[0]))
-  ASSERT(glm_eq(v1[1] * v2[1], v3[1]))
-  ASSERT(glm_eq(v1[2] * v2[2], v3[2]))
+  ASSERT(test_eq(v1[0] * v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] * v2[1], v3[1]))
+  ASSERT(test_eq(v1[2] * v2[2], v3[2]))
   
   TEST_SUCCESS
 }
@@ -394,9 +394,9 @@ TEST_IMPL(GLM_PREFIX, vec3_scale) {
   
   GLM(vec3_scale)(v1, s, v2);
 
-  ASSERT(glm_eq(v1[0] * s, v2[0]))
-  ASSERT(glm_eq(v1[1] * s, v2[1]))
-  ASSERT(glm_eq(v1[2] * s, v2[2]))
+  ASSERT(test_eq(v1[0] * s, v2[0]))
+  ASSERT(test_eq(v1[1] * s, v2[1]))
+  ASSERT(test_eq(v1[2] * s, v2[2]))
   
   TEST_SUCCESS
 }
@@ -410,18 +410,18 @@ TEST_IMPL(GLM_PREFIX, vec3_scale_as) {
 
   norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]);
   if (norm == 0.0f) {
-    ASSERT(glm_eq(v1[0], 0.0f))
-    ASSERT(glm_eq(v1[1], 0.0f))
-    ASSERT(glm_eq(v1[2], 0.0f))
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+    ASSERT(test_eq(v1[2], 0.0f))
 
     TEST_SUCCESS
   }
   
   norm = s / norm;
   
-  ASSERT(glm_eq(v1[0] * norm, v2[0]))
-  ASSERT(glm_eq(v1[1] * norm, v2[1]))
-  ASSERT(glm_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
 
   TEST_SUCCESS
 }
@@ -433,9 +433,9 @@ TEST_IMPL(GLM_PREFIX, vec3_div) {
   
   GLM(vec3_div)(v1, v2, v3);
 
-  ASSERT(glm_eq(v1[0] / v2[0], v3[0]))
-  ASSERT(glm_eq(v1[1] / v2[1], v3[1]))
-  ASSERT(glm_eq(v1[2] / v2[2], v3[2]))
+  ASSERT(test_eq(v1[0] / v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] / v2[1], v3[1]))
+  ASSERT(test_eq(v1[2] / v2[2], v3[2]))
   
   TEST_SUCCESS
 }
@@ -446,9 +446,9 @@ TEST_IMPL(GLM_PREFIX, vec3_divs) {
   
   GLM(vec3_divs)(v1, s, v2);
 
-  ASSERT(glm_eq(v1[0] / s, v2[0]))
-  ASSERT(glm_eq(v1[1] / s, v2[1]))
-  ASSERT(glm_eq(v1[2] / s, v2[2]))
+  ASSERT(test_eq(v1[0] / s, v2[0]))
+  ASSERT(test_eq(v1[1] / s, v2[1]))
+  ASSERT(test_eq(v1[2] / s, v2[2]))
   
   TEST_SUCCESS
 }
@@ -461,9 +461,9 @@ TEST_IMPL(GLM_PREFIX, vec3_addadd) {
   
   GLM(vec3_addadd)(v1, v2, v4);
 
-  ASSERT(glm_eq(v3[0] + v1[0] + v2[0], v4[0]))
-  ASSERT(glm_eq(v3[1] + v1[1] + v2[1], v4[1]))
-  ASSERT(glm_eq(v3[2] + v1[2] + v2[2], v4[2]))
+  ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1]))
+  ASSERT(test_eq(v3[2] + v1[2] + v2[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -476,9 +476,9 @@ TEST_IMPL(GLM_PREFIX, vec3_subadd) {
   
   GLM(vec3_subadd)(v1, v2, v4);
 
-  ASSERT(glm_eq(v3[0] + v1[0] - v2[0], v4[0]))
-  ASSERT(glm_eq(v3[1] + v1[1] - v2[1], v4[1]))
-  ASSERT(glm_eq(v3[2] + v1[2] - v2[2], v4[2]))
+  ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1]))
+  ASSERT(test_eq(v3[2] + v1[2] - v2[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -491,9 +491,9 @@ TEST_IMPL(GLM_PREFIX, vec3_muladd) {
   
   GLM(vec3_muladd)(v1, v2, v4);
 
-  ASSERT(glm_eq(v3[0] + v1[0] * v2[0], v4[0]))
-  ASSERT(glm_eq(v3[1] + v1[1] * v2[1], v4[1]))
-  ASSERT(glm_eq(v3[2] + v1[2] * v2[2], v4[2]))
+  ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1]))
+  ASSERT(test_eq(v3[2] + v1[2] * v2[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -506,9 +506,9 @@ TEST_IMPL(GLM_PREFIX, vec3_muladds) {
   
   GLM(vec3_muladds)(v1, s, v3);
 
-  ASSERT(glm_eq(v2[0] + v1[0] * s, v3[0]))
-  ASSERT(glm_eq(v2[1] + v1[1] * s, v3[1]))
-  ASSERT(glm_eq(v2[2] + v1[2] * s, v3[2]))
+  ASSERT(test_eq(v2[0] + v1[0] * s, v3[0]))
+  ASSERT(test_eq(v2[1] + v1[1] * s, v3[1]))
+  ASSERT(test_eq(v2[2] + v1[2] * s, v3[2]))
   
   TEST_SUCCESS
 }
@@ -521,9 +521,9 @@ TEST_IMPL(GLM_PREFIX, vec3_maxadd) {
   
   GLM(vec3_maxadd)(v1, v2, v4);
 
-  ASSERT(glm_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0]))
-  ASSERT(glm_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1]))
-  ASSERT(glm_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2]))
+  ASSERT(test_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0]))
+  ASSERT(test_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1]))
+  ASSERT(test_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2]))
   
   TEST_SUCCESS
 }
@@ -536,9 +536,9 @@ TEST_IMPL(GLM_PREFIX, vec3_minadd) {
   
   GLM(vec3_minadd)(v1, v2, v4);
 
-  ASSERT(glm_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0]))
-  ASSERT(glm_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1]))
-  ASSERT(glm_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2]))
+  ASSERT(test_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0]))
+  ASSERT(test_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1]))
+  ASSERT(test_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2]))
   
   TEST_SUCCESS
 }
@@ -551,13 +551,13 @@ TEST_IMPL(GLM_PREFIX, vec3_negate_to) {
   GLM(vec3_negate_to)(v1, v3);
   GLM(vec3_negate_to)(v2, v4);
 
-  ASSERT(glm_eq(-v1[0], v3[0]))
-  ASSERT(glm_eq(-v1[1], v3[1]))
-  ASSERT(glm_eq(-v1[2], v3[2]))
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  ASSERT(test_eq(-v1[2], v3[2]))
   
-  ASSERT(glm_eq(-v2[0], v4[0]))
-  ASSERT(glm_eq(-v2[1], v4[1]))
-  ASSERT(glm_eq(-v2[2], v4[2]))
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  ASSERT(test_eq(-v2[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -571,13 +571,13 @@ TEST_IMPL(GLM_PREFIX, vec3_negate) {
   GLM(vec3_negate)(v1);
   GLM(vec3_negate)(v2);
 
-  ASSERT(glm_eq(-v1[0], v3[0]))
-  ASSERT(glm_eq(-v1[1], v3[1]))
-  ASSERT(glm_eq(-v1[2], v3[2]))
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  ASSERT(test_eq(-v1[2], v3[2]))
   
-  ASSERT(glm_eq(-v2[0], v4[0]))
-  ASSERT(glm_eq(-v2[1], v4[1]))
-  ASSERT(glm_eq(-v2[2], v4[2]))
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  ASSERT(test_eq(-v2[2], v4[2]))
   
   TEST_SUCCESS
 }
@@ -591,18 +591,18 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize) {
 
   norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]);
   if (norm == 0.0f) {
-    ASSERT(glm_eq(v1[0], 0.0f))
-    ASSERT(glm_eq(v1[1], 0.0f))
-    ASSERT(glm_eq(v1[2], 0.0f))
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+    ASSERT(test_eq(v1[2], 0.0f))
 
     TEST_SUCCESS
   }
   
   norm = s / norm;
   
-  ASSERT(glm_eq(v1[0] * norm, v2[0]))
-  ASSERT(glm_eq(v1[1] * norm, v2[1]))
-  ASSERT(glm_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
 
   TEST_SUCCESS
 }
@@ -616,18 +616,18 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize_to) {
 
   norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]);
   if (norm == 0.0f) {
-    ASSERT(glm_eq(v1[0], 0.0f))
-    ASSERT(glm_eq(v1[1], 0.0f))
-    ASSERT(glm_eq(v1[2], 0.0f))
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+    ASSERT(test_eq(v1[2], 0.0f))
 
     TEST_SUCCESS
   }
   
   norm = s / norm;
   
-  ASSERT(glm_eq(v1[0] * norm, v2[0]))
-  ASSERT(glm_eq(v1[1] * norm, v2[1]))
-  ASSERT(glm_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
 
   TEST_SUCCESS
 }
@@ -793,12 +793,12 @@ TEST_IMPL(GLM_PREFIX, vec3_max) {
   vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f};
   vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f};
 
-  ASSERT(glm_eq(GLM(vec3_max)(v1),  2.104f))
-  ASSERT(glm_eq(GLM(vec3_max)(v2), -12.35f))
+  ASSERT(test_eq(GLM(vec3_max)(v1),  2.104f))
+  ASSERT(test_eq(GLM(vec3_max)(v2), -12.35f))
   ASSERT(isinf(GLM(vec3_max)(v3)))
   ASSERT(isnan(GLM(vec3_max)(v4)))
   ASSERT(isnan(GLM(vec3_max)(v5)))
-  ASSERT(glm_eq(GLM(vec3_max)(v6),  11.0f))
+  ASSERT(test_eq(GLM(vec3_max)(v6),  11.0f))
 
   TEST_SUCCESS
 }
@@ -808,12 +808,12 @@ TEST_IMPL(GLM_PREFIX, vec3_min) {
   vec3  v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f};
   vec3  v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f};
 
-  ASSERT(glm_eq(GLM(vec3_min)(v1), -4.10f))
-  ASSERT(glm_eq(GLM(vec3_min)(v2), -43.502f))
-  ASSERT(glm_eq(GLM(vec3_min)(v3),  0.0f))
+  ASSERT(test_eq(GLM(vec3_min)(v1), -4.10f))
+  ASSERT(test_eq(GLM(vec3_min)(v2), -43.502f))
+  ASSERT(test_eq(GLM(vec3_min)(v3),  0.0f))
   ASSERT(isnan(GLM(vec3_min)(v4)))
   ASSERT(isnan(GLM(vec3_min)(v5)))
-  ASSERT(glm_eq(GLM(vec3_min)(v6), -11.0f))
+  ASSERT(test_eq(GLM(vec3_min)(v6), -11.0f))
 
   TEST_SUCCESS
 }
@@ -914,8 +914,8 @@ TEST_IMPL(GLM_PREFIX, vec3_hadd) {
   r3 = v1[0] + v1[1] + v1[2];
   r4 = v2[0] + v2[1] + v2[2];
 
-  ASSERT(glm_eq(r1, r3))
-  ASSERT(glm_eq(r2, r4))
+  ASSERT(test_eq(r1, r3))
+  ASSERT(test_eq(r2, r4))
 
   TEST_SUCCESS
 }
@@ -926,13 +926,13 @@ TEST_IMPL(GLM_PREFIX, vec3_sqrt) {
   GLM(vec3_sqrt)(v1, v3);
   GLM(vec3_sqrt)(v2, v4);
 
-  ASSERT(glm_eq(sqrtf(v1[0]), v3[0]))
-  ASSERT(glm_eq(sqrtf(v1[1]), v3[1]))
-  ASSERT(glm_eq(sqrtf(v1[2]), v3[2]))
+  ASSERT(test_eq(sqrtf(v1[0]), v3[0]))
+  ASSERT(test_eq(sqrtf(v1[1]), v3[1]))
+  ASSERT(test_eq(sqrtf(v1[2]), v3[2]))
 
-  ASSERT(glm_eq(sqrtf(v2[0]), v4[0]))
-  ASSERT(glm_eq(sqrtf(v2[1]), v4[1]))
-  ASSERT(glm_eq(sqrtf(v2[2]), v4[2]))
+  ASSERT(test_eq(sqrtf(v2[0]), v4[0]))
+  ASSERT(test_eq(sqrtf(v2[1]), v4[1]))
+  ASSERT(test_eq(sqrtf(v2[2]), v4[2]))
 
   TEST_SUCCESS
 }