Custom Built-in Unit Test Suite (#105)

* tests: new built-in test runner

* tests: update tests for new builtin test api

* tests: print test suite logs

* tests: remove cmocka from build files

* tests: colorize test suite log and remove redundant prints

.github/workflows/ccpp.yml

@@ -1,24 +0,0 @@
-name: C/C++ CI
-
-on: [push]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macOS-latest]
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: dependencies
-      run: sh ./build-deps.sh
-    - name: autogen
-      run: sh autogen.sh
-    - name: configure
-      run: ./configure
-    - name: make
-      run: make
-    - name: make check
-      run: make check

.gitignore

@@ -51,7 +51,6 @@ cscope.*
 test/*.trs
 test/test_*
 *.log
-test-*
 test/.libs/*
 test/tests
 cglm_arm/*
@@ -71,3 +70,4 @@ win/x85
 win/Debug
 cglm-test-ios*
 /cglm.pc
+test-driver

Makefile.am

@@ -7,7 +7,6 @@
 #******************************************************************************
 
 ACLOCAL_AMFLAGS = -I m4
-
 AM_CFLAGS = -Wall \
             -std=gnu99 \
             -O3 \
@@ -19,12 +18,9 @@ lib_LTLIBRARIES = libcglm.la
 libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
 
 checkLDFLAGS = -L./.libs \
-               -L./test/lib/cmocka/build/src \
-               -lcmocka \
                -lm \
                -lcglm
-checkCFLAGS = -I./test/lib/cmocka/include \
+checkCFLAGS = -I./include
-              -I./include
 
 check_PROGRAMS = test/tests
 TESTS = $(check_PROGRAMS)
@@ -140,8 +136,8 @@ libcglm_la_SOURCES=\
     src/bezier.c
 
 test_tests_SOURCES=\
+    test/runner.c \
     test/src/test_common.c \
-    test/src/test_main.c \
     test/src/test_mat4.c \
     test/src/test_cam.c \
     test/src/test_project.c \
@@ -160,7 +156,7 @@ pkgconfig_DATA=cglm.pc
 # the source directory that post-build.sh is in. When not
 # using a prefix, $VPATH will be unset, so we need to fall
 # back to using . to run the script.
-export VPATH
+#export VPATH
 
-all-local:
+# all-local:
-	sh $${VPATH:-.}/post-build.sh
+#	sh $${VPATH:-.}/post-build.sh

configure.ac

@@ -8,7 +8,7 @@
 
 AC_PREREQ([2.69])
 AC_INIT([cglm], [0.6.0], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
 
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([src/])

post-build.sh

@@ -1,24 +0,0 @@
-#! /bin/sh
-#
-# Copyright (c), Recep Aslantas.
-#
-# MIT License (MIT), http://opensource.org/licenses/MIT
-# Full license can be found in the LICENSE file
-#
-
-cd $(dirname "$0")
-
-mkdir -p "$(pwd)/.libs"
-
-libmocka_folder=$(pwd)/test/lib/cmocka/build/src/
-
-if [ "$(uname)" = "Darwin" ]; then
-  libcmocka=libcmocka.0.dylib
-else
-  libcmocka=libcmocka.so.0
-fi
-
-libcmocka_path="$libmocka_folder$libcmocka"
-if [ -f "$libcmocka_path" ]; then
-  ln -sf "$libcmocka_path" "$(pwd)/.libs/$libcmocka";
-fi

test/include/common.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef tests_common_h
+#define tests_common_h
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <cglm/cglm.h>
+#include <cglm/struct.h>
+#include <cglm/call.h>
+
+typedef struct test_status_t {
+  const char *msg;
+  int         status;
+} test_status_t;
+
+typedef test_status_t (*fntest)(void);
+
+typedef struct test_entry_t {
+  char  *name;
+  fntest entry;
+  int    ret;
+  int    show_output;
+} test_entry_t;
+
+#define RESET       "\033[0m"
+#define BLACK       "\033[30m"             /* Black */
+#define RED         "\033[31m"             /* Red */
+#define GREEN       "\033[32m"             /* Green */
+#define YELLOW      "\033[33m"             /* Yellow */
+#define BLUE        "\033[34m"             /* Blue */
+#define MAGENTA     "\033[35m"             /* Magenta */
+#define CYAN        "\033[36m"             /* Cyan */
+#define WHITE       "\033[37m"             /* White */
+#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */
+#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */
+#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */
+#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */
+#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */
+#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */
+#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
+#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */
+
+#define TEST_DECLARE(FUN) test_status_t test_ ## FUN(void);
+#define TEST_ENTRY(FUN)   { #FUN, test_ ## FUN, 0, 0 },
+#define TEST_LIST         static test_entry_t tests[] = 
+
+#define ASSERT_EXT(expr, msg)                                                 \
+  if (!(expr)) {                                                              \
+    fprintf(stderr,                                                           \
+            RED "  assert fail" RESET                                         \
+            " in " BOLDCYAN "%s " RESET                                       \
+            "on " BOLDMAGENTA "line %d" RESET                                 \
+            " : " BOLDWHITE " ASSERT(%s)\n" RESET,                            \
+            __FILE__,                                                         \
+            __LINE__,                                                         \
+            #expr);                                                           \
+    return (test_status_t){msg, 0};                                           \
+  }
+
+#define ASSERT_ARG1(expr)                  ASSERT_EXT(expr, NULL)
+#define ASSERT_ARG2(expr, msg)             ASSERT_EXT(expr, msg)
+#define ASSERT_ARG3(arg1, arg2, arg3, ...) arg3
+
+#define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1)
+#define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } 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()
+
+#endif /* common_h */

test/runner.c

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "include/common.h"
+#include "tests.h"
+
+#include <stdlib.h>
+
+int
+main(int argc, const char * argv[]) {
+  test_entry_t *entry;
+  test_status_t st;
+  int32_t       i, count, passed, failed;
+
+  passed = failed = 0;
+  count  = sizeof(tests) / sizeof(tests[0]);
+ 
+  fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET);
+  
+  for (i = 0; i < count; i++) {
+    entry = tests + i;
+    st    = entry->entry();
+
+    if (!st.status) {
+      fprintf(stderr,
+              BOLDRED  "  𐄂" BOLDWHITE " %s " RESET,
+              entry->name);
+      if (st.msg) {
+        fprintf(stderr,
+                YELLOW "- %s" RESET,
+                st.msg);
+      }
+
+      fprintf(stderr, "\n");
+
+      failed++;
+    } else {
+      fprintf(stderr,
+              GREEN  "  ✔︎" RESET " %s\n"
+              ,
+              entry->name);
+      passed++;
+    }
+  }
+  
+  if (failed == 0) {
+    fprintf(stderr, BOLDGREEN "\n  All tests are passed 🎉\n" RESET);
+  }
+
+  fprintf(stderr,
+          CYAN "\ncglm test results:\n" RESET
+          "------------------\n"
+          
+          MAGENTA "%d" RESET " tests are runned, "
+          GREEN   "%d" RESET " %s passed, "
+          RED     "%d" RESET " %s failed\n\n" RESET,
+          passed + failed,
+          passed,
+          passed > 1 ? "are" : "is",
+          failed,
+          failed > 1 ? "are" : "is");
+
+  return failed;
+}

