From ba694f4aecabde7d99ef3e42b6b66a8d317138fb Mon Sep 17 00:00:00 2001
From: Recep Aslantas <info@recp.me>
Date: Thu, 19 Sep 2019 16:12:27 +0300
Subject: [PATCH] tests: add some tests for vec3

---
 test/include/common.h         |  11 +-
 test/src/test_vec3.c          | 112 +------
 test/src/test_vec3.h          | 581 ++++++++++++++++++++++++++++++++++
 test/src/tests-test_mat4.gcno | Bin 83560 -> 0 bytes
 test/tests.h                  | 152 ++++++++-
 5 files changed, 749 insertions(+), 107 deletions(-)
 create mode 100644 test/src/test_vec3.h
 delete mode 100644 test/src/tests-test_mat4.gcno

diff --git a/test/include/common.h b/test/include/common.h
index d3d03a9..ac7059a 100644
--- a/test/include/common.h
+++ b/test/include/common.h
@@ -10,6 +10,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 
 #include <cglm/cglm.h>
 #include <cglm/struct.h>
@@ -102,13 +103,13 @@ typedef struct test_entry_t {
   } while(0);
 
 #if defined(_WIN32)
-# define drand48() ((float)(rand() / (RAND_MAX + 1.0)))
-# define OK_TEXT "ok:"
-# define FAIL_TEXT "fail:"
+# define drand48()  ((float)(rand() / (RAND_MAX + 1.0)))
+# define OK_TEXT    "ok:"
+# define FAIL_TEXT  "fail:"
 # define FINAL_TEXT "^_^"
 #else
-# define OK_TEXT "✔︎"
-# define FAIL_TEXT "𐄂"
+# define OK_TEXT    "✔︎"
+# define FAIL_TEXT  "𐄂"
 # define FINAL_TEXT "🎉"
 #endif
 
diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c
index 5db3b32..318d306 100644
--- a/test/src/test_vec3.c
+++ b/test/src/test_vec3.c
@@ -5,110 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline mat3 */
 
-TEST_IMPL(vec3) {
-  mat3  rot1m3;
-  mat4  rot1;
-  vec3  v, v1, v2;
-  vec3s vs1, vs2, vs3, vs4;
+#define GLM_PREFIX glm_
+#define GLM(X) (glm_ ## X)
 
-  /* test zero */
-  glm_vec3_zero(v);
-  ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ZERO, v))
+#include "test_vec3.h"
 
-  /* test one */
-  glm_vec3_one(v);
-  ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ONE, v))
+#undef GLM
+#undef GLM_PREFIX
 
-  /* adds, subs, div, divs, mul */
-  glm_vec3_add(v, GLM_VEC3_ONE, v);
-  ASSERT(glmc_vec3_eq_eps(v, 2))
+/* test pre-compiled mat3 */
 
-  glm_vec3_adds(v, 10, v);
-  ASSERT(glmc_vec3_eq_eps(v, 12))
+#define GLM_PREFIX glmc_
+#define GLM(X) (glmc_ ## X)
 
-  glm_vec3_sub(v, GLM_VEC3_ONE, v);
-  ASSERT(glmc_vec3_eq_eps(v, 11))
+#include "test_vec3.h"
 
