From 9ab9e95ce5a2a8a2b8f6c12670c23a8b8df689e8 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 06:56:44 +0300 Subject: [PATCH] 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 | 24 ---------- .gitignore | 2 +- Makefile.am | 14 ++---- configure.ac | 2 +- post-build.sh | 24 ---------- test/include/common.h | 81 +++++++++++++++++++++++++++++++ test/runner.c | 68 ++++++++++++++++++++++++++ test/src/test_affine.c | 27 ++++++----- test/src/test_bezier.c | 17 +++---- test/src/test_cam.c | 29 ++++++------ test/src/test_clamp.c | 25 +++++----- test/src/test_common.c | 96 +++++++++++++++++++++---------------- test/src/test_common.h | 35 +++++--------- test/src/test_euler.c | 15 +++--- test/src/test_main.c | 48 ------------------- test/src/test_mat3.c | 59 +++++++++++++++-------- test/src/test_mat4.c | 74 +++++++++++++++++------------ test/src/test_project.c | 11 +++-- test/src/test_quat.c | 51 ++++++++++---------- test/src/test_tests.h | 46 ------------------ test/src/test_vec3.c | 57 +++++++++++----------- test/src/test_vec4.c | 74 ++++++++++++++--------------- test/tests.h | 97 ++++++++++++++++++++++++++++++++++++++ 23 files changed, 561 insertions(+), 415 deletions(-) delete mode 100644 .github/workflows/ccpp.yml delete mode 100644 post-build.sh create mode 100644 test/include/common.h create mode 100644 test/runner.c delete mode 100644 test/src/test_main.c delete mode 100644 test/src/test_tests.h create mode 100644 test/tests.h diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml deleted file mode 100644 index 3621c64..0000000 --- a/.github/workflows/ccpp.yml +++ /dev/null @@ -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 diff --git a/.gitignore b/.gitignore index 0655cc2..90ccabb 100644 --- a/.gitignore +++ b/.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 diff --git a/Makefile.am b/Makefile.am index 922aefe..d0a8c3a 100644 --- a/Makefile.am +++ b/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 \ - -I./include +checkCFLAGS = -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: - sh $${VPATH:-.}/post-build.sh +#ย all-local: +# sh $${VPATH:-.}/post-build.sh diff --git a/configure.ac b/configure.ac index 071ac47..23de6da 100644 --- a/configure.ac +++ b/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/]) diff --git a/post-build.sh b/post-build.sh deleted file mode 100644 index 6fa6e7a..0000000 --- a/post-build.sh +++ /dev/null @@ -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 diff --git a/test/include/common.h b/test/include/common.h new file mode 100644 index 0000000..e58edc2 --- /dev/null +++ b/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 +#include + +#include +#include +#include + +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 */ diff --git a/test/runner.c b/test/runner.c new file mode 100644 index 0000000..10f8d11 --- /dev/null +++ b/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 + +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; +} diff --git a/test/src/test_affine.c b/test/src/test_affine.c index bb1be15..c78b6b2 100644 --- a/test/src/test_affine.c +++ b/test/src/test_affine.c @@ -7,8 +7,7 @@ #include "test_common.h" -void -test_affine(void **state) { +TEST_IMPL(affine) { 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 } diff --git a/test/src/test_bezier.c b/test/src/test_bezier.c index 1c7bb11..460c47a 100644 --- a/test/src/test_bezier.c +++ b/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_bezier(void **state) { +TEST_IMPL(bezier) { 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)); - test_assert_eqf(smc, Bs_plain); - test_assert_eqf(Bs, smc); + ASSERT(glm_eq(Bs, Bs_plain)); + ASSERT(test_assert_eqf(smc, Bs_plain).status == 1) + 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_true(glm_eq(smc, Bs_plain)); - assert_true(glm_eq(Bs, smc)); + ASSERT(glm_eq(Bs, Bs_plain)); + ASSERT(glm_eq(smc, Bs_plain)); + ASSERT(glm_eq(Bs, smc)); + + TEST_SUCCESS } diff --git a/test/src/test_cam.c b/test/src/test_cam.c index c1f31e1..889e295 100644 --- a/test/src/test_cam.c +++ b/test/src/test_cam.c @@ -7,25 +7,24 @@ #include "test_common.h" -void -test_camera_lookat(void **state) { - mat4 view1, view2; +TEST_IMPL(camera_lookat) { + mat4 view1, view2; vec3 center, - eye = {0.024f, 14.6f, 67.04f}, - dir = {0.0f, 0.0f, -1.0f}, - up = {0.0f, 1.0f, 0.0f} - ; + eye = {0.024f, 14.6f, 67.04f}, + dir = {0.0f, 0.0f, -1.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_camera_decomp(void **state) { +TEST_IMPL(camera_decomp) { 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_true(fabsf(fovy - glm_persp_fovy(proj)) < FLT_EPSILON); - assert_true(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON); + ASSERT(fabsf(aspect - glm_persp_aspect(proj)) < FLT_EPSILON) + ASSERT(fabsf(fovy - 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 } diff --git a/test/src/test_clamp.c b/test/src/test_clamp.c index 70d684b..30e70f4 100644 --- a/test/src/test_clamp.c +++ b/test/src/test_clamp.c @@ -7,24 +7,25 @@ #include "test_common.h" -void -test_clamp(void **state) { +TEST_IMPL(clamp) { 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_true(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(1.6f, 0.0f, 1.0f) == 1.0f) + ASSERT(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f) + 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_true(v3[1] == 0.4f); - assert_true(v3[2] == 1.0f); + ASSERT(v3[0] == 1.0f) + ASSERT(v3[1] == 0.4f) + ASSERT(v3[2] == 1.0f) - assert_true(v4[0] == 3.0f); - assert_true(v4[1] == 2.3f); - assert_true(v4[2] == 1.5f); - assert_true(v4[3] == 1.5f); + ASSERT(v4[0] == 3.0f) + ASSERT(v4[1] == 2.3f) + ASSERT(v4[2] == 1.5f) + ASSERT(v4[3] == 1.5f) + + TEST_SUCCESS } diff --git a/test/src/test_common.c b/test/src/test_common.c index d734e72..4e966b5 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -4,11 +4,7 @@ */ #include "test_common.h" -#include -#include - -#define m 4 -#define n 4 +#include 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 (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + 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 (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - assert_true(fabsf(m1[i][j] - m2[i][j]) <= eps); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + 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_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 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_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); - assert_true(fabsf(v1[3] - v2[3]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009); + ASSERT(fabsf(v1[2] - v2[2]) <= 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_true(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009); - assert_true(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009); - assert_true(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009); + ASSERT(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */ + ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009); + ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 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_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); - assert_true(fabsf(v1[3] - v2[3]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009); + ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009); + ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009); + + TEST_SUCCESS } diff --git a/test/src/test_common.h b/test/src/test_common.h index 690d249..73d9502 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -8,20 +8,7 @@ #ifndef test_common_h #define test_common_h -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include +#include "../include/common.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 diff --git a/test/src/test_euler.c b/test/src/test_euler.c index b71c4cb..74618b3 100644 --- a/test/src/test_euler.c +++ b/test/src/test_euler.c @@ -7,10 +7,9 @@ #include "test_common.h" -void -test_euler(void **state) { - mat4 rot1, rot2; - vec3 inAngles, outAngles; +TEST_IMPL(euler) { + mat4 rot1, rot2; + 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 } diff --git a/test/src/test_main.c b/test/src/test_main.c deleted file mode 100644 index 8ce1673..0000000 --- a/test/src/test_main.c +++ /dev/null @@ -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); -} diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c index e0de7c6..6f43dd4 100644 --- a/test/src/test_mat3.c +++ b/test/src/test_mat3.c @@ -10,25 +10,33 @@ #define m 3 #define n 3 -void -test_mat3(void **state) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - mat3 m4 = GLM_MAT3_ZERO_INIT; - mat3 m5; - int i, j, k; - +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_true(glm_eq(m3[i][j], 1.0f)); - else - assert_true(glm_eq(m3[i][j], 0.0f)); + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + 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 */ @@ -43,16 +51,27 @@ test_mat3(void **state) { m4[i][j] += m1[k][j] * m2[i][k]; } } + + ASSERT(test_assert_mat3_eq(m3, m4).status == 1) + + TEST_SUCCESS +} - test_assert_mat3_eq(m3, m4); - +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(m4); + test_rand_mat3(m1); + test_rand_mat3(m2); /* test inverse precise */ - glmc_mat3_inv(m3, m4); - glmc_mat3_inv(m4, m5); - test_assert_mat3_eq(m3, m5); + glmc_mat3_inv(m1, m2); + glmc_mat3_inv(m2, m3); + ASSERT(test_assert_mat3_eq(m1, m3).status == 1) } + + TEST_SUCCESS } diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index f369829..49ae8ca 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -10,45 +10,63 @@ #define m 4 #define n 4 -void -test_mat4(void **state) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - mat4 m4 = GLM_MAT4_ZERO_INIT; - mat4 m5; - int i, j, k; - +TEST_IMPL(mat4_identity) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + int i, j; + /* 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) - assert_true(glm_eq(m3[i][j], 1.0f)); - else - assert_true(glm_eq(m3[i][j], 0.0f)); + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + 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); test_rand_mat4(m2); - + glm_mat4_mul(m1, m2, m3); 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 } diff --git a/test/src/test_project.c b/test/src/test_project.c index 4cdac9e..d590423 100644 --- a/test/src/test_project.c +++ b/test/src/test_project.c @@ -7,8 +7,7 @@ #include "test_common.h" -void -test_project(void **state) { +TEST_IMPL(project) { 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_true(fabsf(pos[1] - unprojected[1]) < 0.01); - assert_true(fabsf(pos[2] - unprojected[2]) < 0.01); + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01); + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01); + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01); + + TEST_SUCCESS } diff --git a/test/src/test_quat.c b/test/src/test_quat.c index d0cc27c..97ddd49 100644 --- a/test/src/test_quat.c +++ b/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_quat(void **state) { +TEST_IMPL(quat) { 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 - && fabsf(v1[1] - 1.0f) <= 0.00009f - && fabsf(v1[2]) <= 0.00009f); + ASSERT(fabsf(v1[0]) <= 0.00009f + && fabsf(v1[1] - 1.0f) <= 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 } diff --git a/test/src/test_tests.h b/test/src/test_tests.h deleted file mode 100644 index 618cc9f..0000000 --- a/test/src/test_tests.h +++ /dev/null @@ -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 */ diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c index 19af4aa..c529cc2 100644 --- a/test/src/test_vec3.c +++ b/test/src/test_vec3.c @@ -7,65 +7,64 @@ #include "test_common.h" -void -test_vec3(void **state) { - mat3 rot1m3; - mat4 rot1; - vec3 v, v1, v2; +TEST_IMPL(vec3) { + mat3 rot1m3; + mat4 rot1; + 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_as(v, 0.8, v); - test_assert_vec3_eq(v1, v); + glm_vec3_scale(v1, 0.8f, v1); + glm_vec3_scale_as(v, 0.8f, 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); - test_assert_vec3_eq(v1, GLM_ZUP); + ASSERT(test_assert_vec3_eq(v1, v2).status == 1) + 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 } diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index 2e9d12e..df59274 100644 --- a/test/src/test_vec4.c +++ b/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_vec4(void **state) { +TEST_IMPL(vec4) { 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)); - assert_true(fabsf(d1 - d2) <= 0.000009); + 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)); + 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); - - glm_vec4_print(v3, stderr); - glm_vec4_print(v4, stderr); + ASSERT(test_assert_vec4_eq(v3, v4).status == 1) /* 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); - glm_vec4_print(v4, stderr); - - assert_true(v3[0] >= 0.0999 && v3[0] <= 0.80001); /* rounding erros */ - 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); + ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */ + ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001) + ASSERT(v3[2] >= 0.0999 && v3[2] <= 0.80001) + ASSERT(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 } diff --git a/test/tests.h b/test/tests.h new file mode 100644 index 0000000..88562f3 --- /dev/null +++ b/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 */