diff --git a/test/runner.c b/test/runner.c
index 7d4d858..80c4e8f 100644
--- a/test/runner.c
+++ b/test/runner.c
@@ -71,6 +71,10 @@ main(int argc, const char * argv[]) {
       fprintf(stderr, "\n" RESET);
       passed++;
     }
+
+    struct timespec t;
+    t.tv_nsec = 100000000 * 0.5;
+//    nanosleep(&t, NULL);
   }
 
   if (failed == 0) {
diff --git a/test/src/test_common.c b/test/src/test_common.c
index 5741a37..ce1acc8 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -272,3 +272,14 @@ test_assert_quat_eq(versor v1, versor v2) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_quat_eq_identity(versor q) {
+  versor p = GLM_QUAT_IDENTITY_INIT;
+
+  ASSERT(fabsf(q[0] - p[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(q[1] - p[1]) <= 0.000009);
+  ASSERT(fabsf(q[2] - p[2]) <= 0.000009);
+  ASSERT(fabsf(q[3] - p[3]) <= 0.000009);
+
+  TEST_SUCCESS
+}
diff --git a/test/src/test_common.h b/test/src/test_common.h
index a5c4bb6..8443ec3 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -61,6 +61,9 @@ test_assert_vec4s_eq(vec4s v1, vec4s v2);
 test_status_t
 test_assert_quat_eq(versor v1, versor v2);
 
+test_status_t
+test_assert_quat_eq_identity(versor q) ;
+
 test_status_t
 test_assert_quat_eq_abs(versor v1, versor v2);
 
diff --git a/test/src/test_quat.c b/test/src/test_quat.c
index 98bd8a1..9e2a908 100644
--- a/test/src/test_quat.c
+++ b/test/src/test_quat.c
@@ -7,6 +7,26 @@
 
 #include "test_common.h"
 
+/* test inline quat */
+
+#define GLM_PREFIX glm_
+#define GLM(X) (glm_ ## X)
+
+#include "test_quat.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/* test pre-compiled quat */
+
+#define GLM_PREFIX glmc_
+#define GLM(X) (glmc_ ## X)
+
+#include "test_quat.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
 CGLM_INLINE
 void
 test_quat_mul_raw(versor p, versor q, versor dest) {
diff --git a/test/src/test_quat.h b/test/src/test_quat.h
new file mode 100644
index 0000000..2788329
--- /dev/null
+++ b/test/src/test_quat.h
@@ -0,0 +1,233 @@
+/*
+ * 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_QUAT_ONCE
+#define CGLM_TEST_QUAT_ONCE
+
+/* Macros */
+
+TEST_IMPL(MACRO_GLM_QUAT_IDENTITY_INIT) {
+  versor v = GLM_QUAT_IDENTITY_INIT;
+
+  ASSERT(test_eq(v[0], 0.0f))
+  ASSERT(test_eq(v[1], 0.0f))
+  ASSERT(test_eq(v[2], 0.0f))
+  ASSERT(test_eq(v[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_QUAT_IDENTITY) {
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[0], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[1], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[2], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_QUAT_ONCE */
+
+TEST_IMPL(GLM_PREFIX, quat_identity) {
+  versor a = GLM_QUAT_IDENTITY_INIT;
+  versor b = GLM_QUAT_IDENTITY_INIT;
+  versor c;
+  mat4   r;
+
+  GLM(quat_identity)(c);
+
+  ASSERTIFY(test_assert_quat_eq_identity(a))
+  ASSERTIFY(test_assert_quat_eq_identity(b))
+  ASSERTIFY(test_assert_quat_eq_identity(c))
+
+  glm_quat_identity(c);
+  ASSERT(test_eq(glm_quat_real(c), cosf(glm_rad(0.0f) * 0.5f)))
+
+  glm_quat_mat4(c, r);
+  ASSERTIFY(test_assert_mat4_eq2(r, GLM_MAT4_IDENTITY, 0.000009f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_identity_array) {
+  int i, count;
+  versor quats[4] = {
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+  };
+
+  count = 4;
+
+  GLM(quat_identity_array)(quats, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_quat_eq_identity(quats[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_init) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor q2 = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor q3 = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  GLM(quat_init)(q1, 10.0f, 11.0f, 12.0f, 13.0f);
+  GLM(quat_init)(q2, 100.0f, 110.0f, 120.0f, 130.0f);
+  GLM(quat_init)(q3, 1000.0f, 1100.0f, 1200.0f, 1300.0f);
+
+  ASSERT(q1[0] == 10.0f)
+  ASSERT(q1[1] == 11.0f)
+  ASSERT(q1[2] == 12.0f)
+  ASSERT(q1[3] == 13.0f)
+
+  ASSERT(q2[0] == 100.0f)
+  ASSERT(q2[1] == 110.0f)
+  ASSERT(q2[2] == 120.0f)
+  ASSERT(q2[3] == 130.0f)
+
+  ASSERT(q3[0] == 1000.0f)
+  ASSERT(q3[1] == 1100.0f)
+  ASSERT(q3[2] == 1200.0f)
+  ASSERT(q3[3] == 1300.0f)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quatv) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   v1, v2;
+  float  a1;
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q1, glm_rad(60.0f), v1);
+
+  glm_quat_axis(q1, v2);
+  a1 = glm_quat_angle(q1);
+
+  ASSERT(test_eq(a1, glm_rad(60.0f)))
+
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   v1, v2;
+  float  a1;
+
+  test_rand_vec3(v1);
+  GLM(quat)(q1, glm_rad(60.0f), v1[0], v1[1], v1[2]);
+
+  glm_quat_axis(q1, v2);
+  a1 = glm_quat_angle(q1);
+
+  ASSERT(test_eq(a1, glm_rad(60.0f)))
+
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_copy) {
+  versor v1 = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor v2 = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  GLM(quat_copy)(v1, v2);
+
+  ASSERTIFY(test_assert_vec4_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_norm) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  float  n1, n2;
+
+  n1 = GLM(quat_norm)(a);
+  n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_normalize_to) {
+  versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2;
+  float  s  = 1.0f;
+  float  norm;
+
+  GLM(quat_normalize_to)(v1, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
+  if (norm <= 0.0f) {
+    ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+    TEST_SUCCESS
+  }
+
+  norm = s / norm;
+
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[3] * norm, v2[3]))
+
+  glm_vec4_zero(v1);
+  GLM(quat_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_quat_eq_identity(v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_normalize) {
+  versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2 = {2.0f, -3.0f, 4.0f, 5.0f};
+  float  s  = 1.0f;
+  float  norm;
+
+  GLM(quat_normalize)(v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
+  if (norm <= 0.0f) {
+    ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+    TEST_SUCCESS
+  }
+
+  norm = s / norm;
+
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[3] * norm, v2[3]))
+
+  glm_vec4_zero(v1);
+  GLM(quat_normalize)(v1);
+  ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_dot) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  float  dot1, dot2;
+
+  dot1 = GLM(quat_dot)(a, b);
+  dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+
+  ASSERT(test_eq(dot1, dot2))
+
+  TEST_SUCCESS
+}
diff --git a/test/tests.h b/test/tests.h
index 1076a13..386a425 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -128,6 +128,30 @@ TEST_DECLARE(euler)
 
 /* quat */
 TEST_DECLARE(quat)
+TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY_INIT)
+TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY)
+
+TEST_DECLARE(glm_quat_identity)
+TEST_DECLARE(glm_quat_identity_array)
+TEST_DECLARE(glm_quat_init)
+TEST_DECLARE(glm_quatv)
+TEST_DECLARE(glm_quat)
+TEST_DECLARE(glm_quat_copy)
+TEST_DECLARE(glm_quat_norm)
+TEST_DECLARE(glm_quat_normalize_to)
+TEST_DECLARE(glm_quat_normalize)
+TEST_DECLARE(glm_quat_dot)
+
+TEST_DECLARE(glmc_quat_identity)
+TEST_DECLARE(glmc_quat_identity_array)
+TEST_DECLARE(glmc_quat_init)
+TEST_DECLARE(glmc_quatv)
+TEST_DECLARE(glmc_quat)
+TEST_DECLARE(glmc_quat_copy)
+TEST_DECLARE(glmc_quat_norm)
+TEST_DECLARE(glmc_quat_normalize_to)
+TEST_DECLARE(glmc_quat_normalize)
+TEST_DECLARE(glmc_quat_dot)
 
 /* bezier */
 TEST_DECLARE(bezier)
@@ -557,7 +581,31 @@ TEST_LIST {
   
   /* quat */
   TEST_ENTRY(quat)
-  
+  TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY_INIT)
+  TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY)
+
+  TEST_ENTRY(glm_quat_identity)
+  TEST_ENTRY(glm_quat_identity_array)
+  TEST_ENTRY(glm_quat_init)
+  TEST_ENTRY(glm_quatv)
+  TEST_ENTRY(glm_quat)
+  TEST_ENTRY(glm_quat_copy)
+  TEST_ENTRY(glm_quat_norm)
+  TEST_ENTRY(glm_quat_normalize_to)
+  TEST_ENTRY(glm_quat_normalize)
+  TEST_ENTRY(glm_quat_dot)
+
+  TEST_ENTRY(glmc_quat_identity)
+  TEST_ENTRY(glmc_quat_identity_array)
+  TEST_ENTRY(glmc_quat_init)
+  TEST_ENTRY(glmc_quatv)
+  TEST_ENTRY(glmc_quat)
+  TEST_ENTRY(glmc_quat_copy)
+  TEST_ENTRY(glmc_quat_norm)
+  TEST_ENTRY(glmc_quat_normalize_to)
+  TEST_ENTRY(glmc_quat_normalize)
+  TEST_ENTRY(glmc_quat_dot)
+
   /* bezier */
   TEST_ENTRY(bezier)