Andrew Kesterson
9924d74dcc
Closes internal-consistency items 1 through 6, 12 and 13. Every include guard is _AKGL_<FILE>_H_, every in-project header include is angled, and every exported function, type and global carries the akgl_ prefix. This is an ABI break; the soname goes to libakgl.so.0.5. TODO.md carries the full rename table. The renames were driven by renaming each declaration and letting the compiler find the uses, not by pattern substitution: renderer, physics and camera are also parameter and struct-member names, and a sed would have rewritten map->physics and every akgl_RenderBackend *renderer parameter without a word. Item 4 turned out not to be cosmetic. The library exported a global called renderer and tests/character.c defined an SDL_Renderer *renderer of its own; the executable's definition preempted the library's, akgl_sprite_load_json read a SDL_Renderer * through an akgl_RenderBackend *, and every texture load in that suite failed. The suite reported success anyway, because libakerror's unhandled-error handler ends in exit(errctx->status), exit keeps only the low byte, and AKGL_ERR_SDL is exactly 256. So character had been green while running one of its four tests, and every suite in the tree was unable to fail on the most common status in a library built on SDL. Both are fixed. tests/testutil.h gains TEST_TRAP_UNHANDLED_ERRORS(), which collapses any status a byte cannot carry onto 1, and every suite installs it. character binds a real backend with akgl_render_2d_bind. Its fourth test then runs for the first time and fails on a defect it has asserted all along, so akgl_heap_release_character now walks state_sprites with AKGL_ITERATOR_OP_RELEASE and destroys the property set before zeroing the slot -- TODO.md Defects item 21 and half of Carried over item 1. AKGL_TIME_ONESEC_MS said "one second in milliseconds" and held 1000000, so akgl_game_state_lock waited roughly sixteen minutes rather than one second. It is AKGL_TIME_ONEMS_NS now, the budget is its own named constant, and tests/game.c holds the mutex from a second thread to assert the wait -- the contended path had no coverage at all. Headers are self-contained and it is enforced: AKGL_PUBLIC_HEADERS drives both install() and a generated translation unit per header, so a header that ships is a header that is checked. Writing that found registry.h, which used SDL_PropertiesID in eight declarations and included no SDL header. 23/23 suites pass, memcheck is clean, reindent --check is clean. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
408 lines
12 KiB
C
408 lines
12 KiB
C
#include <SDL3/SDL.h>
|
|
#include <string.h>
|
|
#include <akerror.h>
|
|
#include <akgl/error.h>
|
|
#include <akgl/heap.h>
|
|
#include <akgl/staticstring.h>
|
|
#include <akgl/util.h>
|
|
|
|
#include "testutil.h"
|
|
|
|
/**
|
|
* @brief How many entries of AKERR_ARRAY_ERROR are currently held by somebody.
|
|
*
|
|
* The error contexts are a fixed pool exactly like the object pools: a context
|
|
* is in use while its reference count is non-zero, and a function that finishes
|
|
* without releasing one has leaked a slot out of AKERR_MAX_ARRAY_ERROR.
|
|
*/
|
|
static int live_error_contexts(void)
|
|
{
|
|
int live = 0;
|
|
int i = 0;
|
|
|
|
for ( i = 0; i < AKERR_MAX_ARRAY_ERROR; i++ ) {
|
|
if ( AKERR_ARRAY_ERROR[i].refcount != 0 ) {
|
|
live += 1;
|
|
}
|
|
}
|
|
return live;
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_rectangle_points_nullpointers(void)
|
|
{
|
|
akgl_RectanglePoints points;
|
|
// Zeroed for the same reason as the fixtures in
|
|
// test_akgl_collide_point_rectangle_nullpointers: the last case here is a
|
|
// real call, and feeding it stack garbage is noise under `memcheck`.
|
|
SDL_FRect testrect = {.x = 0, .y = 0, .w = 0, .h = 0};
|
|
PREPARE_ERROR(errctx);
|
|
|
|
memset((void *)&points, 0x00, sizeof(akgl_RectanglePoints));
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(NULL, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with all NULL pointers");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(NULL, &testrect));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL SDL_FRect pointer");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(&points, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL akgl_RectanglePoints pointer");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(&points, &testrect));
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_rectangle_points_math(void)
|
|
{
|
|
akgl_RectanglePoints points;
|
|
SDL_FRect testrect = {.x = 0, .y = 0, .w = 32, .h = 32};
|
|
memset((void *)&points, 0x00, sizeof(akgl_RectanglePoints));
|
|
|
|
PREPARE_ERROR(errctx);
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(&points, &testrect));
|
|
if ( points.topleft.x != 0 ||
|
|
points.topleft.y != 0 ||
|
|
points.topright.x != 32 ||
|
|
points.topright.y != 0 ||
|
|
points.bottomleft.x != 0 ||
|
|
points.bottomleft.y != 32 ||
|
|
points.bottomright.x != 32 ||
|
|
points.bottomright.y != 32 ) {
|
|
FAIL_BREAK(
|
|
errctx,
|
|
AKGL_ERR_BEHAVIOR,
|
|
"akgl_rectangle_points incorrectly calculated points for {x=0, y=0, w=32, h=32} to {topleft={%d, %d}, topright={%d, %d}, bottomleft={%d, %d}, bottomright={%d, %d}}",
|
|
points.topleft.x, points.topleft.y,
|
|
points.topright.x, points.topright.y,
|
|
points.bottomleft.x, points.bottomleft.y,
|
|
points.bottomright.x, points.bottomright.y
|
|
);
|
|
}
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_collide_point_rectangle_nullpointers(void)
|
|
{
|
|
// Zeroed rather than left as whatever the stack held. The last case in this
|
|
// function is a real call with real arguments, and reading uninitialised
|
|
// floats out of it is sixteen findings under `memcheck` for a test that is
|
|
// not about coordinates at all.
|
|
akgl_Point testpoint = { .x = 0, .y = 0 };
|
|
akgl_RectanglePoints testrectpoints;
|
|
bool testcollide = false;
|
|
|
|
PREPARE_ERROR(errctx);
|
|
|
|
memset(&testrectpoints, 0x00, sizeof(akgl_RectanglePoints));
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_point_rectangle(*, *, NULL) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, NULL, &testcollide));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_point_rectangle(*, NULL, *) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_point_rectangle(NULL, &testrectpoints, &testcollide));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, *, *) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_point_rectangle(NULL, NULL, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, NULL, NULL) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_collide_point_rectangle_logic(void)
|
|
{
|
|
akgl_Point testpoint = {.x = 16, .y = 16};
|
|
SDL_FRect testrect = { .x = 0, .y = 0, .w = 32, .h = 32};
|
|
akgl_RectanglePoints testrectpoints;
|
|
bool testcollide = false;
|
|
PREPARE_ERROR(errctx);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_rectangle_points(&testrectpoints, &testrect));
|
|
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
testpoint.x = 48;
|
|
testpoint.y = 48;
|
|
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
|
|
if ( testcollide == true ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Invalid collision reported");
|
|
}
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_collide_rectangles_nullpointers(void)
|
|
{
|
|
SDL_FRect testrect1 = {.x = 0, .y = 0, .w = 0, .h = 0};
|
|
SDL_FRect testrect2 = {.x = 0, .y = 0, .w = 0, .h = 0};
|
|
bool testcollide = false;
|
|
|
|
PREPARE_ERROR(errctx);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_rectangles(*, *, NULL) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, NULL, &testcollide));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_rectangles(*, NULL, *) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_rectangles(NULL, &testrect2, &testcollide));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_rectangles(NULL, *, *) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_rectangles(NULL, NULL, NULL));
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "akgl_collide_rectangles(NULL, NULL, NULL) failed");
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} HANDLE(errctx, AKERR_NULLPOINTER) {
|
|
// noop
|
|
} FINISH(errctx, true);
|
|
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
akerr_ErrorContext *test_akgl_collide_rectangles_logic(void)
|
|
{
|
|
SDL_FRect testrect1 = { .x = 0, .y = 0, .w = 32, .h = 32};
|
|
SDL_FRect testrect2 = { .x = 30, .y = 30, .w = 40, .h = 40};
|
|
bool testcollide = false;
|
|
|
|
PREPARE_ERROR(errctx);
|
|
|
|
ATTEMPT {
|
|
// Collision overlapping on the top left
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping on the top right
|
|
testrect1.x = 64;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping on the bottom left
|
|
testrect1.x = 0;
|
|
testrect1.y = 32;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping on the bottom right
|
|
testrect1.x = 32;
|
|
testrect1.y = 32;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping the top edge
|
|
testrect1.x = 0;
|
|
testrect1.y = 0;
|
|
testrect1.w = 60;
|
|
testrect1.h = 32;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping the left edge
|
|
testrect1.x = 0;
|
|
testrect1.y = 0;
|
|
testrect1.w = 35;
|
|
testrect1.h = 80;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping the right edge
|
|
testrect1.x = 65;
|
|
testrect1.y = 0;
|
|
testrect1.w = 60;
|
|
testrect1.h = 80;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Collision overlapping the bottom edge
|
|
testrect1.x = 0;
|
|
testrect1.y = 65;
|
|
testrect1.w = 80;
|
|
testrect1.h = 32;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == false ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Valid collision missed");
|
|
}
|
|
|
|
// Not colliding
|
|
testrect1.x = 0;
|
|
testrect1.y = 0;
|
|
testrect1.w = 16;
|
|
testrect1.h = 16;
|
|
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
|
|
if ( testcollide == true ) {
|
|
FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Invalid collision reported");
|
|
}
|
|
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Resolving a path through the root fallback must give its context back.
|
|
*
|
|
* akgl_path_relative tries the working directory first and falls back to
|
|
* resolving against @p root when that reports ENOENT. That fallback used to be
|
|
* taken by returning from inside the HANDLE block, which skips the
|
|
* RELEASE_ERROR that FINISH ends with -- so every call down that branch leaked
|
|
* one entry of AKERR_ARRAY_ERROR, and the 129th call aborted the whole process
|
|
* with "Unable to pull an error context from the array!". A single map load
|
|
* resolves several paths this way.
|
|
*
|
|
* The loop runs well past AKERR_MAX_ARRAY_ERROR on purpose: at the old
|
|
* behaviour this test does not fail, it terminates the suite.
|
|
*/
|
|
akerr_ErrorContext *test_akgl_path_relative_releases_contexts(void)
|
|
{
|
|
PREPARE_ERROR(errctx);
|
|
akgl_String *dst = NULL;
|
|
int before = 0;
|
|
int after = 0;
|
|
int i = 0;
|
|
|
|
PASS(errctx, akgl_heap_init());
|
|
PASS(errctx, akgl_heap_next_string(&dst));
|
|
before = live_error_contexts();
|
|
|
|
for ( i = 0; i < (AKERR_MAX_ARRAY_ERROR * 2); i++ ) {
|
|
PASS(errctx, akgl_path_relative("assets", "testcharacter.json", dst));
|
|
}
|
|
after = live_error_contexts();
|
|
|
|
ATTEMPT {
|
|
if ( after != before ) {
|
|
FAIL_BREAK(
|
|
errctx,
|
|
AKGL_ERR_BEHAVIOR,
|
|
"akgl_path_relative leaked %d error context(s) over %d root-fallback resolutions",
|
|
(after - before),
|
|
(AKERR_MAX_ARRAY_ERROR * 2));
|
|
}
|
|
} CLEANUP {
|
|
IGNORE(akgl_heap_release_string(dst));
|
|
} PROCESS(errctx) {
|
|
} FINISH(errctx, true);
|
|
SUCCEED_RETURN(errctx);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
PREPARE_ERROR(errctx);
|
|
ATTEMPT {
|
|
CATCH(errctx, akgl_error_init());
|
|
TEST_TRAP_UNHANDLED_ERRORS();
|
|
CATCH(errctx, test_akgl_rectangle_points_nullpointers());
|
|
CATCH(errctx, test_akgl_rectangle_points_math());
|
|
CATCH(errctx, test_akgl_collide_point_rectangle_nullpointers());
|
|
CATCH(errctx, test_akgl_collide_rectangles_nullpointers());
|
|
CATCH(errctx, test_akgl_collide_rectangles_logic());
|
|
CATCH(errctx, test_akgl_path_relative_releases_contexts());
|
|
} CLEANUP {
|
|
} PROCESS(errctx) {
|
|
} FINISH_NORETURN(errctx);
|
|
}
|