-  glm_vec3_subs(v, 1, v);
-  ASSERT(glmc_vec3_eq_eps(v, 10))
-
-  glm_vec3_broadcast(2, v1);
-  glm_vec3_div(v, v1, v);
-  ASSERT(glmc_vec3_eq_eps(v, 5))
-
-  glm_vec3_divs(v, 0.5, v);
-  ASSERT(glmc_vec3_eq_eps(v, 10))
-
-  glm_vec3_mul(v, v1, v);
-  ASSERT(glmc_vec3_eq_eps(v, 20))
-
-  glm_vec3_scale(v, 0.5, v);
-  ASSERT(glmc_vec3_eq_eps(v, 10))
-
-  glm_vec3_normalize_to(v, v1);
-  glm_vec3_scale(v1, 0.8f, v1);
-  glm_vec3_scale_as(v, 0.8f, v);
-  ASSERTIFY(test_assert_vec3_eq(v1, v))
-
-  /* addadd, subadd, muladd */
-  glm_vec3_one(v);
-
-  glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v);
-  ASSERT(glmc_vec3_eq_eps(v, 3))
-
-  glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v);
-  ASSERT(glmc_vec3_eq_eps(v, 4))
-
-  glm_vec3_broadcast(2, v1);
-  glm_vec3_broadcast(3, v2);
-  glm_vec3_muladd(v1, v2, v);
-  ASSERT(glmc_vec3_eq_eps(v, 10))
-
-  /* rotate */
-  glm_vec3_copy(GLM_YUP, v);
-  glm_rotate_make(rot1, glm_rad(90), GLM_XUP);
-  glm_vec3_rotate_m4(rot1, v, v1);
-  glm_mat4_pick3(rot1, rot1m3);
-  glm_vec3_rotate_m3(rot1m3, v, v2);
-
-  ASSERTIFY(test_assert_vec3_eq(v1, v2))
-  ASSERTIFY(test_assert_vec3_eq(v1, GLM_ZUP))
-
-  /* structs */
-  vs1 = test_rand_vec3s();
-  vs2 = test_rand_vec3s();
-
-  vs3 = glms_vec3_add(vs1, vs2);
-  vs4 = glms_vec3_maxv(vs1, vs3);
-  ASSERTIFY(test_assert_vec3s_eq(vs3, vs4))
-
-  /* swizzle */
-
-  /* ZYX */
-  v1[0] = 1;
-  v1[1] = 2;
-  v1[2] = 3;
-  glm_vec3_swizzle(v1, GLM_ZYX, v1);
-  ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 2, 1}))
-
-  glm_vec3_swizzle(v1, GLM_XXX, v1);
-  ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3}))
-
-  v1[0] = 1;
-  v1[1] = 2;
-  v1[2] = 3;
-
-  glm_vec3_swizzle(v1, GLM_YYY, v1);
-  ASSERTIFY(test_assert_vec3_eq(v1, (vec3){2, 2, 2}))
-
-  v1[0] = 1;
-  v1[1] = 2;
-  v1[2] = 3;
-
-  glm_vec3_swizzle(v1, GLM_ZZZ, v1);
-  ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3}))
-
-  TEST_SUCCESS
-}
+#undef GLM
+#undef GLM_PREFIX
diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h
new file mode 100644
index 0000000..ff60497
--- /dev/null
+++ b/test/src/test_vec3.h
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define TEST_GLM_SHUFFLE3(z, y, x) (((z) << 4) | ((y) << 2) | (x))
+
+#ifndef CGLM_TEST_VEC3_ONCE
+#define CGLM_TEST_VEC3_ONCE
+
+/* Macros */
+
+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))
+  
+  TEST_SUCCESS
+}
+
+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))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC3_ONE) {
+  vec3 v = GLM_VEC3_ONE;
+  
+  ASSERT(glm_eq(v[0], 1.0f))
+  ASSERT(glm_eq(v[1], 1.0f))
+  ASSERT(glm_eq(v[2], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC3_ZERO) {
+  vec3 v = GLM_VEC3_ZERO;
+  
+  ASSERT(glm_eq(v[0], 0.0f))
+  ASSERT(glm_eq(v[1], 0.0f))
+  ASSERT(glm_eq(v[2], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_YUP) {
+  vec3 v = GLM_YUP;
+  
+  ASSERT(glm_eq(v[0], 0.0f))
+  ASSERT(glm_eq(v[1], 1.0f))
+  ASSERT(glm_eq(v[2], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_ZUP) {
+  vec3 v = GLM_ZUP;
+  
+  ASSERT(glm_eq(v[0], 0.0f))
+  ASSERT(glm_eq(v[1], 0.0f))
+  ASSERT(glm_eq(v[2], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_XUP) {
+  vec3 v = GLM_XUP;
+  
+  ASSERT(glm_eq(v[0], 1.0f))
+  ASSERT(glm_eq(v[1], 0.0f))
+  ASSERT(glm_eq(v[2], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_SHUFFLE3) {
+  ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0))
+  ASSERT(TEST_GLM_SHUFFLE3(0, 1, 0) == GLM_SHUFFLE3(0, 1, 0))
+  ASSERT(TEST_GLM_SHUFFLE3(0, 0, 1) == GLM_SHUFFLE3(0, 0, 1))
+  ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0))
+  ASSERT(TEST_GLM_SHUFFLE3(1, 0, 1) == GLM_SHUFFLE3(1, 0, 1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_XXX) {
+  ASSERT(TEST_GLM_SHUFFLE3(0, 0, 0) == GLM_XXX)
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_YYY) {
+  ASSERT(TEST_GLM_SHUFFLE3(1, 1, 1) == GLM_YYY)
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_ZZZ) {
+  ASSERT(TEST_GLM_SHUFFLE3(2, 2, 2) == GLM_ZZZ)
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_ZYX) {
+  ASSERT(TEST_GLM_SHUFFLE3(0, 1, 2) == GLM_ZYX)
+  TEST_SUCCESS
+}
+
+/* Deprecated */
+
+TEST_IMPL(MACRO_glm_vec3_dup) {
+  vec3 v1 = {13.0f, 12.0f, 11.0f}, v2;
+  
+  glm_vec3_dup(v1, v2);
+  
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_glm_vec3_flipsign) {
+  vec3 v1 = {13.0f, -12.0f, 11.0f},
+       v2 = {-13.0f, 12.0f, -11.0f};
+  
+  glm_vec3_flipsign(v1);
+
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_glm_vec3_flipsign_to) {
+  vec3 v1 = {13.0f, -12.0f, 11.0f},
+       v2 = {-13.0f, 12.0f, -11.0f},
+       v3;
+  
+  glm_vec3_flipsign_to(v1, v3);
+
+  ASSERTIFY(test_assert_vec3_eq(v2, v3))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_glm_vec3_inv) {
+  vec3 v1 = {13.0f, -12.0f, 11.0f},
+       v2 = {-13.0f, 12.0f, -11.0f};
+  
+  glm_vec3_inv(v1);
+
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_glm_vec3_inv_to) {
+  vec3 v1 = {13.0f, -12.0f, 11.0f},
+       v2 = {-13.0f, 12.0f, -11.0f},
+       v3;
+  
+  glm_vec3_inv_to(v1, v3);
+  
+  ASSERTIFY(test_assert_vec3_eq(v2, v3))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_glm_vec3_mulv) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3;
+  
+  glm_vec3_mulv(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]))
+  
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_VEC3_ONCE */
+
+/* --- */
+
+TEST_IMPL(GLM_PREFIX, vec3) {
+  vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f};
+  vec3 v3;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_copy) {
+  vec3 v1 = {10.0f, 9.0f, 8.0f};
+  vec3 v2 = {1.0f, 2.0f, 3.0f};
+  
+  GLM(vec3_copy)(v1, v2);
+  
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_zero) {
+  vec3 v1 = {10.0f, 9.0f, 8.0f};
+  vec3 v2 = {1.0f, 2.0f, 3.0f};
+  
+  GLM(vec3_zero)(v1);
+  GLM(vec3_zero)(v2);
+  
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_one) {
+  vec3 v1 = {10.0f, 9.0f, 8.0f};
+  vec3 v2 = {1.0f, 2.0f, 3.0f};
+  
+  GLM(vec3_one)(v1);
+  GLM(vec3_one)(v2);
+  
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ONE))
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ONE))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_dot) {
+  vec3  a = {10.0f, 9.0f, 8.0f};
+  vec3  b = {1.0f, 2.0f, 3.0f};
+  float dot1, dot2;
+  
+  dot1 = GLM(vec3_dot)(a, b);
+  dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  
+  ASSERT(glm_eq(dot1, dot2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_norm2) {
+  vec3 a = {10.0f, 9.0f, 8.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec3_norm2)(a);
+  n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+
+  ASSERT(glm_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_norm) {
+  vec3  a = {10.0f, 9.0f, 8.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec3_norm)(a);
+  n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+
+  ASSERT(glm_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_norm_one) {
+  vec3  a = {-10.0f, 9.0f, -8.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec3_norm_one)(a);
+  n2 = fabsf(a[0]) + fabsf(a[1]) + fabsf(a[2]);
+
+  ASSERT(glm_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
+  vec3  a = {-10.0f, 9.0f, -8.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec3_norm_inf)(a);
+  n2 = fabsf(a[0]);
+  
+  if (fabsf(a[0]) < fabsf(a[1]))
+    n2 = fabsf(a[1]);
+  
+  if (fabsf(a[1]) < fabsf(a[2]))
+    n2 = fabsf(a[2]);
+  
+  ASSERT(glm_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_add) {
+  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec4 c, d;
+  
+  c[0] = a[0] + b[0];
+  c[1] = a[1] + b[1];
+  c[2] = a[2] + b[2];
+  
+  GLM(vec3_add)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec3_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_adds) {
+  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec4  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] + s;
+  c[1] = a[1] + s;
+  c[2] = a[2] + s;
+  
+  GLM(vec3_adds)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec3_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_sub) {
+  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec4 c, d;
+  
+  c[0] = a[0] - b[0];
+  c[1] = a[1] - b[1];
+  c[2] = a[2] - b[2];
+  
+  GLM(vec3_sub)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec3_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_subs) {
+  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec4  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] - s;
+  c[1] = a[1] - s;
+  c[2] = a[2] - s;
+  
+  GLM(vec3_subs)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec3_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_mul) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_scale) {
+  vec3  v1 = {2.0f, -3.0f, 4.0f}, v2;
+  float s  = 7.0f;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_scale_as) {
+  vec3  v1 = {2.0f, -3.0f, 4.0f}, v2;
+  float s  = 7.0f;
+  float norm;
+
+  GLM(vec3_scale_as)(v1, s, v2);
+
+  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))
+
+    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]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_div) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_divs) {
+  vec3  v1 = {2.0f, -3.0f, 4.0f}, v2;
+  float s  = 7.0f;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_addadd) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {1.0f, 2.0f, 3.0f},
+       v4 = {1.0f, 2.0f, 3.0f};
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_subadd) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {1.0f, 2.0f, 3.0f},
+       v4 = {1.0f, 2.0f, 3.0f};
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_muladd) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {1.0f, 2.0f, 3.0f},
+       v4 = {1.0f, 2.0f, 3.0f};
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_muladds) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {1.0f, 2.0f, 3.0f},
+       v3 = {1.0f, 2.0f, 3.0f};
+  float s = 9.0f;
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_maxadd) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {1.0f, 2.0f, 3.0f},
+       v4 = {1.0f, 2.0f, 3.0f};
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_minadd) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {1.0f, 2.0f, 3.0f},
+       v4 = {1.0f, 2.0f, 3.0f};
+  
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_negate_to) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3, v4;
+  
+  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(glm_eq(-v2[0], v4[0]))
+  ASSERT(glm_eq(-v2[1], v4[1]))
+  ASSERT(glm_eq(-v2[2], v4[2]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_negate) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3 = {2.0f, -3.0f, 4.0f},
+       v4 = {-3.0f, 4.0f, -5.0f};
+  
+  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(glm_eq(-v2[0], v4[0]))
+  ASSERT(glm_eq(-v2[1], v4[1]))
+  ASSERT(glm_eq(-v2[2], v4[2]))
+  
+  TEST_SUCCESS
+}
+
diff --git a/test/src/tests-test_mat4.gcno b/test/src/tests-test_mat4.gcno
deleted file mode 100644
index d58d103ca57c26e8a784b0d9657f55792bd47ed0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 83560
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