test/src/test_affine.c

@@ -7,8 +7,7 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(affine) {
-test_affine(void **state) {
   mat4 t1, t2, t3, t4, t5;
 
   /* test translate is postmultiplied */
@@ -18,7 +17,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t1, t2, t3); /* R * T */
 
   glm_translate(t1, (vec3){34, 57, 36});
-  test_assert_mat4_eq(t1, t3);
+  ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
 
   /* test rotate is postmultiplied */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -27,7 +26,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate(t2, GLM_PI_4f, GLM_YUP);
-  test_assert_mat4_eq(t2, t3);
+  ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
 
   /* test scale is postmultiplied */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -38,7 +37,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t3, t4, t5); /* T * R * S */
 
   glm_scale(t3, (vec3){3, 5, 6});
-  test_assert_mat4_eq(t3, t5);
+  ASSERT(test_assert_mat4_eq(t3, t5).status == 1)
 
   /* test translate_x */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -46,7 +45,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_x(t1, 34);
-  test_assert_mat4_eq(t1, t3);
+  ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
 
   /* test translate_y */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -54,7 +53,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_y(t1, 57);
-  test_assert_mat4_eq(t1, t3);
+  ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
 
   /* test translate_z */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -62,7 +61,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_z(t1, 36);
-  test_assert_mat4_eq(t1, t3);
+  ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
 
   /* test rotate_x */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0});
@@ -71,7 +70,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_x(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
 
   /* test rotate_y */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0});
@@ -80,7 +79,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_y(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
 
   /* test rotate_z */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -89,7 +88,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_z(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
 
   /* test rotate */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -98,7 +97,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
   glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1});
 
-  test_assert_mat4_eq(t3, t2);
+  ASSERT(test_assert_mat4_eq(t3, t2).status == 1)
 
   /* test scale_uni */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -109,5 +108,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t3, t4, t5); /* T * R * S */
 
   glm_scale_uni(t3, 3);
-  test_assert_mat4_eq(t3, t5);
+  ASSERT(test_assert_mat4_eq(t3, t5).status == 1)
+
+  TEST_SUCCESS
 }

test/src/test_bezier.c

@@ -35,8 +35,7 @@ test_hermite_plain(float s, float p0, float t0, float t1, float p1) {
        + t1 * (sss - ss);
 }
 
-void
+TEST_IMPL(bezier) {
-test_bezier(void **state) {
   float s, p0, p1, c0, c1, smc, Bs, Bs_plain;
 
   s        = test_rand();
@@ -50,16 +49,18 @@ test_bezier(void **state) {
   Bs       = glm_bezier(s, p0, c0, c1, p1);
   Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
 
-  assert_true(glm_eq(Bs,  Bs_plain));
+  ASSERT(glm_eq(Bs,  Bs_plain));
-  test_assert_eqf(smc, Bs_plain);
+  ASSERT(test_assert_eqf(smc, Bs_plain).status == 1)
-  test_assert_eqf(Bs,  smc);
+  ASSERT(test_assert_eqf(Bs,  smc).status == 1)
 
   /* test cubic hermite */
   smc      = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1});
   Bs       = glm_hermite(s, p0, c0, c1, p1);
   Bs_plain = test_hermite_plain(s, p0, c0, c1, p1);
 
-  assert_true(glm_eq(Bs,  Bs_plain));
+  ASSERT(glm_eq(Bs,  Bs_plain));
-  assert_true(glm_eq(smc, Bs_plain));
+  ASSERT(glm_eq(smc, Bs_plain));
-  assert_true(glm_eq(Bs,  smc));
+  ASSERT(glm_eq(Bs,  smc));
+  
+  TEST_SUCCESS
 }

test/src/test_cam.c

@@ -7,25 +7,24 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(camera_lookat) {
-test_camera_lookat(void **state) {
+  mat4 view1, view2;
-  mat4  view1, view2;
   vec3 center,
-       eye    = {0.024f, 14.6f, 67.04f},
+       eye = {0.024f, 14.6f, 67.04f},
-       dir    = {0.0f, 0.0f, -1.0f},
+       dir = {0.0f, 0.0f, -1.0f},
-       up     = {0.0f, 1.0f, 0.0f}
+       up  = {0.0f, 1.0f, 0.0f};
-  ;
 
   glm_vec3_add(eye, dir, center);
   glm_lookat(eye, center, up, view1);
 
   glm_look(eye, dir, up, view2);
 
-  test_assert_mat4_eq(view1, view2);
+  ASSERT(test_assert_mat4_eq(view1, view2).status == 1)
+
+  TEST_SUCCESS
 }
 
-void
+TEST_IMPL(camera_decomp) {
-test_camera_decomp(void **state) {
   mat4  proj, proj2;
   vec4  sizes;
   float aspect, fovy, nearVal, farVal;
@@ -36,9 +35,9 @@ test_camera_decomp(void **state) {
   farVal  = 100.0f;
 
   glm_perspective(fovy, aspect, nearVal, farVal, proj);
-  assert_true(fabsf(aspect  - glm_persp_aspect(proj)) < FLT_EPSILON);
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < FLT_EPSILON)
-  assert_true(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON);
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON)
-  assert_true(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON);
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON)
 
   glm_persp_sizes(proj, fovy, sizes);
 
@@ -50,5 +49,7 @@ test_camera_decomp(void **state) {
                farVal,
                proj2);
 
-  test_assert_mat4_eq(proj, proj2);
+  ASSERT(test_assert_mat4_eq(proj, proj2).status == 1)
+
+  TEST_SUCCESS
 }

