External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-10-04 09:08:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: improve runner output and add assert helper for inline functions

Browse Source
This commit is contained in:
Recep Aslantas
2019-09-12 23:54:24 +03:00
parent 80c2b3712d
commit 32e5784564
10 changed files with 89 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/include/common.h
View File

@@ -70,6 +70,7 @@ typedef struct test_entry_t {
#define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1)
#define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } while(0);
#define ASSERTIFY(expr) ASSERT((expr).status == 1, (expr).msg)
#define TEST_OK 1
#define TEST_SUCCESS return (test_status_t){NULL, TEST_OK};

35
test/runner.c
View File

@@ -10,25 +10,43 @@
#include <stdlib.h>
#include <time.h>
#include <string.h>
int
main(int argc, const char * argv[]) {
test_entry_t *entry;
test_status_t st;
int32_t i, count, passed, failed;
double start, end, elapsed;
int32_t i, count, passed, failed, maxlen;
double start, end, elapsed, total;
passed = failed = 0;
passed = failed = maxlen = 0;
total = 0.0;
count = sizeof(tests) / sizeof(tests[0]);
fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET);
for (i = 0; i < count; i++) {
int32_t len;
entry = tests + i;
len = (int32_t)strlen(entry->name);
maxlen = GLM_MAX(maxlen, len);
}
maxlen += 5;
fprintf(stderr,
BOLDWHITE " %-*s %-*s\n",
maxlen, "Test Name", maxlen, "Elapsed Time");
for (i = 0; i < count; i++) {
entry = tests + i;
start = clock();
st = entry->entry();
end = clock();
elapsed = (end - start) / CLOCKS_PER_SEC;
total += elapsed;
if (!st.status) {
fprintf(stderr,
@@ -44,14 +62,14 @@ main(int argc, const char * argv[]) {
failed++;
} else {
fprintf(stderr, GREEN " ✔︎" RESET " %s - " , entry->name);
fprintf(stderr, GREEN " ✔︎" RESET " %-*s ", maxlen, entry->name);
if (elapsed > 0.01)
fprintf(stderr, YELLOW "%.2f", elapsed);
fprintf(stderr, YELLOW "%.2fs", elapsed);
else
fprintf(stderr, "0");
fprintf(stderr, "s\n" RESET);
fprintf(stderr, "\n" RESET);
passed++;
}
}
@@ -61,12 +79,13 @@ main(int argc, const char * argv[]) {
}
fprintf(stderr,
CYAN "\ncglm test results:\n" RESET
"------------------\n"
CYAN "\ncglm test results (%0.2fs):\n" RESET
"--------------------------\n"
MAGENTA "%d" RESET " tests are runned, "
GREEN "%d" RESET " %s passed, "
RED "%d" RESET " %s failed\n\n" RESET,
total,
count,
passed,
passed > 1 ? "are" : "is",

22
test/src/test_affine.c
View File

@@ -17,7 +17,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t1, t2, t3); /* R * T */
glm_translate(t1, (vec3){34, 57, 36});
ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t1, t3))
/* test rotate is postmultiplied */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -26,7 +26,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t2, t1, t3); /* T * R */
glm_rotate(t2, GLM_PI_4f, GLM_YUP);
ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t2, t3))
/* test scale is postmultiplied */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -37,7 +37,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t3, t4, t5); /* T * R * S */
glm_scale(t3, (vec3){3, 5, 6});
ASSERT(test_assert_mat4_eq(t3, t5).status == 1)
ASSERTIFY(test_assert_mat4_eq(t3, t5))
/* test translate_x */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -45,7 +45,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t1, t2, t3); /* R * T */
glm_translate_x(t1, 34);
ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t1, t3))
/* test translate_y */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -53,7 +53,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t1, t2, t3); /* R * T */
glm_translate_y(t1, 57);
ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t1, t3))
/* test translate_z */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -61,7 +61,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t1, t2, t3); /* R * T */
glm_translate_z(t1, 36);
ASSERT(test_assert_mat4_eq(t1, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t1, t3))
/* test rotate_x */
glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0});
@@ -70,7 +70,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t2, t1, t3); /* T * R */
glm_rotate_x(t2, GLM_PI_4f, t2);
ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t2, t3))
/* test rotate_y */
glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0});
@@ -79,7 +79,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t2, t1, t3); /* T * R */
glm_rotate_y(t2, GLM_PI_4f, t2);
ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t2, t3))
/* test rotate_z */
glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -88,7 +88,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t2, t1, t3); /* T * R */
glm_rotate_z(t2, GLM_PI_4f, t2);
ASSERT(test_assert_mat4_eq(t2, t3).status == 1)
ASSERTIFY(test_assert_mat4_eq(t2, t3))
/* test rotate */
glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -97,7 +97,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t2, t1, t3); /* T * R */
glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1});
ASSERT(test_assert_mat4_eq(t3, t2).status == 1)
ASSERTIFY(test_assert_mat4_eq(t3, t2))
/* test scale_uni */
glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -108,7 +108,7 @@ TEST_IMPL(affine) {
glmc_mat4_mul(t3, t4, t5); /* T * R * S */
glm_scale_uni(t3, 3);
ASSERT(test_assert_mat4_eq(t3, t5).status == 1)
ASSERTIFY(test_assert_mat4_eq(t3, t5))
TEST_SUCCESS
}

