From 78f38db4802ce19e803c59e76cbbcad0ab5ad2a9 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 18 Sep 2019 23:33:41 +0300 Subject: [PATCH] tests: add missing tests for mat3 --- test/src/test_common.c | 30 ++++ test/src/test_common.h | 6 + test/src/test_mat3.c | 75 ++-------- test/src/test_mat3.h | 307 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 72 +++++++++- 5 files changed, 421 insertions(+), 69 deletions(-) create mode 100644 test/src/test_mat3.h diff --git a/test/src/test_common.c b/test/src/test_common.c index d2b6271..7c808be 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -152,6 +152,36 @@ test_assert_mat3_eqt(mat3 m1, mat3 m2) { TEST_SUCCESS } +test_status_t +test_assert_mat3_eq_identity(mat3 m3) { + int i, j; + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } + } + } + + TEST_SUCCESS +} + +test_status_t +test_assert_mat3_eq_zero(mat3 m3) { + int i, j; + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } + } + + TEST_SUCCESS +} + test_status_t test_assert_mat4_eq_identity(mat4 m4) { int i, j; diff --git a/test/src/test_common.h b/test/src/test_common.h index 155f21c..2ebe227 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -40,6 +40,12 @@ test_assert_mat3_eq(mat3 m1, mat3 m2); test_status_t test_assert_mat3_eqt(mat3 m1, mat3 m2); +test_status_t +test_assert_mat3_eq_identity(mat3 m3); + +test_status_t +test_assert_mat3_eq_zero(mat3 m3); + test_status_t test_assert_vec3_eq(vec3 v1, vec3 v2); diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c index 4d9dc07..0c9cf98 100644 --- a/test/src/test_mat3.c +++ b/test/src/test_mat3.c @@ -5,73 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline mat3 */ -#define m 3 -#define n 3 +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) -TEST_IMPL(mat3_identity) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - int i, j; - - /* 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) { - ASSERT(glm_eq(m3[i][j], 1.0f)) - } else { - ASSERT(glm_eq(m3[i][j], 0.0f)) - } - } - } - - TEST_SUCCESS -} +#include "test_mat3.h" -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; +#undef GLM +#undef GLM_PREFIX - /* test random matrices */ - /* random matrices */ - test_rand_mat3(m1); - test_rand_mat3(m2); +/* test pre-compiled mat3 */ - glmc_mat3_mul(m1, m2, m3); - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - /* column-major */ - m4[i][j] += m1[k][j] * m2[i][k]; - } - } - - ASSERTIFY(test_assert_mat3_eq(m3, m4)) - - TEST_SUCCESS -} +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) -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(m1); - test_rand_mat3(m2); +#include "test_mat3.h" - /* test inverse precise */ - glmc_mat3_inv(m1, m2); - glmc_mat3_inv(m2, m3); - ASSERTIFY(test_assert_mat3_eq(m1, m3)) - } - - TEST_SUCCESS -} +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h new file mode 100644 index 0000000..d45c3d6 --- /dev/null +++ b/test/src/test_mat3.h @@ -0,0 +1,307 @@ +/* + * 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 A_MATRIX {{1,2,3},{5,6,7},{9,10,11}} + +TEST_IMPL(GLM_PREFIX, mat3_copy) { + mat3 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + + GLM(mat3_copy)(m1, m2); + + test_assert_mat3_eq(m1, m2); + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_identity) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + + GLM(mat3_identity)(m3); + + ASSERTIFY(test_assert_mat3_eq_identity(m1)) + ASSERTIFY(test_assert_mat3_eq_identity(m2)) + ASSERTIFY(test_assert_mat3_eq_identity(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_identity_array) { + int i, count; + mat3 matrices[4] = { + A_MATRIX, + A_MATRIX, + A_MATRIX, + A_MATRIX + }; + + count = 4; + + GLM(mat3_identity_array)(matrices, count); + + for (i = 0; i < count; i++) { + ASSERTIFY(test_assert_mat3_eq_identity(matrices[i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_zero) { + mat3 m1 = GLM_MAT3_ZERO_INIT; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3; + + GLM(mat3_zero)(m3); + + ASSERTIFY(test_assert_mat3_eq_zero(m1)) + ASSERTIFY(test_assert_mat3_eq_zero(m2)) + ASSERTIFY(test_assert_mat3_eq_zero(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, 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); + test_rand_mat3(m2); + + GLM(mat3_mul)(m1, m2, m3); + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + for (k = 0; k < 3; k++) + /* column-major */ + m4[i][j] += m1[k][j] * m2[i][k]; + } + } + + ASSERTIFY(test_assert_mat3_eq(m3, m4)) + + /* test pre compiled */ + GLM(mat3_mul)(m1, m2, m3); + ASSERTIFY(test_assert_mat3_eq(m3, m4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_mulv) { + vec4 res; + mat3 mat = A_MATRIX; + vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; + int i; + + GLM(mat3_mulv)(mat, v, res); + + for (i = 0; i < 3; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_trace) { + mat3 mat = A_MATRIX; + float trace; + + trace = glm_mat3_trace(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_quat) { + mat3 m1, m3; + mat4 m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat_mat3)(q1, m1); + GLM(mat3_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat3_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + glm_mat4_pick3(m2, m3); + + ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat3_eq(m1, m3)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_transpose_to) { + mat3 mat = A_MATRIX; + mat3 m1; + + GLM(mat3_transpose_to)(mat, m1); + + ASSERTIFY(test_assert_mat3_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_transpose) { + mat3 mat = A_MATRIX; + mat3 m1; + + GLM(mat3_copy)(mat, m1); + GLM(mat3_transpose)(m1); + + ASSERTIFY(test_assert_mat3_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_scale) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + GLM(mat3_scale)(m1, scale); + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + for (k = 0; k < 3; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_det) { + mat3 mat; + + float a = mat[0][0], b = mat[0][1], c = mat[0][2], + d = mat[1][0], e = mat[1][1], f = mat[1][2], + g = mat[2][0], h = mat[2][1], i = mat[2][2]; + + float det1, det2; + + det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e); + det2 = glm_mat3_det(mat); + + test_rand_mat3(mat); + + ASSERT(glm_eq(det1, det2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, 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(m1); + test_rand_mat3(m2); + + /* test inverse precise */ + glmc_mat3_inv(m1, m2); + glmc_mat3_inv(m2, m3); + ASSERTIFY(test_assert_mat3_eq(m1, m3)) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_swap_col) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + + GLM(mat3_swap_col)(m1, 0, 1); + + ASSERTIFY(test_assert_vec3_eq(m1[0], m2[1])) + ASSERTIFY(test_assert_vec3_eq(m1[1], m2[0])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_swap_row) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + + GLM(mat3_swap_row)(m1, 0, 1); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][0])) + ASSERT(glm_eq(m1[0][2], m2[0][2])) + + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][0])) + ASSERT(glm_eq(m1[1][2], m2[1][2])) + + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][0])) + ASSERT(glm_eq(m1[2][2], m2[2][2])) + + GLM(mat3_swap_row)(m1, 1, 2); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][2])) + ASSERT(glm_eq(m1[0][2], m2[0][0])) + + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][2])) + ASSERT(glm_eq(m1[1][2], m2[1][0])) + + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][2])) + ASSERT(glm_eq(m1[2][2], m2[2][0])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_rmc) { + mat3 mat = A_MATRIX; + vec3 v = {11.0f, 12.0f, 13.0f}; + vec3 v1; + float r1, r2; + int i; + + r1 = GLM(mat3_rmc)(v, mat, v); + + for (i = 0; i < 3; i++) { + v1[i] = v[0] * mat[i][0] + + v[1] * mat[i][1] + + v[2] * mat[i][2]; + } + + r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2]; + + ASSERT(glm_eq(r1, r2)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index bb5e89a..a3bf582 100644 --- a/test/tests.h +++ b/test/tests.h @@ -73,9 +73,39 @@ TEST_DECLARE(glmc_mat4_rmc) TEST_DECLARE(affine) /* mat3 */ -TEST_DECLARE(mat3_identity) -TEST_DECLARE(mat3_mul) -TEST_DECLARE(mat3_inv) +TEST_DECLARE(glm_mat3_copy) +TEST_DECLARE(glm_mat3_identity) +TEST_DECLARE(glm_mat3_identity_array) +TEST_DECLARE(glm_mat3_zero) +TEST_DECLARE(glm_mat3_mul) +TEST_DECLARE(glm_mat3_mulv) +TEST_DECLARE(glm_mat3_trace) +TEST_DECLARE(glm_mat3_quat) +TEST_DECLARE(glm_mat3_transpose_to) +TEST_DECLARE(glm_mat3_transpose) +TEST_DECLARE(glm_mat3_scale) +TEST_DECLARE(glm_mat3_det) +TEST_DECLARE(glm_mat3_inv) +TEST_DECLARE(glm_mat3_swap_col) +TEST_DECLARE(glm_mat3_swap_row) +TEST_DECLARE(glm_mat3_rmc) + +TEST_DECLARE(glmc_mat3_copy) +TEST_DECLARE(glmc_mat3_identity) +TEST_DECLARE(glmc_mat3_identity_array) +TEST_DECLARE(glmc_mat3_zero) +TEST_DECLARE(glmc_mat3_mul) +TEST_DECLARE(glmc_mat3_mulv) +TEST_DECLARE(glmc_mat3_trace) +TEST_DECLARE(glmc_mat3_quat) +TEST_DECLARE(glmc_mat3_transpose_to) +TEST_DECLARE(glmc_mat3_transpose) +TEST_DECLARE(glmc_mat3_scale) +TEST_DECLARE(glmc_mat3_det) +TEST_DECLARE(glmc_mat3_inv) +TEST_DECLARE(glmc_mat3_swap_col) +TEST_DECLARE(glmc_mat3_swap_row) +TEST_DECLARE(glmc_mat3_rmc) /* camera */ TEST_DECLARE(camera_lookat) @@ -162,9 +192,39 @@ TEST_LIST { TEST_ENTRY(affine) /* mat3 */ - TEST_ENTRY(mat3_identity) - TEST_ENTRY(mat3_mul) - TEST_ENTRY(mat3_inv) + TEST_ENTRY(glm_mat3_copy) + TEST_ENTRY(glm_mat3_identity) + TEST_ENTRY(glm_mat3_identity_array) + TEST_ENTRY(glm_mat3_zero) + TEST_ENTRY(glm_mat3_mul) + TEST_ENTRY(glm_mat3_mulv) + TEST_ENTRY(glm_mat3_trace) + TEST_ENTRY(glm_mat3_quat) + TEST_ENTRY(glm_mat3_transpose_to) + TEST_ENTRY(glm_mat3_transpose) + TEST_ENTRY(glm_mat3_scale) + TEST_ENTRY(glm_mat3_det) + TEST_ENTRY(glm_mat3_inv) + TEST_ENTRY(glm_mat3_swap_col) + TEST_ENTRY(glm_mat3_swap_row) + TEST_ENTRY(glm_mat3_rmc) + + TEST_ENTRY(glmc_mat3_copy) + TEST_ENTRY(glmc_mat3_identity) + TEST_ENTRY(glmc_mat3_identity_array) + TEST_ENTRY(glmc_mat3_zero) + TEST_ENTRY(glmc_mat3_mul) + TEST_ENTRY(glmc_mat3_mulv) + TEST_ENTRY(glmc_mat3_trace) + TEST_ENTRY(glmc_mat3_quat) + TEST_ENTRY(glmc_mat3_transpose_to) + TEST_ENTRY(glmc_mat3_transpose) + TEST_ENTRY(glmc_mat3_scale) + TEST_ENTRY(glmc_mat3_det) + TEST_ENTRY(glmc_mat3_inv) + TEST_ENTRY(glmc_mat3_swap_col) + TEST_ENTRY(glmc_mat3_swap_row) + TEST_ENTRY(glmc_mat3_rmc) /* camera */ TEST_ENTRY(camera_lookat)