test/src/test_clamp.c

@@ -7,24 +7,25 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(clamp) {
-test_clamp(void **state) {
   vec3 v3 = {15.07, 0.4, 17.3};
   vec4 v4 = {5.07,  2.3, 1.3, 1.4};
 
-  assert_true(glm_clamp(1.6f, 0.0f, 1.0f)  == 1.0f);
+  ASSERT(glm_clamp(1.6f, 0.0f, 1.0f)  == 1.0f)
-  assert_true(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f);
+  ASSERT(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f)
-  assert_true(glm_clamp(0.6f, 0.0f, 1.0f)  == 0.6f);
+  ASSERT(glm_clamp(0.6f, 0.0f, 1.0f)  == 0.6f)
 
   glm_vec3_clamp(v3, 0.0, 1.0);
   glm_vec4_clamp(v4, 1.5, 3.0);
 
-  assert_true(v3[0] == 1.0f);
+  ASSERT(v3[0] == 1.0f)
-  assert_true(v3[1] == 0.4f);
+  ASSERT(v3[1] == 0.4f)
-  assert_true(v3[2] == 1.0f);
+  ASSERT(v3[2] == 1.0f)
 
-  assert_true(v4[0] == 3.0f);
+  ASSERT(v4[0] == 3.0f)
-  assert_true(v4[1] == 2.3f);
+  ASSERT(v4[1] == 2.3f)
-  assert_true(v4[2] == 1.5f);
+  ASSERT(v4[2] == 1.5f)
-  assert_true(v4[3] == 1.5f);
+  ASSERT(v4[3] == 1.5f)
+  
+  TEST_SUCCESS
 }

test/src/test_common.c

@@ -4,11 +4,7 @@
  */
 
 #include "test_common.h"
-#include <stdlib.h>
+#include <time.h>
-#include <math.h>
-
-#define m 4
-#define n 4
 
 void
 test_rand_mat4(mat4 dest) {
@@ -86,85 +82,105 @@ test_rand_quat(versor q) {
   glm_quat_normalize(q);
 }
 
-void
+test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2) {
   int i, j, k;
 
-  for (i = 0; i < m; i++) {
+  for (i = 0; i < 4; i++) {
-    for (j = 0; j < n; j++) {
+    for (j = 0; j < 4; j++) {
-      for (k = 0; k < m; k++)
+      for (k = 0; k < 4; k++)
-        assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
     }
   }
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
   int i, j, k;
   
-  for (i = 0; i < m; i++) {
+  for (i = 0; i < 4; i++) {
-    for (j = 0; j < n; j++) {
+    for (j = 0; j < 4; j++) {
-      for (k = 0; k < m; k++)
+      for (k = 0; k < 4; k++)
-        assert_true(fabsf(m1[i][j] - m2[i][j]) <= eps);
+        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
     }
   }
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_mat3_eq(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_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
     }
   }
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_eqf(float a, float b) {
-  assert_true(fabsf(a - b) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec3s_eq(vec3s v1, vec3s v2) {
   test_assert_vec3_eq(v1.raw, v2.raw);
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 0.000009);
+  ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec4s_eq(vec4s v1, vec4s v2) {
   test_assert_vec4_eq(v1.raw, v2.raw);
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_quat_eq_abs(versor v1, versor v2) {
-  assert_true(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */
+  ASSERT(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */
-  assert_true(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_quat_eq(versor v1, versor v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 0.000009);
+  ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
+  
+  TEST_SUCCESS
 }
 

test/src/test_common.h

@@ -8,20 +8,7 @@
 #ifndef test_common_h
 #define test_common_h
 
-#include <stdarg.h>
+#include "../include/common.h"
-#include <stdint.h>
-#include <stddef.h>
-#include <setjmp.h>
-#include <cmocka.h>
-#include <time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <float.h>
-#include <stdbool.h>
-
-#include <cglm/cglm.h>
-#include <cglm/struct.h>
-#include <cglm/call.h>
 
 void
 test_rand_mat4(mat4 dest);
@@ -29,34 +16,34 @@ test_rand_mat4(mat4 dest);
 void
 test_rand_mat3(mat3 dest);
 
-void
+test_status_t
 test_assert_eqf(float a, float b);
 
-void
+test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2);
 
-void
+test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
 
-void
+test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
-void
+test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 
-void
+test_status_t
 test_assert_vec3s_eq(vec3s v1, vec3s v2);
 
-void
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2);
 
-void
+test_status_t
 test_assert_vec4s_eq(vec4s v1, vec4s v2);
 
-void
+test_status_t
 test_assert_quat_eq(versor v1, versor v2);
 
-void
+test_status_t
 test_assert_quat_eq_abs(versor v1, versor v2);
 
 void

test/src/test_euler.c

@@ -7,10 +7,9 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(euler) {
-test_euler(void **state) {
+  mat4 rot1, rot2;
-  mat4  rot1, rot2;
+  vec3 inAngles, outAngles;
-  vec3  inAngles, outAngles;
 
   inAngles[0] = glm_rad(-45.0f);  /* X angle */
   inAngles[1] = glm_rad(88.0f);   /* Y angle */
@@ -22,11 +21,11 @@ test_euler(void **state) {
   glmc_euler_angles(rot1, outAngles);
 
   /* angles must be equal in that range */
-  test_assert_vec3_eq(inAngles, outAngles);
+  ASSERT(test_assert_vec3_eq(inAngles, outAngles).status == 1)
 
   /* matrices must be equal */
   glmc_euler_xyz(outAngles, rot2);
-  test_assert_mat4_eq(rot1, rot2);
+  ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1)
 
   /* change range */
   inAngles[0] = glm_rad(-145.0f);  /* X angle */
@@ -40,5 +39,7 @@ test_euler(void **state) {
 
   /* matrices must be equal */
   glmc_euler_xyz(outAngles, rot2);
-  test_assert_mat4_eq(rot1, rot2);
+  ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1)
+  
+  TEST_SUCCESS
 }

test/src/test_main.c

@@ -1,48 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- * MIT License (MIT), http://opensource.org/licenses/MIT
- */
-
-#include "test_common.h"
-#include "test_tests.h"
-
-int
-main(int argc, const char * argv[]) {
-  const struct CMUnitTest tests[] = {
-    /* mat4 */
-    cmocka_unit_test(test_mat4),
-
-    /* mat3 */
-    cmocka_unit_test(test_mat3),
-
-    /* camera */
-    cmocka_unit_test(test_camera_lookat),
-    cmocka_unit_test(test_camera_decomp),
-
-    /* project */
-    cmocka_unit_test(test_project),
-
-    /* vector */
-    cmocka_unit_test(test_clamp),
-
-    /* euler */
-    cmocka_unit_test(test_euler),
-
-    /* quaternion */
-    cmocka_unit_test(test_quat),
-
-    /* vec4 */
-    cmocka_unit_test(test_vec4),
-
-    /* vec3 */
-    cmocka_unit_test(test_vec3),
-
-    /* affine */
-    cmocka_unit_test(test_affine),
-
-    /* bezier */
-    cmocka_unit_test(test_bezier)
-  };
-
-  return cmocka_run_group_tests(tests, NULL, NULL);
-}

test/src/test_mat3.c

@@ -10,26 +10,34 @@
 #define m 3
 #define n 3
 
-void
+TEST_IMPL(mat3_identity) {
-test_mat3(void **state) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
-  mat3  m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
-  mat3  m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
-  mat3  m3;
+  int  i, j;
-  mat3  m4 = GLM_MAT3_ZERO_INIT;
-  mat3  m5;
-  int   i, j, k;
   
   /* test identity matrix multiplication */
   glmc_mat3_mul(m1, m2, m3);
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
-      if (i == j)
+      if (i == j) {
-        assert_true(glm_eq(m3[i][j], 1.0f));
+        ASSERT(glm_eq(m3[i][j], 1.0f))
-      else
+      } else {
-        assert_true(glm_eq(m3[i][j], 0.0f));
+        ASSERT(glm_eq(m3[i][j], 0.0f))
+      }
     }
   }
   
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3_mul) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+  int  i, j, k;
+
   /* test random matrices */
   /* random matrices */
   test_rand_mat3(m1);
@@ -44,15 +52,26 @@ test_mat3(void **state) {
     }
   }
   
-  test_assert_mat3_eq(m3, m4);
+  ASSERT(test_assert_mat3_eq(m3, m4).status == 1)
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3_inv) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
+  int  i;
   
   for (i = 0; i < 100000; i++) {
-    test_rand_mat3(m3);
+    test_rand_mat3(m1);
-    test_rand_mat3(m4);
+    test_rand_mat3(m2);
 
     /* test inverse precise */
-    glmc_mat3_inv(m3, m4);
+    glmc_mat3_inv(m1, m2);
-    glmc_mat3_inv(m4, m5);
+    glmc_mat3_inv(m2, m3);
-    test_assert_mat3_eq(m3, m5);
+    ASSERT(test_assert_mat3_eq(m1, m3).status == 1)
   }
+  
+  TEST_SUCCESS
 }

test/src/test_mat4.c

@@ -10,26 +10,34 @@
 #define m 4
 #define n 4
 
-void
+TEST_IMPL(mat4_identity) {
-test_mat4(void **state) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
-  mat4  m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
-  mat4  m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
-  mat4  m3;
+  int  i, j;
-  mat4  m4 = GLM_MAT4_ZERO_INIT;
-  mat4  m5;
-  int   i, j, k;
   
   /* test identity matrix multiplication */
   glm_mat4_mul(m1, m2, m3);
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
-      if (i == j)
+      if (i == j) {
-        assert_true(glm_eq(m3[i][j], 1.0f));
+        ASSERT(glm_eq(m3[i][j], 1.0f))
-      else
+      } else {
-        assert_true(glm_eq(m3[i][j], 0.0f));
+        ASSERT(glm_eq(m3[i][j], 0.0f))
+      }
     }
   }
   
+  TEST_SUCCESS
+}
+
+TEST_IMPL(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);
@@ -39,16 +47,26 @@ test_mat4(void **state) {
   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];
     }
   }
   
-  test_assert_mat4_eq(m3, m4);
+  ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK)
   
   /* test pre compiled */
   glmc_mat4_mul(m1, m2, m3);