diff --git a/test/tests.h b/test/tests.h
index a3bf582..1cded8e 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -127,7 +127,79 @@ TEST_DECLARE(quat)
 TEST_DECLARE(bezier)
 
 /* vec3 */
-TEST_DECLARE(vec3)
+TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT)
+TEST_DECLARE(MACRO_GLM_VEC3_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_VEC3_ONE)
+TEST_DECLARE(MACRO_GLM_VEC3_ZERO)
+TEST_DECLARE(MACRO_GLM_YUP)
+TEST_DECLARE(MACRO_GLM_ZUP)
+TEST_DECLARE(MACRO_GLM_XUP)
+TEST_DECLARE(MACRO_GLM_SHUFFLE3)
+TEST_DECLARE(MACRO_GLM_XXX)
+TEST_DECLARE(MACRO_GLM_YYY)
+TEST_DECLARE(MACRO_GLM_ZZZ)
+TEST_DECLARE(MACRO_GLM_ZYX)
+
+TEST_DECLARE(MACRO_glm_vec3_dup)
+TEST_DECLARE(MACRO_glm_vec3_flipsign)
+TEST_DECLARE(MACRO_glm_vec3_flipsign_to)
+TEST_DECLARE(MACRO_glm_vec3_inv)
+TEST_DECLARE(MACRO_glm_vec3_inv_to)
+TEST_DECLARE(MACRO_glm_vec3_mulv)
+
+TEST_DECLARE(glm_vec3)
+TEST_DECLARE(glm_vec3_copy)
+TEST_DECLARE(glm_vec3_zero)
+TEST_DECLARE(glm_vec3_one)
+TEST_DECLARE(glm_vec3_dot)
+TEST_DECLARE(glm_vec3_norm2)
+TEST_DECLARE(glm_vec3_norm)
+TEST_DECLARE(glm_vec3_norm_one)
+TEST_DECLARE(glm_vec3_norm_inf)
+TEST_DECLARE(glm_vec3_add)
+TEST_DECLARE(glm_vec3_adds)
+TEST_DECLARE(glm_vec3_sub)
+TEST_DECLARE(glm_vec3_subs)
+TEST_DECLARE(glm_vec3_mul)
+TEST_DECLARE(glm_vec3_scale)
+TEST_DECLARE(glm_vec3_scale_as)
+TEST_DECLARE(glm_vec3_div)
+TEST_DECLARE(glm_vec3_divs)
+TEST_DECLARE(glm_vec3_addadd)
+TEST_DECLARE(glm_vec3_subadd)
+TEST_DECLARE(glm_vec3_muladd)
+TEST_DECLARE(glm_vec3_muladds)
+TEST_DECLARE(glm_vec3_maxadd)
+TEST_DECLARE(glm_vec3_minadd)
+TEST_DECLARE(glm_vec3_negate_to)
+TEST_DECLARE(glm_vec3_negate)
+
+TEST_DECLARE(glmc_vec3)
+TEST_DECLARE(glmc_vec3_copy)
+TEST_DECLARE(glmc_vec3_zero)
+TEST_DECLARE(glmc_vec3_one)
+TEST_DECLARE(glmc_vec3_dot)
+TEST_DECLARE(glmc_vec3_norm2)
+TEST_DECLARE(glmc_vec3_norm)
+TEST_DECLARE(glmc_vec3_norm_one)
+TEST_DECLARE(glmc_vec3_norm_inf)
+TEST_DECLARE(glmc_vec3_add)
+TEST_DECLARE(glmc_vec3_adds)
+TEST_DECLARE(glmc_vec3_sub)
+TEST_DECLARE(glmc_vec3_subs)
+TEST_DECLARE(glmc_vec3_mul)
+TEST_DECLARE(glmc_vec3_scale)
+TEST_DECLARE(glmc_vec3_scale_as)
+TEST_DECLARE(glmc_vec3_div)
+TEST_DECLARE(glmc_vec3_divs)
+TEST_DECLARE(glmc_vec3_addadd)
+TEST_DECLARE(glmc_vec3_subadd)
+TEST_DECLARE(glmc_vec3_muladd)
+TEST_DECLARE(glmc_vec3_muladds)
+TEST_DECLARE(glmc_vec3_maxadd)
+TEST_DECLARE(glmc_vec3_minadd)
+TEST_DECLARE(glmc_vec3_negate_to)
+TEST_DECLARE(glmc_vec3_negate)
 
 /* vec4 */
 TEST_DECLARE(vec4)
