External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-10-03 16:51:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Custom Built-in Unit Test Suite (#105)

Browse Source 
* 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
This commit is contained in:
Recep Aslantas
2019-09-12 06:56:44 +03:00
committed by GitHub
parent 27cc9c3351
commit 9ab9e95ce5
23 changed files with 561 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
.github/workflows/ccpp.yml vendored
View File

@@ -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

2
.gitignore vendored
View File

@@ -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

14
Makefile.am
View File

@@ -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

2
configure.ac
View File

@@ -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/])

24
post-build.sh
View File

@@ -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

81
test/include/common.h Normal file
View File

@@ -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 <stdlib.h>
#include <stdio.h>
#include <cglm/cglm.h>
#include <cglm/struct.h>
#include <cglm/call.h>
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 */

68
test/runner.c Normal file
View File

@@ -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 <stdlib.h>
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;
}

27
test/src/test_affine.c
View File

@@ -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
}

17
test/src/test_bezier.c
View File

@@ -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
}

29
test/src/test_cam.c
View File

@@ -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
}

25
test/src/test_clamp.c
View File

@@ -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
}

96
test/src/test_common.c
View File

@@ -4,11 +4,7 @@
*/
#include "test_common.h"
#include <stdlib.h>
#include <math.h>
#define m 4
#define n 4
#include <time.h>
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
}

35
test/src/test_common.h
View File

@@ -8,20 +8,7 @@
#ifndef test_common_h
#define test_common_h
#include <stdarg.h>
#include <stdint.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <stdbool.h>
#include <cglm/cglm.h>
#include <cglm/struct.h>
#include <cglm/call.h>
#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

15
test/src/test_euler.c
View File

@@ -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
}

48
test/src/test_main.c
View File

@@ -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);
}

59
test/src/test_mat3.c
View File

@@ -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
}

74
test/src/test_mat4.c
View File

@@ -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
}

11
test/src/test_project.c
View File

@@ -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
}

51
test/src/test_quat.c
View File

@@ -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
}

46
test/src/test_tests.h
View File

@@ -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 */

57
test/src/test_vec3.c
View File

@@ -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
}

74
test/src/test_vec4.c
View File

@@ -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
}

97
test/tests.h Normal file
View File

@@ -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 */