-  test_assert_mat4_eq(m3, m4);
+  ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK)
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4_all) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  mat4 m5;
+  int  i;
 
   for (i = 0; i < 100000; i++) {
     test_rand_mat4(m3);
@@ -57,14 +75,14 @@ test_mat4(void **state) {
     /* test inverse precise */
     glm_mat4_inv_precise(m3, m4);
     glm_mat4_inv_precise(m4, m5);
-    test_assert_mat4_eq(m3, m5);
+    ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK)
     
     test_rand_mat4(m3);
     test_rand_mat4(m4);
 
     glmc_mat4_inv_precise(m3, m4);
     glmc_mat4_inv_precise(m4, m5);
-    test_assert_mat4_eq(m3, m5);
+    ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK)
     
     /* test inverse rcp */
     test_rand_mat4(m3);
@@ -72,23 +90,21 @@ test_mat4(void **state) {
     
     glm_mat4_inv_fast(m3, m4);
     glm_mat4_inv_fast(m4, m5);
-    test_assert_mat4_eq2(m3, m5, 0.0009f);
+    ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK)
     
     test_rand_mat4(m3);
     test_rand_mat4(m4);
     
     glmc_mat4_inv(m3, m4);
     glmc_mat4_inv(m4, m5);
-    test_assert_mat4_eq2(m3, m5, 0.0009f);
+    ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK)
   }
 
