add tests for vec2 and its call version

include/cglm/struct/mat2.h

@@ -35,7 +35,6 @@
 #include "../common.h"
 #include "../types-struct.h"
 #include "../mat2.h"
-#include "vec2.h"
 
 #define GLMS_MAT2_IDENTITY_INIT {1.0f, 0.0f, 0.0f, 1.0f}
 #define GLMS_MAT2_ZERO_INIT     {0.0f, 0.0f, 0.0f, 0.0f}

include/cglm/types-struct.h

@@ -113,7 +113,7 @@ typedef union mat2s {
 } mat2s;
 
 typedef union mat3s {
-  mat3 raw;
+  mat3  raw;
   vec3s col[3];
 #if CGLM_USE_ANONYMOUS_STRUCT
   struct {
@@ -125,7 +125,7 @@ typedef union mat3s {
 } mat3s;
 
 typedef union CGLM_ALIGN_MAT mat4s {
-  mat4 raw;
+  mat4  raw;
   vec4s col[4];
 #if CGLM_USE_ANONYMOUS_STRUCT
   struct {

src/vec2.c

@@ -53,7 +53,7 @@ glmc_vec2_norm2(vec2 v) {
 CGLM_EXPORT
 float
 glmc_vec2_norm(vec2 v) {
-  return glm_vec2_norm2(v);
+  return glm_vec2_norm(v);
 }
 
 CGLM_EXPORT

test/src/test_tests.h

@@ -1,50 +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);
-
-/* vec2 */
-void
-test_vec2(void **state);
-
-#endif /* test_tests_h */

test/src/test_vec2.c

@@ -1,13 +0,0 @@
-/*
- * 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"
-
-void
-test_vec2(void **state) {
- 
-}

test/src/test_vec2.h

@@ -0,0 +1,596 @@
+/*
+ * 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"
+
+#ifndef CGLM_TEST_VEC2_ONCE
+#define CGLM_TEST_VEC2_ONCE
+
+/* Macros */
+
+TEST_IMPL(MACRO_GLM_VEC2_ONE_INIT) {
+  vec2 v = GLM_VEC2_ONE_INIT;
+  
+  ASSERT(test_eq(v[0], 1.0f))
+  ASSERT(test_eq(v[1], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ZERO_INIT) {
+  vec2 v = GLM_VEC2_ZERO_INIT;
+  
+  ASSERT(test_eq(v[0], 0.0f))
+  ASSERT(test_eq(v[1], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ONE) {
+  ASSERT(test_eq(GLM_VEC2_ONE[0], 1.0f))
+  ASSERT(test_eq(GLM_VEC2_ONE[1], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ZERO) {
+  ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
+  ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_VEC2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, vec2) {
+  vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f};
+  vec3 v3 = {11.0f, 12.0f, 13.0f};
+  vec2 v2;
+  
+  GLM(vec2)(v4, v2);
+  ASSERT(test_eq(v2[0], v4[0]))
+  ASSERT(test_eq(v2[1], v4[1]))
+  
+  GLM(vec2)(v3, v2);
+  ASSERT(test_eq(v2[0], v3[0]))
+  ASSERT(test_eq(v2[1], v3[1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_copy) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_copy)(v1, v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_zero) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_zero)(v1);
+  GLM(vec2_zero)(v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_one) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_one)(v1);
+  GLM(vec2_one)(v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ONE))
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ONE))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_dot) {
+  vec2  a = {10.0f, 9.0f};
+  vec2  b = {1.0f, 2.0f};
+  float dot1, dot2;
+  
+  dot1 = GLM(vec2_dot)(a, b);
+  dot2 = a[0] * b[0] + a[1] * b[1];
+  
+  ASSERT(test_eq(dot1, dot2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_cross) {
+  vec2  a = {10.0f, 9.0f};
+  vec2  b = {1.0f, 2.0f};
+  float cprod;
+
+  cprod = a[0] * b[1] - a[1] * b[0];
+
+  ASSERT(test_eq(glm_vec2_cross(a, b), cprod))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_norm2) {
+  vec2 a = {10.0f, 9.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec2_norm2)(a);
+  n2 = a[0] * a[0] + a[1] * a[1];
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_norm) {
+  vec2  a = {10.0f, 9.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec2_norm)(a);
+  n2 = sqrtf(a[0] * a[0] + a[1] * a[1]);
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_add) {
+  vec2 a = {-10.0f, 9.0f};
+  vec2 b = {12.0f, 19.0f};
+  vec2 c, d;
+  
+  c[0] = a[0] + b[0];
+  c[1] = a[1] + b[1];
+  
+  GLM(vec2_add)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_adds) {
+  vec4  a = {-10.0f, 9.0f};
+  vec4  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] + s;
+  c[1] = a[1] + s;
+  
+  GLM(vec2_adds)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_sub) {
+  vec2 a = {-10.0f, 9.0f};
+  vec2 b = {12.0f, 19.0f};
+  vec2 c, d;
+  
+  c[0] = a[0] - b[0];
+  c[1] = a[1] - b[1];
+  
+  GLM(vec2_sub)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_subs) {
+  vec2  a = {-10.0f, 9.0f};
+  vec2  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] - s;
+  c[1] = a[1] - s;
+  
+  GLM(vec2_subs)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_mul) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3;
+  
+  GLM(vec2_mul)(v1, v2, v3);
+
+  ASSERT(test_eq(v1[0] * v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] * v2[1], v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_scale) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  
+  GLM(vec2_scale)(v1, s, v2);
+
+  ASSERT(test_eq(v1[0] * s, v2[0]))
+  ASSERT(test_eq(v1[1] * s, v2[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_scale_as) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  float norm;
+
+  GLM(vec2_scale_as)(v1, s, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_div) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3;
+  
+  GLM(vec2_div)(v1, v2, v3);
+
+  ASSERT(test_eq(v1[0] / v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] / v2[1], v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_divs) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  
+  GLM(vec2_divs)(v1, s, v2);
+
+  ASSERT(test_eq(v1[0] / s, v2[0]))
+  ASSERT(test_eq(v1[1] / s, v2[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_addadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_addadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_subadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_subadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_muladd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_muladd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_muladds) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {1.0f, 2.0f},
+       v3 = {1.0f, 2.0f};
+  float s = 9.0f;
+  
+  GLM(vec2_muladds)(v1, s, v3);
+
+  ASSERT(test_eq(v2[0] + v1[0] * s, v3[0]))
+  ASSERT(test_eq(v2[1] + v1[1] * s, v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_maxadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_maxadd)(v1, v2, v4);
+
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_minadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_minadd)(v1, v2, v4);
+
+  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]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_negate_to) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3, v4;
+  
+  GLM(vec2_negate_to)(v1, v3);
+  GLM(vec2_negate_to)(v2, v4);
+
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_negate) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {2.0f, -3.0f},
+       v4 = {-3.0f, 4.0f};
+  
+  GLM(vec2_negate)(v1);
+  GLM(vec2_negate)(v2);
+
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_normalize) {
+  vec2  v1 = {2.0f, -3.0f}, v2 = {2.0f, -3.0f};
+  float s  = 1.0f;
+  float norm;
+
+  GLM(vec2_normalize)(v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  glm_vec2_zero(v1);
+  GLM(vec2_normalize)(v1);
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_normalize_to) {
+  vec2 v1 = {2.0f, -3.0f}, v2;
+  float s  = 1.0f;
+  float norm;
+
+  GLM(vec2_normalize_to)(v1, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  glm_vec2_zero(v1);
+  GLM(vec2_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_rotate) {
+  vec2 v1 = {1.0f, 0.0f};
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 1.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_distance2) {
+  vec2 v1 = {30.0f, 0.0f},
+       v2 = {0.0f, 0.0f},
+       v3 = {3.0f, 10.0f},
+       v4 = {0.46f, 4.0f};
+  float d;
+
+  d = GLM(vec2_distance2)(v1, v2);
+  ASSERT(test_eq(d, 30.0f * 30.0f))
+
+  d = GLM(vec2_distance2)(v3, v4);
+  ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f)
+               + powf(v3[1] - v4[1], 2.0f), d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_distance) {
+  vec2 v1 = {30.0f, 0.0f},
+       v2 = {0.0f, 0.0f},
+       v3 = {3.0f, 10.0f},
+       v4 = {0.46f, 4.0f};
+  float d;
+
+  d = GLM(vec2_distance)(v1, v2);
+  ASSERT(test_eq(d, 30.0f))
+
+  d = GLM(vec2_distance)(v3, v4);
+  ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f)
+                     + powf(v3[1] - v4[1], 2.0f)), d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_maxv) {
+  vec2 v1, v2, v3;
+  vec2 v5 = {-1.456f, -1.456f};
+  vec2 v6 = {11.0f, 11.0f};
+  vec2 v7 = {78.0f, -78.0f};
+
+  GLM(vec2_maxv)(v5, v6, v1);
+  GLM(vec2_maxv)(v5, v7, v2);
+  GLM(vec2_maxv)(v6, v7, v3);
+
+  ASSERT(test_eq(v1[0], 11.0f))
+  ASSERT(test_eq(v1[1], 11.0f))
+
+  ASSERT(test_eq(v2[0], 78.0f))
+  ASSERT(test_eq(v2[1], -1.456f))
+
+  ASSERT(test_eq(v3[0], 78.0f))
+  ASSERT(test_eq(v3[1], 11.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_minv) {
+  vec2 v1, v2, v3;
+  vec2 v5 = {-1.456f, -1.456f};
+  vec2 v6 = {11.0f, 11.0f};
+  vec2 v7 = {78.0f, -78.0f};
+
+  GLM(vec2_minv)(v5, v6, v1);
+  GLM(vec2_minv)(v5, v7, v2);
+  GLM(vec2_minv)(v6, v7, v3);
+
+  ASSERT(test_eq(v1[0], -1.456f))
+  ASSERT(test_eq(v1[1], -1.456f))
+
+  ASSERT(test_eq(v2[0], -1.456f))
+  ASSERT(test_eq(v2[1], -78.0f))
+
+  ASSERT(test_eq(v3[0], 11.0f))
+  ASSERT(test_eq(v3[1], -78.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_clamp) {
+  vec2 v1 = {-1.456f, -11.456f};
+  vec2 v2 = {0.110f, 111.0f};
+  vec2 v3 = {78.0f, 32.0f};
+
+  GLM(vec2_clamp)(v1, -1.03f, 30.0f);
+  GLM(vec2_clamp)(v2,  0.11f, 111.0f);
+  GLM(vec2_clamp)(v3, -88.0f, 70.0f);
+
+  ASSERT(test_eq(v1[0], -1.03f))
+  ASSERT(test_eq(v1[1], -1.03f))
+  
+  ASSERT(test_eq(v2[0],  0.11f))
+  ASSERT(test_eq(v2[1],  111.0f))
+  
+  ASSERT(test_eq(v3[0],  70.0f))
+  ASSERT(test_eq(v3[1],  32.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_lerp) {
+  vec2 v1 = {-100.0f, -200.0f};
+  vec2 v2 = {100.0f, 200.0f};
+  vec2 v3;
+
+  GLM(vec2_lerp)(v1, v2, 0.5f, v3);
+  ASSERT(test_eq(v3[0], 0.0f))
+  ASSERT(test_eq(v3[1], 0.0f))
+  
+  GLM(vec2_lerp)(v1, v2, 0.75f, v3);
+  ASSERT(test_eq(v3[0], 50.0f))
+  ASSERT(test_eq(v3[1], 100.0f))
+
+  TEST_SUCCESS
+}

test/src/test_vec3.h

@@ -233,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, vec3_zero) {
   GLM(vec3_zero)(v2);
   
   ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
-  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+  ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
   
   TEST_SUCCESS
 }
@@ -335,9 +335,9 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_add) {
-  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec3 a = {-10.0f, 9.0f, -8.0f};
-  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec3 b = {12.0f, 19.0f, -18.0f};
-  vec4 c, d;
+  vec3 c, d;
   
   c[0] = a[0] + b[0];
   c[1] = a[1] + b[1];
@@ -351,8 +351,8 @@ TEST_IMPL(GLM_PREFIX, vec3_add) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_adds) {
-  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec3  a = {-10.0f, 9.0f, -8.0f};
-  vec4  c, d;
+  vec3  c, d;
   float s = 7.0f;
   
   c[0] = a[0] + s;
@@ -367,9 +367,9 @@ TEST_IMPL(GLM_PREFIX, vec3_adds) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_sub) {
-  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec3 a = {-10.0f, 9.0f, -8.0f};
-  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec3 b = {12.0f, 19.0f, -18.0f};
-  vec4 c, d;
+  vec3 c, d;
   
   c[0] = a[0] - b[0];
   c[1] = a[1] - b[1];
@@ -383,8 +383,8 @@ TEST_IMPL(GLM_PREFIX, vec3_sub) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_subs) {
-  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec3  a = {-10.0f, 9.0f, -8.0f};
-  vec4  c, d;
+  vec3  c, d;
   float s = 7.0f;
   
   c[0] = a[0] - s;
@@ -928,7 +928,6 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) {
   TEST_SUCCESS
 }
 
-
 TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) {
   vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f};
   mat4 x0, y0, z0;

test/src/test_vec4.h

@@ -217,7 +217,7 @@ TEST_IMPL(GLM_PREFIX, vec4_zero) {
   GLM(vec4_zero)(v2);
   
   ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
-  ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
+  ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ZERO))
   
   TEST_SUCCESS
 }
@@ -230,7 +230,7 @@ TEST_IMPL(GLM_PREFIX, vec4_one) {
   GLM(vec4_one)(v2);
   
   ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
-  ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
+  ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ONE))
   
   TEST_SUCCESS
 }

test/src/tests.c

@@ -12,6 +12,7 @@
 #define GLM_PREFIX glm_
 #define GLM(X) (glm_ ## X)
 
+#include "test_vec2.h"
 #include "test_vec3.h"
 #include "test_vec4.h"
 #include "test_mat3.h"
@@ -31,6 +32,7 @@
 #define GLM_PREFIX glmc_
 #define GLM(X) (glmc_ ## X)
 
+#include "test_vec2.h"
 #include "test_vec3.h"
 #include "test_vec4.h"
 #include "test_mat3.h"

test/tests.h

@@ -261,6 +261,85 @@ TEST_DECLARE(glmc_quat_rotate_atm)
 /* bezier */
 TEST_DECLARE(bezier)
 
+
+/* Macros */
+
+TEST_DECLARE(MACRO_GLM_VEC2_ONE_INIT)
+TEST_DECLARE(MACRO_GLM_VEC2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_VEC2_ONE)
+TEST_DECLARE(MACRO_GLM_VEC2_ZERO)
+
+TEST_DECLARE(glm_vec2)
+TEST_DECLARE(glm_vec2_copy)
+TEST_DECLARE(glm_vec2_zero)
+TEST_DECLARE(glm_vec2_one)
+TEST_DECLARE(glm_vec2_dot)
+TEST_DECLARE(glm_vec2_cross)
+TEST_DECLARE(glm_vec2_norm2)
+TEST_DECLARE(glm_vec2_norm)
+TEST_DECLARE(glm_vec2_add)
+TEST_DECLARE(glm_vec2_adds)
+TEST_DECLARE(glm_vec2_sub)
+TEST_DECLARE(glm_vec2_subs)
+TEST_DECLARE(glm_vec2_mul)
+TEST_DECLARE(glm_vec2_scale)
+TEST_DECLARE(glm_vec2_scale_as)
+TEST_DECLARE(glm_vec2_div)
+TEST_DECLARE(glm_vec2_divs)
+TEST_DECLARE(glm_vec2_addadd)
+TEST_DECLARE(glm_vec2_subadd)
+TEST_DECLARE(glm_vec2_muladd)
+TEST_DECLARE(glm_vec2_muladds)
+TEST_DECLARE(glm_vec2_maxadd)
+TEST_DECLARE(glm_vec2_minadd)
+TEST_DECLARE(glm_vec2_negate_to)
+TEST_DECLARE(glm_vec2_negate)
+TEST_DECLARE(glm_vec2_normalize)
+TEST_DECLARE(glm_vec2_normalize_to)
+TEST_DECLARE(glm_vec2_rotate)
+TEST_DECLARE(glm_vec2_distance2)
+TEST_DECLARE(glm_vec2_distance)
+TEST_DECLARE(glm_vec2_maxv)
+TEST_DECLARE(glm_vec2_minv)
+TEST_DECLARE(glm_vec2_clamp)
+TEST_DECLARE(glm_vec2_lerp)
+
+
+TEST_DECLARE(glmc_vec2)
+TEST_DECLARE(glmc_vec2_copy)
+TEST_DECLARE(glmc_vec2_zero)
+TEST_DECLARE(glmc_vec2_one)
+TEST_DECLARE(glmc_vec2_dot)
+TEST_DECLARE(glmc_vec2_cross)
+TEST_DECLARE(glmc_vec2_norm2)
+TEST_DECLARE(glmc_vec2_norm)
+TEST_DECLARE(glmc_vec2_add)
+TEST_DECLARE(glmc_vec2_adds)
+TEST_DECLARE(glmc_vec2_sub)
+TEST_DECLARE(glmc_vec2_subs)
+TEST_DECLARE(glmc_vec2_mul)
+TEST_DECLARE(glmc_vec2_scale)
+TEST_DECLARE(glmc_vec2_scale_as)
+TEST_DECLARE(glmc_vec2_div)
+TEST_DECLARE(glmc_vec2_divs)
+TEST_DECLARE(glmc_vec2_addadd)
+TEST_DECLARE(glmc_vec2_subadd)
+TEST_DECLARE(glmc_vec2_muladd)
+TEST_DECLARE(glmc_vec2_muladds)
+TEST_DECLARE(glmc_vec2_maxadd)
+TEST_DECLARE(glmc_vec2_minadd)
+TEST_DECLARE(glmc_vec2_negate_to)
+TEST_DECLARE(glmc_vec2_negate)
+TEST_DECLARE(glmc_vec2_normalize)
+TEST_DECLARE(glmc_vec2_normalize_to)
+TEST_DECLARE(glmc_vec2_rotate)
+TEST_DECLARE(glmc_vec2_distance2)
+TEST_DECLARE(glmc_vec2_distance)
+TEST_DECLARE(glmc_vec2_maxv)
+TEST_DECLARE(glmc_vec2_minv)
+TEST_DECLARE(glmc_vec2_clamp)
+TEST_DECLARE(glmc_vec2_lerp)
+
 /* vec3 */
 TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT)
 TEST_DECLARE(MACRO_GLM_VEC3_ZERO_INIT)
@@ -834,6 +913,84 @@ TEST_LIST {
   /* bezier */
   TEST_ENTRY(bezier)
 
+  /* Macros */
+
+  TEST_ENTRY(MACRO_GLM_VEC2_ONE_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC2_ONE)
+  TEST_ENTRY(MACRO_GLM_VEC2_ZERO)
+  
+  TEST_ENTRY(glm_vec2)
+  TEST_ENTRY(glm_vec2_copy)
+  TEST_ENTRY(glm_vec2_zero)
+  TEST_ENTRY(glm_vec2_one)
+  TEST_ENTRY(glm_vec2_dot)
+  TEST_ENTRY(glm_vec2_cross)
+  TEST_ENTRY(glm_vec2_norm2)
+  TEST_ENTRY(glm_vec2_norm)
+  TEST_ENTRY(glm_vec2_add)
+  TEST_ENTRY(glm_vec2_adds)
+  TEST_ENTRY(glm_vec2_sub)
+  TEST_ENTRY(glm_vec2_subs)
+  TEST_ENTRY(glm_vec2_mul)
+  TEST_ENTRY(glm_vec2_scale)
+  TEST_ENTRY(glm_vec2_scale_as)
+  TEST_ENTRY(glm_vec2_div)
+  TEST_ENTRY(glm_vec2_divs)
+  TEST_ENTRY(glm_vec2_addadd)
+  TEST_ENTRY(glm_vec2_subadd)
+  TEST_ENTRY(glm_vec2_muladd)
+  TEST_ENTRY(glm_vec2_muladds)
+  TEST_ENTRY(glm_vec2_maxadd)
+  TEST_ENTRY(glm_vec2_minadd)
+  TEST_ENTRY(glm_vec2_negate_to)
+  TEST_ENTRY(glm_vec2_negate)
+  TEST_ENTRY(glm_vec2_normalize)
+  TEST_ENTRY(glm_vec2_normalize_to)
+  TEST_ENTRY(glm_vec2_rotate)
+  TEST_ENTRY(glm_vec2_distance2)
+  TEST_ENTRY(glm_vec2_distance)
+  TEST_ENTRY(glm_vec2_maxv)
+  TEST_ENTRY(glm_vec2_minv)
+  TEST_ENTRY(glm_vec2_clamp)
+  TEST_ENTRY(glm_vec2_lerp)
+
+
+  TEST_ENTRY(glmc_vec2)
+  TEST_ENTRY(glmc_vec2_copy)
+  TEST_ENTRY(glmc_vec2_zero)
+  TEST_ENTRY(glmc_vec2_one)
+  TEST_ENTRY(glmc_vec2_dot)
+  TEST_ENTRY(glmc_vec2_cross)
+  TEST_ENTRY(glmc_vec2_norm2)
+  TEST_ENTRY(glmc_vec2_norm)
+  TEST_ENTRY(glmc_vec2_add)
+  TEST_ENTRY(glmc_vec2_adds)
+  TEST_ENTRY(glmc_vec2_sub)
+  TEST_ENTRY(glmc_vec2_subs)
+  TEST_ENTRY(glmc_vec2_mul)
+  TEST_ENTRY(glmc_vec2_scale)
+  TEST_ENTRY(glmc_vec2_scale_as)
+  TEST_ENTRY(glmc_vec2_div)
+  TEST_ENTRY(glmc_vec2_divs)
+  TEST_ENTRY(glmc_vec2_addadd)
+  TEST_ENTRY(glmc_vec2_subadd)
+  TEST_ENTRY(glmc_vec2_muladd)
+  TEST_ENTRY(glmc_vec2_muladds)
+  TEST_ENTRY(glmc_vec2_maxadd)
+  TEST_ENTRY(glmc_vec2_minadd)
+  TEST_ENTRY(glmc_vec2_negate_to)
+  TEST_ENTRY(glmc_vec2_negate)
+  TEST_ENTRY(glmc_vec2_normalize)
+  TEST_ENTRY(glmc_vec2_normalize_to)
+  TEST_ENTRY(glmc_vec2_rotate)
+  TEST_ENTRY(glmc_vec2_distance2)
+  TEST_ENTRY(glmc_vec2_distance)
+  TEST_ENTRY(glmc_vec2_maxv)
+  TEST_ENTRY(glmc_vec2_minv)
+  TEST_ENTRY(glmc_vec2_clamp)
+  TEST_ENTRY(glmc_vec2_lerp)
+
   /* vec3 */
 
   /* Macros */