Andrew Kesterson
c6227545a6
akgl_path_relative took its ENOENT branch by returning from inside the HANDLE block, which skips the RELEASE_ERROR that FINISH ends with. The handled context was never given back, so one entry of AKERR_ARRAY_ERROR was lost per call and the 129th call hit "Unable to pull an error context from the array!" and exited the process. That branch is not an edge case: every asset path inside a tilemap is resolved relative to the map's own directory, so it is taken several times per map load. A game that loaded fifty levels died in the loader. It was found by a benchmark that loaded the fixture map in a loop, which is the first thing in this tree to call it more than a hundred times. The fallback now runs after FINISH, so the context is released on the way past. tests/util.c resolves AKERR_MAX_ARRAY_ERROR * 2 paths through the branch and asserts the pool is where it started -- against the old code that test does not fail, it terminates the suite. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
393 lines
12 KiB
C
393 lines
12 KiB
C
#include <SDL3/SDL.h>
|
|
#include <akerror.h>
|
|
#include <akgl/error.h>
|
|
#include <akgl/heap.h>
|
|
#include <akgl/staticstring.h>
|
|
#include <akgl/util.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)
|
|
{
|
|
RectanglePoints points;
|
|
SDL_FRect testrect;
|
|
PREPARE_ERROR(errctx);
|
|
|
|
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 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)
|
|
{
|
|
RectanglePoints points;
|
|
SDL_FRect testrect = {.x = 0, .y = 0, .w = 32, .h = 32};
|
|
memset((void *)&points, 0x00, sizeof(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)
|
|
{
|
|
point testpoint;
|
|
RectanglePoints testrectpoints;
|
|
bool testcollide;
|
|
|
|
PREPARE_ERROR(errctx);
|
|
|
|
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)
|
|
{
|
|
point testpoint = {.x = 16, .y = 16};
|
|
SDL_FRect testrect = { .x = 0, .y = 0, .w = 32, .h = 32};
|
|
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;
|
|
SDL_FRect testrect2;
|
|
bool testcollide;
|
|
|
|
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());
|
|
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);
|
|
}
|