-  /* print */
-  glm_mat4_print(m3, stderr);
-  glm_mat4_print(m4, stderr);
-
   /* test determinant */
-  assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1));
+  ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1))
 #if defined( __SSE2__ )
-  assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1));
+  ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1))
 #endif
+  
+  TEST_SUCCESS
 }

test/src/test_project.c

@@ -7,8 +7,7 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(project) {
-test_project(void **state) {
   mat4 model, view, proj, mvp;
   vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f};
   vec3 pos      = {13.0f, 45.0f, 0.74f};
@@ -25,7 +24,9 @@ test_project(void **state) {
 
   /* unprojected of projected vector must be same as original one */
   /* we used 0.01 because of projection floating point errors */
-  assert_true(fabsf(pos[0] - unprojected[0]) < 0.01);
+  ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01);
-  assert_true(fabsf(pos[1] - unprojected[1]) < 0.01);
+  ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01);
-  assert_true(fabsf(pos[2] - unprojected[2]) < 0.01);
+  ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01);
+  
+  TEST_SUCCESS
 }

test/src/test_quat.c

@@ -16,8 +16,7 @@ test_quat_mul_raw(versor p, versor q, versor dest) {
   dest[3] = p[3] * q[3] - p[0] * q[0] - p[1] * q[1] - p[2] * q[2];
 }
 
-void
+TEST_IMPL(quat) {
-test_quat(void **state) {
   mat4   inRot, outRot, view1, view2, rot1, rot2;
   versor inQuat, outQuat, q3, q4, q5;
   vec3   eye, axis, imag, v1, v2;
@@ -25,9 +24,10 @@ test_quat(void **state) {
 
   /* 0. test identiy quat */
   glm_quat_identity(q4);
-  assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)));
+  ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
+
   glm_quat_mat4(q4, rot1);
-  test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1)
 
   /* 1. test quat to mat and mat to quat */
   for (i = 0; i < 1000; i++) {
@@ -38,16 +38,17 @@ test_quat(void **state) {
     glmc_quat_mat4(outQuat, outRot);
 
     /* 2. test first quat and generated one equality */
-    test_assert_quat_eq_abs(inQuat, outQuat);
+    ASSERT(test_assert_quat_eq_abs(inQuat, outQuat).status == 1);
 
     /* 3. test first rot and second rotation */
-    test_assert_mat4_eq2(inRot, outRot, 0.000009); /* almost equal */
+    /* almost equal */
+    ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009).status == 1);
 
     /* 4. test SSE mul and raw mul */
 #if defined( __SSE__ ) || defined( __SSE2__ )
     test_quat_mul_raw(inQuat, outQuat, q3);
     glm_quat_mul_sse2(inQuat, outQuat, q4);
-    test_assert_quat_eq(q3, q4);
+    ASSERT(test_assert_quat_eq(q3, q4).status == 1);
 #endif
   }
 
@@ -61,7 +62,7 @@ test_quat(void **state) {
   /* create view matrix with quaternion */
   glm_quat_look(eye, q3, view2);
 
-  test_assert_mat4_eq2(view1, view2, 0.000009);
+  ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009).status == 1);
 
   /* 6. test quaternion rotation matrix result */
   test_rand_quat(q3);
@@ -71,7 +72,7 @@ test_quat(void **state) {
   glm_quat_axis(q3, axis);
   glm_rotate_make(rot2, glm_quat_angle(q3), axis);
 
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1);
 
   /* 7. test quaternion multiplication (hamilton product),
         final rotation = first rotation + second = quat1 * quat2
@@ -91,7 +92,7 @@ test_quat(void **state) {
   glm_quat_mat4(q5, rot2);
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
 
   /* 8. test quaternion for look rotation */
 
@@ -101,26 +102,26 @@ test_quat(void **state) {
 
   /* result must be identity */
   glm_quat_identity(q4);
-  test_assert_quat_eq(q3, q4);
+  ASSERT(test_assert_quat_eq(q3, q4).status == 1)
 
   /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */
   glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3);
 
   /* result must be identity */
   glm_quat_identity(q4);
-  test_assert_quat_eq(q3, q4);
+  ASSERT(test_assert_quat_eq(q3, q4).status == 1)
 
   /* 8.2 perpendicular */
   glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3);
 
   /* result must be -90 */
   glm_quatv(q4, glm_rad(-90.0f), GLM_YUP);
-  test_assert_quat_eq(q3, q4);
+  ASSERT(test_assert_quat_eq(q3, q4).status == 1)
 
   /* 9. test imag, real */
 
   /* 9.1 real */
-  assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)));
+  ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)))
 
   /* 9.1 imag */
   glm_quat_imag(q4, imag);
