tests: add more tests for mat4

test/include/common.h

@@ -51,6 +51,13 @@ typedef struct test_entry_t {
 #define TEST_ENTRY(FUN)   { #FUN, test_ ## FUN, 0, 0 },
 #define TEST_LIST         static test_entry_t tests[] = 
 
+#define TEST_OK 1
+#define TEST_SUCCESS  return (test_status_t){NULL, TEST_OK};
+
+#define TEST_IMPL(FUN)                                                        \
+  test_status_t test_ ## FUN (void);                                          \
+  test_status_t test_ ## FUN()
+
 #define ASSERT_EXT(expr, msg)                                                 \
   if (!(expr)) {                                                              \
     fprintf(stderr,                                                           \
@@ -73,7 +80,7 @@ typedef struct test_entry_t {
 #define ASSERTIFY(expr) do {                                                  \
     test_status_t ts; \
     ts = expr; \
-    if (ts.status != 1) {                                                     \
+    if (ts.status != TEST_OK) {                                               \
       fprintf(stderr,                                                         \
               RED "  assert fail" RESET                                       \
               " in " BOLDCYAN "%s " RESET                                     \
@@ -86,13 +93,6 @@ typedef struct test_entry_t {
     } \
   } while(0);
 
-#define TEST_OK 1
-#define TEST_SUCCESS  return (test_status_t){NULL, TEST_OK};
-
-#define TEST_IMPL(FUN)                                                        \
-  test_status_t test_ ## FUN (void);                                          \
-  test_status_t test_ ## FUN()
-
 #if defined(_WIN32)
 # define drand48() ((float)(rand() / (RAND_MAX + 1.0)))
 # define OK_TEXT "ok:"

test/src/test_common.c

@@ -124,6 +124,50 @@ test_assert_mat3_eq(mat3 m1, mat3 m2) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat3_eqt(mat3 m1, mat3 m2) {
+  int i, j, k;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 3; k++)
+        ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4_eq_identity(mat4 m4) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      if (i == j) {
+        ASSERT(glm_eq(m4[i][j], 1.0f))
+      } else {
+        ASSERT(glm_eq(m4[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4_eq_zero(mat4 m4) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(glm_eq(m4[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_eqf(float a, float b) {
   ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */

test/src/test_common.h

@@ -25,9 +25,18 @@ test_assert_mat4_eq(mat4 m1, mat4 m2);
 test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
 
+test_status_t
+test_assert_mat4_eq_identity(mat4 m4);
+
+test_status_t
+test_assert_mat4_eq_zero(mat4 m4);
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
+test_status_t
+test_assert_mat3_eqt(mat3 m1, mat3 m2);
+
 test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 

test/src/test_mat4.c

@@ -10,58 +10,209 @@
 #define m 4
 #define n 4
 
-TEST_IMPL(mat4_identity) {
+#define A_MATRIX  {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
-  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+#define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}}
+
+TEST_IMPL(glm_mat4_ucopy) {
+  mat4 m1 = A_MATRIX;
   mat4 m2 = GLM_MAT4_IDENTITY_INIT;
-  mat4 m3;
+
-  int  i, j;
+  glm_mat4_ucopy(m1, m2);
-  
+
-  /* test identity matrix multiplication */
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
-  glm_mat4_mul(m1, m2, m3);
+
-  for (i = 0; i < m; i++) {
-    for (j = 0; j < n; j++) {
-      if (i == j) {
-        ASSERT(glm_eq(m3[i][j], 1.0f))
-      } else {
-        ASSERT(glm_eq(m3[i][j], 0.0f))
-      }
-    }
-  }
-  
   TEST_SUCCESS
 }
 
-TEST_IMPL(mat4_mul) {
+TEST_IMPL(glm_mat4_copy) {
-  mat4  m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m1 = A_MATRIX;
-  mat4  m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
-  mat4  m3;
+
-  mat4  m4 = GLM_MAT4_ZERO_INIT;
+  glm_mat4_copy(m1, m2);
-  int   i, j, k;
+
-  
+  test_assert_mat4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_identity) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+
+  glm_mat4_identity(m3);
+
+  ASSERTIFY(test_assert_mat4_eq_identity(m1))
+  ASSERTIFY(test_assert_mat4_eq_identity(m2))
+  ASSERTIFY(test_assert_mat4_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_identity_array) {
+  int i, count;
+  mat4 matrices[4] = {
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX
+  };
+
+  count = 4;
+
+  glm_mat4_identity_array(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat4_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_zero) {
+  mat4 m1 = GLM_MAT4_ZERO_INIT;
+  mat4 m2 = GLM_MAT4_ZERO_INIT;
+  mat4 m3;
+
+  glm_mat4_zero(m3);
+
+  ASSERTIFY(test_assert_mat4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_pick3) {
+  mat4 m1 = A_MATRIX;
+  mat3 m2 = GLM_MAT3_ZERO_INIT;
+  mat3 m3 = A_MATRIX3;
+
+  glm_mat4_pick3(m1, m2);
+
+  ASSERTIFY(test_assert_mat3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_pick3t) {
+  mat4 m1 = A_MATRIX;
+  mat3 m2 = GLM_MAT3_ZERO_INIT;
+  mat3 m3 = A_MATRIX3;
+
+  glm_mat4_pick3t(m1, m2);
+
+  ASSERTIFY(test_assert_mat3_eqt(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_ins3) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat3 m2 = A_MATRIX3;
+  int i, j;
+
+  glm_mat4_ins3(m2, m1);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(m1[i][j] == m2[i][j])
+    }
+  }
+
+  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))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_mul) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  int  i, j, k;
+
   /* test random matrices */
   /* random matrices */
   test_rand_mat4(m1);
   test_rand_mat4(m2);
-  
+
   glm_mat4_mul(m1, m2, m3);
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
       for (k = 0; k < m; k++)
-      /* column-major */
+        /* column-major */
         m4[i][j] += m1[k][j] * m2[i][k];
     }
   }
-  
+
-  ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK)
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
-  
+
   /* test pre compiled */
   glmc_mat4_mul(m1, m2, m3);
-  ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK)
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
-  
+
   TEST_SUCCESS
 }
 
-TEST_IMPL(mat4_all) {
+TEST_IMPL(glm_mat4_mulN) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_mulv) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_mulv3) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_trace) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_trace3) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_quat) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_transpose_to) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_transpose) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_scale_p) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_scale) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_det) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+
+  test_rand_mat4(m1);
+
+  /* test determinant */
+  ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1))
+#if defined( __SSE2__ )
+  ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1))
+#endif
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_inv) {
   mat4 m1 = GLM_MAT4_IDENTITY_INIT;
   mat4 m3;
   mat4 m4 = GLM_MAT4_ZERO_INIT;
@@ -71,33 +222,33 @@ TEST_IMPL(mat4_all) {
   for (i = 0; i < 100000; i++) {
     test_rand_mat4(m3);
     test_rand_mat4(m4);
-    
+
     /* test inverse precise */
-    glm_mat4_inv_precise(m3, m4);
+    glm_mat4_inv(m3, m4);
-    glm_mat4_inv_precise(m4, m5);
+    glm_mat4_inv(m4, m5);
-    ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK)
+    ASSERTIFY(test_assert_mat4_eq(m3, m5))
-    
+
     test_rand_mat4(m3);
     test_rand_mat4(m4);
 
     glmc_mat4_inv_precise(m3, m4);
     glmc_mat4_inv_precise(m4, m5);
-    ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK)
+    ASSERTIFY(test_assert_mat4_eq(m3, m5))
-    
+
     /* test inverse rcp */
     test_rand_mat4(m3);
     test_rand_mat4(m4);
-    
+
     glm_mat4_inv_fast(m3, m4);
     glm_mat4_inv_fast(m4, m5);
-    ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK)
+    ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f))
-    
+
     test_rand_mat4(m3);
     test_rand_mat4(m4);
