Andrew Kesterson
af304dc2f9
`cmake --build build --target memcheck` runs every registered CTest suite under valgrind. There are no new test programs, and there should not be any: tests/benchutil.h notices valgrind in LD_PRELOAD and drops the benchmark scale to 0.0005, which turns the perf suites into the broadest path coverage in the tree at a cost valgrind can survive. A benchmark walks one path a hundred thousand times; a leak check wants every path walked once. Same binaries, one flag apart, and the whole run is about thirty seconds. scripts/memcheck.sh wraps `ctest -T memcheck` because that command records defects and still exits 0, which cannot gate anything. It also forces the headless drivers, so the vendor GPU stack is never loaded -- that removes thousands of unfixable findings inside amdgpu_dri.so without suppressing anything, and it is what the suites are written for anyway. Only definite losses, invalid accesses and uninitialised reads count; "still reachable" is what SDL and FreeType keep for the process lifetime and says nothing about this library. The three suppressions in scripts/valgrind.supp are each a decision that a finding belongs to somebody else. Six defects, all filed in TODO.md under "Memory checking", the first of which is the one that matters: not one of the four json_load_file calls in src/ is ever matched by a json_decref, so every asset load abandons its parsed document -- 1.5 KB per sprite, 2.1 KB per character, 9 KB per load of the 2x2 fixture map, and on the order of a megabyte for a real one. A game that reloads a level on death leaks a level's worth of JSON every time. akgl_get_property also reads up to 4 KiB past the end of every property value it copies, and the savegame name tables read past the end of every registry key and write what they find into the file. tests/util.c zeroes three fixtures it used to leave as stack garbage. The library was never at fault there -- the tests handed it uninitialised floats and then made one real call with them -- but sixteen findings of noise in a new gate is how a gate gets ignored. The unit suites' TIMEOUT goes from 30 to 300 because CTest applies the same property to the checked run, where everything is twenty times slower. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
405 lines
12 KiB
C
405 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>
|
|
|
|
/**
|
|
* @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;
|
|
// 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(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 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)
|
|
{
|
|
// 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.
|
|
point testpoint = { .x = 0, .y = 0 };
|
|
RectanglePoints testrectpoints;
|
|
bool testcollide = false;
|
|
|
|
PREPARE_ERROR(errctx);
|
|
|
|
memset(&testrectpoints, 0x00, sizeof(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)
|
|
{
|
|
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 = {.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());
|
|
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);
|
|
}
|