YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some random fixes

Browse Source
This commit is contained in:
Dominic Masters
2026-08-08 01:18:07 -05:00
parent 36fb359aa2
commit 128f9ab9d4
15 changed files with 1041 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/animation/CMakeLists.txt
+1
View File
@@ -6,5 +6,6 @@
include(dusktest)
# Tests
dusktest(test_easing.c)
dusktest(test_keyframe.c)
dusktest(test_animation.c)
test/animation/test_easing.c
+188
View File
@@ -0,0 +1,188 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "dusktest.h"
#include "animation/easing.h"
#define EASING_TOLERANCE 0.0001f
static void test_easingLinear(void **state) {
assert_float_equal(easingLinear(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingLinear(0.25f), 0.25f, EASING_TOLERANCE);
assert_float_equal(easingLinear(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingLinear(0.75f), 0.75f, EASING_TOLERANCE);
assert_float_equal(easingLinear(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInSine(void **state) {
assert_float_equal(easingInSine(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInSine(0.25f), 0.076120f, EASING_TOLERANCE);
assert_float_equal(easingInSine(0.5f), 0.292893f, EASING_TOLERANCE);
assert_float_equal(easingInSine(0.75f), 0.617317f, EASING_TOLERANCE);
assert_float_equal(easingInSine(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingOutSine(void **state) {
assert_float_equal(easingOutSine(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingOutSine(0.25f), 0.382683f, EASING_TOLERANCE);
assert_float_equal(easingOutSine(0.5f), 0.707107f, EASING_TOLERANCE);
assert_float_equal(easingOutSine(0.75f), 0.923880f, EASING_TOLERANCE);
assert_float_equal(easingOutSine(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInOutSine(void **state) {
assert_float_equal(easingInOutSine(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInOutSine(0.25f), 0.146447f, EASING_TOLERANCE);
assert_float_equal(easingInOutSine(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingInOutSine(0.75f), 0.853553f, EASING_TOLERANCE);
assert_float_equal(easingInOutSine(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInQuad(void **state) {
assert_float_equal(easingInQuad(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInQuad(0.25f), 0.0625f, EASING_TOLERANCE);
assert_float_equal(easingInQuad(0.5f), 0.25f, EASING_TOLERANCE);
assert_float_equal(easingInQuad(0.75f), 0.5625f, EASING_TOLERANCE);
assert_float_equal(easingInQuad(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingOutQuad(void **state) {
assert_float_equal(easingOutQuad(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingOutQuad(0.25f), 0.4375f, EASING_TOLERANCE);
assert_float_equal(easingOutQuad(0.5f), 0.75f, EASING_TOLERANCE);
assert_float_equal(easingOutQuad(0.75f), 0.9375f, EASING_TOLERANCE);
assert_float_equal(easingOutQuad(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInOutQuad(void **state) {
assert_float_equal(easingInOutQuad(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuad(0.25f), 0.125f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuad(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuad(0.75f), 0.875f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuad(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInCubic(void **state) {
assert_float_equal(easingInCubic(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInCubic(0.25f), 0.015625f, EASING_TOLERANCE);
assert_float_equal(easingInCubic(0.5f), 0.125f, EASING_TOLERANCE);
assert_float_equal(easingInCubic(0.75f), 0.421875f, EASING_TOLERANCE);
assert_float_equal(easingInCubic(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingOutCubic(void **state) {
assert_float_equal(easingOutCubic(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingOutCubic(0.25f), 0.578125f, EASING_TOLERANCE);
assert_float_equal(easingOutCubic(0.5f), 0.875f, EASING_TOLERANCE);
assert_float_equal(easingOutCubic(0.75f), 0.984375f, EASING_TOLERANCE);
assert_float_equal(easingOutCubic(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInOutCubic(void **state) {
assert_float_equal(easingInOutCubic(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInOutCubic(0.25f), 0.0625f, EASING_TOLERANCE);
assert_float_equal(easingInOutCubic(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingInOutCubic(0.75f), 0.9375f, EASING_TOLERANCE);
assert_float_equal(easingInOutCubic(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInQuart(void **state) {
assert_float_equal(easingInQuart(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInQuart(0.25f), 0.003906f, EASING_TOLERANCE);
assert_float_equal(easingInQuart(0.5f), 0.0625f, EASING_TOLERANCE);
assert_float_equal(easingInQuart(0.75f), 0.316406f, EASING_TOLERANCE);
assert_float_equal(easingInQuart(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingOutQuart(void **state) {
assert_float_equal(easingOutQuart(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingOutQuart(0.25f), 0.683594f, EASING_TOLERANCE);
assert_float_equal(easingOutQuart(0.5f), 0.9375f, EASING_TOLERANCE);
assert_float_equal(easingOutQuart(0.75f), 0.996094f, EASING_TOLERANCE);
assert_float_equal(easingOutQuart(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInOutQuart(void **state) {
assert_float_equal(easingInOutQuart(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuart(0.25f), 0.03125f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuart(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuart(0.75f), 0.96875f, EASING_TOLERANCE);
assert_float_equal(easingInOutQuart(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInBack(void **state) {
// "In back" overshoots below 0 before rising to 1 - that's the point of it.
assert_float_equal(easingInBack(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInBack(0.25f), -0.064137f, EASING_TOLERANCE);
assert_float_equal(easingInBack(0.5f), -0.087698f, EASING_TOLERANCE);
assert_float_equal(easingInBack(0.75f), 0.182590f, EASING_TOLERANCE);
assert_float_equal(easingInBack(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingOutBack(void **state) {
// "Out back" overshoots above 1 before settling at 1.
assert_float_equal(easingOutBack(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingOutBack(0.25f), 0.817410f, EASING_TOLERANCE);
assert_float_equal(easingOutBack(0.5f), 1.087697f, EASING_TOLERANCE);
assert_float_equal(easingOutBack(0.75f), 1.064137f, EASING_TOLERANCE);
assert_float_equal(easingOutBack(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingInOutBack(void **state) {
assert_float_equal(easingInOutBack(0.0f), 0.0f, EASING_TOLERANCE);
assert_float_equal(easingInOutBack(0.25f), -0.099682f, EASING_TOLERANCE);
assert_float_equal(easingInOutBack(0.5f), 0.5f, EASING_TOLERANCE);
assert_float_equal(easingInOutBack(0.75f), 1.099682f, EASING_TOLERANCE);
assert_float_equal(easingInOutBack(1.0f), 1.0f, EASING_TOLERANCE);
}
static void test_easingApplyDispatchesToEachType(void **state) {
assert_float_equal(easingApply(EASING_LINEAR, 0.5f), easingLinear(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_SINE, 0.5f), easingInSine(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_OUT_SINE, 0.5f), easingOutSine(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_OUT_SINE, 0.5f), easingInOutSine(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_QUAD, 0.5f), easingInQuad(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_OUT_QUAD, 0.5f), easingOutQuad(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_OUT_QUAD, 0.5f), easingInOutQuad(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_CUBIC, 0.5f), easingInCubic(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_OUT_CUBIC, 0.5f), easingOutCubic(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_OUT_CUBIC, 0.5f), easingInOutCubic(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_QUART, 0.5f), easingInQuart(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_OUT_QUART, 0.5f), easingOutQuart(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_OUT_QUART, 0.5f), easingInOutQuart(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_BACK, 0.5f), easingInBack(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_OUT_BACK, 0.5f), easingOutBack(0.5f), EASING_TOLERANCE);
assert_float_equal(easingApply(EASING_IN_OUT_BACK, 0.5f), easingInOutBack(0.5f), EASING_TOLERANCE);
}
static void test_easingApplyInvalidTypeAsserts(void **state) {
expect_assert_failure(easingApply(EASING_COUNT, 0.5f));
}
int main(int argc, char **argv) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_easingLinear),
cmocka_unit_test(test_easingInSine),
cmocka_unit_test(test_easingOutSine),
cmocka_unit_test(test_easingInOutSine),
cmocka_unit_test(test_easingInQuad),
cmocka_unit_test(test_easingOutQuad),
cmocka_unit_test(test_easingInOutQuad),
cmocka_unit_test(test_easingInCubic),
cmocka_unit_test(test_easingOutCubic),
cmocka_unit_test(test_easingInOutCubic),
cmocka_unit_test(test_easingInQuart),
cmocka_unit_test(test_easingOutQuart),
cmocka_unit_test(test_easingInOutQuart),
cmocka_unit_test(test_easingInBack),
cmocka_unit_test(test_easingOutBack),
cmocka_unit_test(test_easingInOutBack),
cmocka_unit_test(test_easingApplyDispatchesToEachType),
cmocka_unit_test(test_easingApplyInvalidTypeAsserts),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}