-    
+
     glmc_mat4_inv(m3, m4);
     glmc_mat4_inv(m4, m5);
-    ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK)
+    ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f))
   }
 
   /* test determinant */
@@ -105,6 +256,22 @@ TEST_IMPL(mat4_all) {
 #if defined( __SSE2__ )
   ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1))
 #endif
-  
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_inv_fast) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_swap_col) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_swap_row) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(glm_mat4_rmc) {
   TEST_SUCCESS
 }

test/tests.h

@@ -17,9 +17,32 @@
  */
 
 /* mat4 */
-TEST_DECLARE(mat4_identity)
+TEST_DECLARE(glm_mat4_ucopy)
-TEST_DECLARE(mat4_mul)
+TEST_DECLARE(glm_mat4_copy)
-TEST_DECLARE(mat4_all)
+TEST_DECLARE(glm_mat4_identity)
+TEST_DECLARE(glm_mat4_identity_array)
+TEST_DECLARE(glm_mat4_zero)
+TEST_DECLARE(glm_mat4_pick3)
+TEST_DECLARE(glm_mat4_pick3t)
+TEST_DECLARE(glm_mat4_ins3)
+TEST_DECLARE(glm_mat4_mul)
+TEST_DECLARE(glm_mat4_mulN)
+TEST_DECLARE(glm_mat4_mulv)
+TEST_DECLARE(glm_mat4_mulv3)
+TEST_DECLARE(glm_mat4_trace)
+TEST_DECLARE(glm_mat4_trace3)
+TEST_DECLARE(glm_mat4_quat)
+TEST_DECLARE(glm_mat4_transpose_to)
+TEST_DECLARE(glm_mat4_transpose)
+TEST_DECLARE(glm_mat4_scale_p)
+TEST_DECLARE(glm_mat4_scale)
+TEST_DECLARE(glm_mat4_det)
+TEST_DECLARE(glm_mat4_inv)
+TEST_DECLARE(glm_mat4_inv_fast)
+TEST_DECLARE(glm_mat4_swap_col)
+TEST_DECLARE(glm_mat4_swap_row)
+TEST_DECLARE(glm_mat4_rmc)
+
 
 TEST_DECLARE(affine)
 