4
test/src/test_bezier.c
View File

@@ -50,8 +50,8 @@ TEST_IMPL(bezier) {
Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
ASSERT(glm_eq(Bs, Bs_plain));
ASSERT(test_assert_eqf(smc, Bs_plain).status == 1)
ASSERT(test_assert_eqf(Bs, smc).status == 1)
ASSERTIFY(test_assert_eqf(smc, Bs_plain))
ASSERTIFY(test_assert_eqf(Bs, smc))
/* test cubic hermite */
smc = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1});

4
test/src/test_cam.c
View File

@@ -19,7 +19,7 @@ TEST_IMPL(camera_lookat) {
glm_look(eye, dir, up, view2);
ASSERT(test_assert_mat4_eq(view1, view2).status == 1)
ASSERTIFY(test_assert_mat4_eq(view1, view2))
TEST_SUCCESS
}
@@ -49,7 +49,7 @@ TEST_IMPL(camera_decomp) {
farVal,
proj2);
ASSERT(test_assert_mat4_eq(proj, proj2).status == 1)
ASSERTIFY(test_assert_mat4_eq(proj, proj2))
TEST_SUCCESS
}

6
test/src/test_euler.c
View File

@@ -21,11 +21,11 @@ TEST_IMPL(euler) {
glmc_euler_angles(rot1, outAngles);
/* angles must be equal in that range */
ASSERT(test_assert_vec3_eq(inAngles, outAngles).status == 1)
ASSERTIFY(test_assert_vec3_eq(inAngles, outAngles))
/* matrices must be equal */
glmc_euler_xyz(outAngles, rot2);
ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1)
ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
/* change range */
inAngles[0] = glm_rad(-145.0f); /* X angle */
@@ -39,7 +39,7 @@ TEST_IMPL(euler) {
/* matrices must be equal */
glmc_euler_xyz(outAngles, rot2);
ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1)
ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
TEST_SUCCESS
}

4
test/src/test_mat3.c
View File

@@ -52,7 +52,7 @@ TEST_IMPL(mat3_mul) {
}
}
ASSERT(test_assert_mat3_eq(m3, m4).status == 1)
ASSERTIFY(test_assert_mat3_eq(m3, m4))
TEST_SUCCESS
}
@@ -70,7 +70,7 @@ TEST_IMPL(mat3_inv) {
/* test inverse precise */
glmc_mat3_inv(m1, m2);
glmc_mat3_inv(m2, m3);
ASSERT(test_assert_mat3_eq(m1, m3).status == 1)
ASSERTIFY(test_assert_mat3_eq(m1, m3))
}
TEST_SUCCESS

32
test/src/test_quat.c
View File