@@ -130,7 +131,7 @@ test_quat(void **state) {
   axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f;
   axis[2] = 0.0f;
 
-  assert_true(glm_vec3_eqv_eps(imag, axis));
+  ASSERT(glm_vec3_eqv_eps(imag, axis));
 
   /* 9.2 axis */
   glm_quat_axis(q4, axis);
@@ -138,7 +139,7 @@ test_quat(void **state) {
   imag[1] = -1.0f;
   imag[2] =  0.0f;
 
-  test_assert_vec3_eq(imag, axis);
+  ASSERT(test_assert_vec3_eq(imag, axis).status == 1);
 
   /* 10. test rotate vector using quat */
   /* (0,0,-1) around (1,0,0) must give (0,1,0) */
@@ -152,11 +153,11 @@ test_quat(void **state) {
   glm_quat_rotatev(q3, v2, v2);
 
   /* result must be : (0,1,0) */
-  assert_true(fabsf(v1[0]) <= 0.00009f
+  ASSERT(fabsf(v1[0]) <= 0.00009f
-              && fabsf(v1[1] - 1.0f) <= 0.00009f
+          && fabsf(v1[1] - 1.0f) <= 0.00009f
-              && fabsf(v1[2]) <= 0.00009f);
+          && fabsf(v1[2]) <= 0.00009f)
 
-  test_assert_vec3_eq(v1, v2);
+  ASSERT(test_assert_vec3_eq(v1, v2).status == 1)
 
   /* 11. test rotate transform */
   glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -167,7 +168,7 @@ test_quat(void **state) {
   glm_quat_rotate(rot2, q3, rot2);
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
 
   glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
   glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -178,7 +179,7 @@ test_quat(void **state) {
   glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f});
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
 
   /* reverse */
   glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
@@ -186,7 +187,7 @@ test_quat(void **state) {
   glm_quat_rotate(rot1, q3, rot1);
 
   /* result must be identity */
-  test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009);
+  ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1)
 
   test_rand_quat(q3);
 
@@ -195,7 +196,9 @@ test_quat(void **state) {
   glm_quat_mul(q3, q4, q5);
 
   glm_quat_identity(q3);
-  test_assert_quat_eq(q3, q5);
+  ASSERT(test_assert_quat_eq(q3, q5).status == 1)
 
   /* TODO: add tests for slerp, lerp */
+
+  TEST_SUCCESS
 }

test/src/test_tests.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- * MIT License (MIT), http://opensource.org/licenses/MIT
- */
-
-#ifndef test_tests_h
-#define test_tests_h
-
-/* mat4 */
-void test_mat4(void **state);
-
-/* mat3 */
-void test_mat3(void **state);
-
-/* camera */
-void
-test_camera_lookat(void **state);
-
-void
-test_camera_decomp(void **state);
-
-void
-test_project(void **state);
-
-void
-test_clamp(void **state);
-
-void
-test_euler(void **state);
-
-void
-test_quat(void **state);
-
-void
-test_vec4(void **state);
-
-void
-test_vec3(void **state);
-
-void
-test_affine(void **state);
-
-void
-test_bezier(void **state);
-
-#endif /* test_tests_h */

test/src/test_vec3.c

@@ -7,65 +7,64 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(vec3) {
-test_vec3(void **state) {
+  mat3  rot1m3;
-  mat3 rot1m3;
+  mat4  rot1;
-  mat4 rot1;
+  vec3  v, v1, v2;
-  vec3 v, v1, v2;
   vec3s vs1, vs2, vs3, vs4;
 
   /* test zero */
   glm_vec3_zero(v);
-  test_assert_vec3_eq(GLM_VEC3_ZERO, v);
+  ASSERT(test_assert_vec3_eq(GLM_VEC3_ZERO, v).status == 1)
 
   /* test one */
   glm_vec3_one(v);
-  test_assert_vec3_eq(GLM_VEC3_ONE, v);
+  ASSERT(test_assert_vec3_eq(GLM_VEC3_ONE, v).status == 1)
 
   /* adds, subs, div, divs, mul */
   glm_vec3_add(v, GLM_VEC3_ONE, v);
-  assert_true(glmc_vec3_eq_eps(v, 2));
+  ASSERT(glmc_vec3_eq_eps(v, 2))
 
   glm_vec3_adds(v, 10, v);
-  assert_true(glmc_vec3_eq_eps(v, 12));
+  ASSERT(glmc_vec3_eq_eps(v, 12))
 
   glm_vec3_sub(v, GLM_VEC3_ONE, v);
-  assert_true(glmc_vec3_eq_eps(v, 11));
+  ASSERT(glmc_vec3_eq_eps(v, 11))
 
   glm_vec3_subs(v, 1, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
+  ASSERT(glmc_vec3_eq_eps(v, 10))
 
   glm_vec3_broadcast(2, v1);
   glm_vec3_div(v, v1, v);
-  assert_true(glmc_vec3_eq_eps(v, 5));
+  ASSERT(glmc_vec3_eq_eps(v, 5))
 
   glm_vec3_divs(v, 0.5, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
+  ASSERT(glmc_vec3_eq_eps(v, 10))
 
   glm_vec3_mul(v, v1, v);
-  assert_true(glmc_vec3_eq_eps(v, 20));
+  ASSERT(glmc_vec3_eq_eps(v, 20))
 
   glm_vec3_scale(v, 0.5, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
+  ASSERT(glmc_vec3_eq_eps(v, 10))
 
   glm_vec3_normalize_to(v, v1);
-  glm_vec3_scale(v1, 0.8, v1);
+  glm_vec3_scale(v1, 0.8f, v1);
-  glm_vec3_scale_as(v, 0.8, v);
+  glm_vec3_scale_as(v, 0.8f, v);
-  test_assert_vec3_eq(v1, v);
+  ASSERT(test_assert_vec3_eq(v1, v).status == 1)
 
   /* addadd, subadd, muladd */
   glm_vec3_one(v);
 
   glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v);
-  assert_true(glmc_vec3_eq_eps(v, 3));
+  ASSERT(glmc_vec3_eq_eps(v, 3))
 
   glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v);
-  assert_true(glmc_vec3_eq_eps(v, 4));
+  ASSERT(glmc_vec3_eq_eps(v, 4))
 
   glm_vec3_broadcast(2, v1);
   glm_vec3_broadcast(3, v2);
   glm_vec3_muladd(v1, v2, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
+  ASSERT(glmc_vec3_eq_eps(v, 10))
 
   /* rotate */
   glm_vec3_copy(GLM_YUP, v);
@@ -74,8 +73,8 @@ test_vec3(void **state) {
   glm_mat4_pick3(rot1, rot1m3);
   glm_vec3_rotate_m3(rot1m3, v, v2);
 
-  test_assert_vec3_eq(v1, v2);
+  ASSERT(test_assert_vec3_eq(v1, v2).status == 1)
-  test_assert_vec3_eq(v1, GLM_ZUP);
+  ASSERT(test_assert_vec3_eq(v1, GLM_ZUP).status == 1)
 
   /* structs */
   vs1 = test_rand_vec3s();
@@ -83,7 +82,7 @@ test_vec3(void **state) {
 
   vs3 = glms_vec3_add(vs1, vs2);
   vs4 = glms_vec3_maxv(vs1, vs3);
-  test_assert_vec3s_eq(vs3, vs4);
+  ASSERT(test_assert_vec3s_eq(vs3, vs4).status == 1)
 
   /* swizzle */
 
@@ -92,22 +91,24 @@ test_vec3(void **state) {
   v1[1] = 2;
   v1[2] = 3;
   glm_vec3_swizzle(v1, GLM_ZYX, v1);
-  test_assert_vec3_eq(v1, (vec3){3, 2, 1});
+  ASSERT(test_assert_vec3_eq(v1, (vec3){3, 2, 1}).status == 1)
 
   glm_vec3_swizzle(v1, GLM_XXX, v1);
-  test_assert_vec3_eq(v1, (vec3){3, 3, 3});
+  ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1)
 
   v1[0] = 1;
   v1[1] = 2;
   v1[2] = 3;
 
   glm_vec3_swizzle(v1, GLM_YYY, v1);
-  test_assert_vec3_eq(v1, (vec3){2, 2, 2});
+  ASSERT(test_assert_vec3_eq(v1, (vec3){2, 2, 2}).status == 1)
 
   v1[0] = 1;
   v1[1] = 2;
   v1[2] = 3;
 
   glm_vec3_swizzle(v1, GLM_ZZZ, v1);
-  test_assert_vec3_eq(v1, (vec3){3, 3, 3});
+  ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1)
+
+  TEST_SUCCESS
 }

test/src/test_vec4.c

@@ -62,8 +62,7 @@ test_vec4_clamp(vec4 v, float minVal, float maxVal) {
   v[3] = glm_clamp(v[3], minVal, maxVal);
 }
 
-void
+TEST_IMPL(vec4) {
-test_vec4(void **state) {
   vec4  v, v1, v2, v3, v4;
   vec4s vs1, vs2, vs3, vs4;
   int   i;
@@ -75,7 +74,7 @@ test_vec4(void **state) {
     d1 = glm_vec4_dot(v, v);
     d2 = test_vec4_dot(v, v);
 
-    assert_true(fabsf(d1 - d2) <= 0.000009);
+    ASSERT(fabsf(d1 - d2) <= 0.000009)
 
     /* 2. test SIMD normalize */
     test_vec4_normalize_to(v, v1);
@@ -98,62 +97,65 @@ test_vec4(void **state) {
     test_rand_vec4(v1);
     test_rand_vec4(v2);
     d1 = glm_vec4_distance(v1, v2);
-    d2 = sqrtf(powf(v1[0]-v2[0], 2.0f) + pow(v1[1]-v2[1], 2.0f) + pow(v1[2]-v2[2], 2.0f) + pow(v1[3]-v2[3], 2.0f));
+    d2 = sqrtf(powf(v1[0] - v2[0], 2.0f)
-    assert_true(fabsf(d1 - d2) <= 0.000009);
+               + pow(v1[1] - v2[1], 2.0f)
+               + pow(v1[2] - v2[2], 2.0f)
+               + pow(v1[3] - v2[3], 2.0f));
+    ASSERT(fabsf(d1 - d2) <= 0.000009)
   }
 
   /* test zero */
   glm_vec4_zero(v);
-  test_assert_vec4_eq(GLM_VEC4_ZERO, v);
+  ASSERT(test_assert_vec4_eq(GLM_VEC4_ZERO, v).status == 1)
 
   /* test one */
   glm_vec4_one(v);
-  test_assert_vec4_eq(GLM_VEC4_ONE, v);
+  ASSERT(test_assert_vec4_eq(GLM_VEC4_ONE, v).status == 1)
 
   /* adds, subs, div, divs, mul */
   glm_vec4_add(v, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 2));
+  ASSERT(glmc_vec4_eq_eps(v, 2))
 
   glm_vec4_adds(v, 10, v);
-  assert_true(glmc_vec4_eq_eps(v, 12));
+  ASSERT(glmc_vec4_eq_eps(v, 12))
 
   glm_vec4_sub(v, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 11));
+  ASSERT(glmc_vec4_eq_eps(v, 11))
 
   glm_vec4_subs(v, 1, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
+  ASSERT(glmc_vec4_eq_eps(v, 10))
 
   glm_vec4_broadcast(2, v1);
   glm_vec4_div(v, v1, v);
-  assert_true(glmc_vec4_eq_eps(v, 5));
+  ASSERT(glmc_vec4_eq_eps(v, 5))
 
   glm_vec4_divs(v, 0.5, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
+  ASSERT(glmc_vec4_eq_eps(v, 10))
 
   glm_vec4_mul(v, v1, v);
-  assert_true(glmc_vec4_eq_eps(v, 20));
+  ASSERT(glmc_vec4_eq_eps(v, 20))
 
   glm_vec4_scale(v, 0.5, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
+  ASSERT(glmc_vec4_eq_eps(v, 10))
 
   glm_vec4_normalize_to(v, v1);
   glm_vec4_scale(v1, 0.8, v1);
   glm_vec4_scale_as(v, 0.8, v);
-  test_assert_vec4_eq(v1, v);
+  ASSERT(test_assert_vec4_eq(v1, v).status == 1)
 
   /* addadd, subadd, muladd */
   glm_vec4_one(v);
 
   glm_vec4_addadd(GLM_VEC4_ONE, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 3));
+  ASSERT(glmc_vec4_eq_eps(v, 3))
 
   glm_vec4_subadd(GLM_VEC4_ONE, GLM_VEC4_ZERO, v);
-  assert_true(glmc_vec4_eq_eps(v, 4));
+  ASSERT(glmc_vec4_eq_eps(v, 4))
 
   glm_vec4_broadcast(2, v1);
   glm_vec4_broadcast(3, v2);
   glm_vec4_muladd(v1, v2, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
+  ASSERT(glmc_vec4_eq_eps(v, 10))
 
   /* min, max */
   test_rand_vec4(v1);
@@ -161,27 +163,21 @@ test_vec4(void **state) {
 
   glm_vec4_maxv(v1, v2, v3);
   test_vec4_maxv(v1, v2, v4);
-  test_assert_vec4_eq(v3, v4);
+  ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
 
   glm_vec4_minv(v1, v2, v3);
   test_vec4_minv(v1, v2, v4);
-  test_assert_vec4_eq(v3, v4);
+  ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
-
-  glm_vec4_print(v3, stderr);
-  glm_vec4_print(v4, stderr);
 
   /* clamp */
   glm_vec4_clamp(v3, 0.1, 0.8);
   test_vec4_clamp(v4, 0.1, 0.8);
-  test_assert_vec4_eq(v3, v4);
+  ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
 
-  glm_vec4_print(v3, stderr);
+  ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */
-  glm_vec4_print(v4, stderr);
+  ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001)
-
+  ASSERT(v3[2] >= 0.0999 && v3[2] <= 0.80001)
-  assert_true(v3[0] >= 0.0999 && v3[0] <= 0.80001); /* rounding erros */
+  ASSERT(v3[3] >= 0.0999 && v3[3] <= 0.80001)
-  assert_true(v3[1] >= 0.0999 && v3[1] <= 0.80001);
-  assert_true(v3[2] >= 0.0999 && v3[2] <= 0.80001);
-  assert_true(v3[3] >= 0.0999 && v3[3] <= 0.80001);
 
   /* swizzle */
 
@@ -192,10 +188,10 @@ test_vec4(void **state) {
   v1[3] = 4;
 
   glm_vec4_swizzle(v1, GLM_WZYX, v1);
-  test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1});
+  ASSERT(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}).status == 1)
 
   glm_vec4_swizzle(v1, GLM_XXXX, v1);
-  test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4});
+  ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1)
 
   v1[0] = 1;
   v1[1] = 2;
@@ -203,7 +199,7 @@ test_vec4(void **state) {
   v1[3] = 4;
 
   glm_vec4_swizzle(v1, GLM_YYYY, v1);
-  test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2});
+  ASSERT(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}).status == 1)
 
   v1[0] = 1;
   v1[1] = 2;
@@ -211,7 +207,7 @@ test_vec4(void **state) {
   v1[3] = 4;
 
   glm_vec4_swizzle(v1, GLM_ZZZZ, v1);
-  test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3});
+  ASSERT(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}).status == 1)
 
   v1[0] = 1;
   v1[1] = 2;