@@ -57,9 +80,31 @@ TEST_DECLARE(vec4)
 
 TEST_LIST {
   /* mat4 */
-  TEST_ENTRY(mat4_identity)
+  TEST_ENTRY(glm_mat4_ucopy)
-  TEST_ENTRY(mat4_mul)
+  TEST_ENTRY(glm_mat4_copy)
-  TEST_ENTRY(mat4_all)
+  TEST_ENTRY(glm_mat4_identity)
+  TEST_ENTRY(glm_mat4_identity_array)
+  TEST_ENTRY(glm_mat4_zero)
+  TEST_ENTRY(glm_mat4_pick3)
+  TEST_ENTRY(glm_mat4_pick3t)
+  TEST_ENTRY(glm_mat4_ins3)
+  TEST_ENTRY(glm_mat4_mul)
+  TEST_ENTRY(glm_mat4_mulN)
+  TEST_ENTRY(glm_mat4_mulv)
+  TEST_ENTRY(glm_mat4_mulv3)
+  TEST_ENTRY(glm_mat4_trace)
+  TEST_ENTRY(glm_mat4_trace3)
+  TEST_ENTRY(glm_mat4_quat)
+  TEST_ENTRY(glm_mat4_transpose_to)
+  TEST_ENTRY(glm_mat4_transpose)
+  TEST_ENTRY(glm_mat4_scale_p)
+  TEST_ENTRY(glm_mat4_scale)
+  TEST_ENTRY(glm_mat4_det)
+  TEST_ENTRY(glm_mat4_inv)
+  TEST_ENTRY(glm_mat4_inv_fast)
+  TEST_ENTRY(glm_mat4_swap_col)
+  TEST_ENTRY(glm_mat4_swap_row)
+  TEST_ENTRY(glm_mat4_rmc)
   
   TEST_ENTRY(affine)