@@ -246,8 +318,84 @@ TEST_LIST {
   TEST_ENTRY(bezier)
 
   /* vec3 */
-  TEST_ENTRY(vec3)
 
+  /* Macros */
+
+  TEST_ENTRY(MACRO_GLM_VEC3_ONE_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC3_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC3_ONE)
+  TEST_ENTRY(MACRO_GLM_VEC3_ZERO)
+  TEST_ENTRY(MACRO_GLM_YUP)
+  TEST_ENTRY(MACRO_GLM_ZUP)
+  TEST_ENTRY(MACRO_GLM_XUP)
+  TEST_ENTRY(MACRO_GLM_SHUFFLE3)
+  TEST_ENTRY(MACRO_GLM_XXX)
+  TEST_ENTRY(MACRO_GLM_YYY)
+  TEST_ENTRY(MACRO_GLM_ZZZ)
+  TEST_ENTRY(MACRO_GLM_ZYX)
+
+  TEST_ENTRY(MACRO_glm_vec3_dup)
+  TEST_ENTRY(MACRO_glm_vec3_flipsign)
+  TEST_ENTRY(MACRO_glm_vec3_flipsign_to)
+  TEST_ENTRY(MACRO_glm_vec3_inv)
+  TEST_ENTRY(MACRO_glm_vec3_inv_to)
+  TEST_ENTRY(MACRO_glm_vec3_mulv)
+
+  TEST_ENTRY(glm_vec3)
+  TEST_ENTRY(glm_vec3_copy)
+  TEST_ENTRY(glm_vec3_zero)
+  TEST_ENTRY(glm_vec3_one)
+  TEST_ENTRY(glm_vec3_dot)
+  TEST_ENTRY(glm_vec3_norm2)
+  TEST_ENTRY(glm_vec3_norm)
+  TEST_ENTRY(glm_vec3_norm_one)
+  TEST_ENTRY(glm_vec3_norm_inf)
+  TEST_ENTRY(glm_vec3_add)
+  TEST_ENTRY(glm_vec3_adds)
+  TEST_ENTRY(glm_vec3_sub)
+  TEST_ENTRY(glm_vec3_subs)
+  TEST_ENTRY(glm_vec3_mul)
+  TEST_ENTRY(glm_vec3_scale)
+  TEST_ENTRY(glm_vec3_scale_as)
+  TEST_ENTRY(glm_vec3_div)
+  TEST_ENTRY(glm_vec3_divs)
+  TEST_ENTRY(glm_vec3_addadd)
+  TEST_ENTRY(glm_vec3_subadd)
+  TEST_ENTRY(glm_vec3_muladd)
+  TEST_ENTRY(glm_vec3_muladds)
+  TEST_ENTRY(glm_vec3_maxadd)
+  TEST_ENTRY(glm_vec3_minadd)
+  TEST_ENTRY(glm_vec3_negate_to)
+  TEST_ENTRY(glm_vec3_negate)
+  
+
+  TEST_ENTRY(glmc_vec3)
+  TEST_ENTRY(glmc_vec3_copy)
+  TEST_ENTRY(glmc_vec3_zero)
+  TEST_ENTRY(glmc_vec3_one)
+  TEST_ENTRY(glmc_vec3_dot)
+  TEST_ENTRY(glmc_vec3_norm2)
+  TEST_ENTRY(glmc_vec3_norm)
+  TEST_ENTRY(glmc_vec3_norm_one)
+  TEST_ENTRY(glmc_vec3_norm_inf)
+  TEST_ENTRY(glmc_vec3_add)
+  TEST_ENTRY(glmc_vec3_adds)
+  TEST_ENTRY(glmc_vec3_sub)
+  TEST_ENTRY(glmc_vec3_subs)
+  TEST_ENTRY(glmc_vec3_mul)
+  TEST_ENTRY(glmc_vec3_scale)
+  TEST_ENTRY(glmc_vec3_scale_as)
+  TEST_ENTRY(glmc_vec3_div)
+  TEST_ENTRY(glmc_vec3_divs)
+  TEST_ENTRY(glmc_vec3_addadd)
+  TEST_ENTRY(glmc_vec3_subadd)
+  TEST_ENTRY(glmc_vec3_muladd)
+  TEST_ENTRY(glmc_vec3_muladds)
+  TEST_ENTRY(glmc_vec3_maxadd)
+  TEST_ENTRY(glmc_vec3_minadd)
+  TEST_ENTRY(glmc_vec3_negate_to)
+  TEST_ENTRY(glmc_vec3_negate)
+  
   /* vec4 */
   TEST_ENTRY(vec4)
 };