@@ -27,7 +27,7 @@ TEST_IMPL(quat) {
ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
glm_quat_mat4(q4, rot1);
ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1)
ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009))
/* 1. test quat to mat and mat to quat */
for (i = 0; i < 1000; i++) {
@@ -38,17 +38,17 @@ TEST_IMPL(quat) {
glmc_quat_mat4(outQuat, outRot);
/* 2. test first quat and generated one equality */
ASSERT(test_assert_quat_eq_abs(inQuat, outQuat).status == 1);
ASSERTIFY(test_assert_quat_eq_abs(inQuat, outQuat));
/* 3. test first rot and second rotation */
/* almost equal */
ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009).status == 1);
ASSERTIFY(test_assert_mat4_eq2(inRot, outRot, 0.000009));
/* 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);
ASSERT(test_assert_quat_eq(q3, q4).status == 1);
ASSERTIFY(test_assert_quat_eq(q3, q4));
#endif
}
@@ -62,7 +62,7 @@ TEST_IMPL(quat) {
/* create view matrix with quaternion */
glm_quat_look(eye, q3, view2);
ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009).status == 1);
ASSERTIFY(test_assert_mat4_eq2(view1, view2, 0.000009));
/* 6. test quaternion rotation matrix result */
test_rand_quat(q3);
@@ -72,7 +72,7 @@ TEST_IMPL(quat) {
glm_quat_axis(q3, axis);
glm_rotate_make(rot2, glm_quat_angle(q3), axis);
ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1);
ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009));
/* 7. test quaternion multiplication (hamilton product),
final rotation = first rotation + second = quat1 * quat2
@@ -92,7 +92,7 @@ TEST_IMPL(quat) {
glm_quat_mat4(q5, rot2);
/* result must be same (almost) */
ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009))
/* 8. test quaternion for look rotation */
@@ -102,21 +102,21 @@ TEST_IMPL(quat) {
/* result must be identity */
glm_quat_identity(q4);
ASSERT(test_assert_quat_eq(q3, q4).status == 1)
ASSERTIFY(test_assert_quat_eq(q3, q4))
/* 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);
ASSERT(test_assert_quat_eq(q3, q4).status == 1)
ASSERTIFY(test_assert_quat_eq(q3, q4))
/* 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);
ASSERT(test_assert_quat_eq(q3, q4).status == 1)
ASSERTIFY(test_assert_quat_eq(q3, q4))
/* 9. test imag, real */
@@ -139,7 +139,7 @@ TEST_IMPL(quat) {
imag[1] = -1.0f;
imag[2] = 0.0f;
ASSERT(test_assert_vec3_eq(imag, axis).status == 1);
ASSERTIFY(test_assert_vec3_eq(imag, axis));
/* 10. test rotate vector using quat */
/* (0,0,-1) around (1,0,0) must give (0,1,0) */
@@ -157,7 +157,7 @@ TEST_IMPL(quat) {
&& fabsf(v1[1] - 1.0f) <= 0.00009f
&& fabsf(v1[2]) <= 0.00009f)
ASSERT(test_assert_vec3_eq(v1, v2).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, v2))
/* 11. test rotate transform */
glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -168,7 +168,7 @@ TEST_IMPL(quat) {
glm_quat_rotate(rot2, q3, rot2);
/* result must be same (almost) */
ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009))
glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -179,7 +179,7 @@ TEST_IMPL(quat) {
glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f});
/* result must be same (almost) */
ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1)
ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009))
/* reverse */
glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
@@ -187,7 +187,7 @@ TEST_IMPL(quat) {
glm_quat_rotate(rot1, q3, rot1);
/* result must be identity */
ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1)
ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009))
test_rand_quat(q3);
@@ -196,7 +196,7 @@ TEST_IMPL(quat) {
glm_quat_mul(q3, q4, q5);
glm_quat_identity(q3);
ASSERT(test_assert_quat_eq(q3, q5).status == 1)
ASSERTIFY(test_assert_quat_eq(q3, q5))
/* TODO: add tests for slerp, lerp */

20
test/src/test_vec3.c
View File

@@ -15,11 +15,11 @@ TEST_IMPL(vec3) {
/* test zero */
glm_vec3_zero(v);
ASSERT(test_assert_vec3_eq(GLM_VEC3_ZERO, v).status == 1)
ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ZERO, v))
/* test one */
glm_vec3_one(v);
ASSERT(test_assert_vec3_eq(GLM_VEC3_ONE, v).status == 1)
ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ONE, v))
/* adds, subs, div, divs, mul */
glm_vec3_add(v, GLM_VEC3_ONE, v);
@@ -50,7 +50,7 @@ TEST_IMPL(vec3) {
glm_vec3_normalize_to(v, v1);
glm_vec3_scale(v1, 0.8f, v1);
glm_vec3_scale_as(v, 0.8f, v);
ASSERT(test_assert_vec3_eq(v1, v).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, v))
/* addadd, subadd, muladd */
glm_vec3_one(v);
@@ -73,8 +73,8 @@ TEST_IMPL(vec3) {
glm_mat4_pick3(rot1, rot1m3);
glm_vec3_rotate_m3(rot1m3, v, v2);
ASSERT(test_assert_vec3_eq(v1, v2).status == 1)
ASSERT(test_assert_vec3_eq(v1, GLM_ZUP).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, v2))
ASSERTIFY(test_assert_vec3_eq(v1, GLM_ZUP))
/* structs */
vs1 = test_rand_vec3s();
@@ -82,7 +82,7 @@ TEST_IMPL(vec3) {
vs3 = glms_vec3_add(vs1, vs2);
vs4 = glms_vec3_maxv(vs1, vs3);
ASSERT(test_assert_vec3s_eq(vs3, vs4).status == 1)
ASSERTIFY(test_assert_vec3s_eq(vs3, vs4))
/* swizzle */
@@ -91,24 +91,24 @@ TEST_IMPL(vec3) {
v1[1] = 2;
v1[2] = 3;
glm_vec3_swizzle(v1, GLM_ZYX, v1);
ASSERT(test_assert_vec3_eq(v1, (vec3){3, 2, 1}).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 2, 1}))
glm_vec3_swizzle(v1, GLM_XXX, v1);
ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3}))
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
glm_vec3_swizzle(v1, GLM_YYY, v1);
ASSERT(test_assert_vec3_eq(v1, (vec3){2, 2, 2}).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, (vec3){2, 2, 2}))
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
glm_vec3_swizzle(v1, GLM_ZZZ, v1);
ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1)
ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3}))
TEST_SUCCESS
}