@@ -219,7 +215,7 @@ test_vec4(void **state) {
   v1[3] = 4;
 
   glm_vec4_swizzle(v1, GLM_WWWW, v1);
-  test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4});
+  ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1)
 
   /* structs */
   vs1 = test_rand_vec4s();
@@ -227,5 +223,7 @@ test_vec4(void **state) {
 
   vs3 = glms_vec4_add(vs1, vs2);
   vs4 = glms_vec4_maxv(vs1, vs3);
-  test_assert_vec4s_eq(vs3, vs4);
+  ASSERT(test_assert_vec4s_eq(vs3, vs4).status == 1)
+
+  TEST_SUCCESS
 }

test/tests.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef tests_h
+#define tests_h
+
+#include "include/common.h"
+
+/*
+ * To register a test:
+ *   1. use TEST_DECLARE() to forward declare test
+ *   2. use TEST_ENTRY() to add test to list
+ */
+
+/* mat4 */
+TEST_DECLARE(mat4_identity)
+TEST_DECLARE(mat4_mul)
+TEST_DECLARE(mat4_all)
+
+TEST_DECLARE(affine)
+
+/* mat3 */
+TEST_DECLARE(mat3_identity)
+TEST_DECLARE(mat3_mul)
+TEST_DECLARE(mat3_inv)
+
+/* camera */
+TEST_DECLARE(camera_lookat)
+TEST_DECLARE(camera_decomp)
+
+/* project */
+TEST_DECLARE(project)
+
+/* utils */
+TEST_DECLARE(clamp)
+
+/* euler */
+TEST_DECLARE(euler)
+
+/* quat */
+TEST_DECLARE(quat)
+
+/* bezier */
+TEST_DECLARE(bezier)
+
+/* vec3 */
+TEST_DECLARE(vec3)
+
+/* vec4 */
+TEST_DECLARE(vec4)
+
+/*****************************************************************************/
+
+TEST_LIST {
+  /* mat4 */
+  TEST_ENTRY(mat4_identity)
+  TEST_ENTRY(mat4_mul)
+  TEST_ENTRY(mat4_all)
+  
+  TEST_ENTRY(affine)
+  
+  /* mat3 */
+  TEST_ENTRY(mat3_identity)
+  TEST_ENTRY(mat3_mul)
+  TEST_ENTRY(mat3_inv)
+  
+  /* camera */
+  TEST_ENTRY(camera_lookat)
+  TEST_ENTRY(camera_decomp)
+  
+  /* project */
+  TEST_ENTRY(project)
+  
+  /* utils */
+  TEST_ENTRY(clamp)
+  
+  /* euler */
+  TEST_ENTRY(euler)
+  
+  /* quat */
+  TEST_ENTRY(quat)
+  
+  /* bezier */
+  TEST_ENTRY(bezier)
+
+  /* vec3 */
+  TEST_ENTRY(vec3)
+
+  /* vec4 */
+  TEST_ENTRY(vec4)
+};
+
+#endif /* tests_h */