24
test/src/test_vec4.c
View File

@@ -106,11 +106,11 @@ TEST_IMPL(vec4) {
/* test zero */
glm_vec4_zero(v);
ASSERT(test_assert_vec4_eq(GLM_VEC4_ZERO, v).status == 1)
ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ZERO, v))
/* test one */
glm_vec4_one(v);
ASSERT(test_assert_vec4_eq(GLM_VEC4_ONE, v).status == 1)
ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ONE, v))
/* adds, subs, div, divs, mul */
glm_vec4_add(v, GLM_VEC4_ONE, v);
@@ -141,7 +141,7 @@ TEST_IMPL(vec4) {
glm_vec4_normalize_to(v, v1);
glm_vec4_scale(v1, 0.8, v1);
glm_vec4_scale_as(v, 0.8, v);
ASSERT(test_assert_vec4_eq(v1, v).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, v))
/* addadd, subadd, muladd */
glm_vec4_one(v);
@@ -163,16 +163,16 @@ TEST_IMPL(vec4) {
glm_vec4_maxv(v1, v2, v3);
test_vec4_maxv(v1, v2, v4);
ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
ASSERTIFY(test_assert_vec4_eq(v3, v4))
glm_vec4_minv(v1, v2, v3);
test_vec4_minv(v1, v2, v4);
ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
ASSERTIFY(test_assert_vec4_eq(v3, v4))
/* clamp */
glm_vec4_clamp(v3, 0.1, 0.8);
test_vec4_clamp(v4, 0.1, 0.8);
ASSERT(test_assert_vec4_eq(v3, v4).status == 1)
ASSERTIFY(test_assert_vec4_eq(v3, v4))
ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */
ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001)
@@ -188,10 +188,10 @@ TEST_IMPL(vec4) {
v1[3] = 4;
glm_vec4_swizzle(v1, GLM_WZYX, v1);
ASSERT(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}))
glm_vec4_swizzle(v1, GLM_XXXX, v1);
ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}))
v1[0] = 1;
v1[1] = 2;
@@ -199,7 +199,7 @@ TEST_IMPL(vec4) {
v1[3] = 4;
glm_vec4_swizzle(v1, GLM_YYYY, v1);
ASSERT(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}))
v1[0] = 1;
v1[1] = 2;
@@ -207,7 +207,7 @@ TEST_IMPL(vec4) {
v1[3] = 4;
glm_vec4_swizzle(v1, GLM_ZZZZ, v1);
ASSERT(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}))
v1[0] = 1;
v1[1] = 2;
@@ -215,7 +215,7 @@ TEST_IMPL(vec4) {
v1[3] = 4;
glm_vec4_swizzle(v1, GLM_WWWW, v1);
ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1)
ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}))
/* structs */
vs1 = test_rand_vec4s();
@@ -223,7 +223,7 @@ TEST_IMPL(vec4) {
vs3 = glms_vec4_add(vs1, vs2);
vs4 = glms_vec4_maxv(vs1, vs3);
ASSERT(test_assert_vec4s_eq(vs3, vs4).status == 1)
ASSERTIFY(test_assert_vec4s_eq(vs3, vs4))
TEST_SUCCESS
}