andrew/libakgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unify the library on an akgl_ namespace

Browse Source
This commit is contained in:
Andrew Kesterson
2026-05-06 23:18:42 -04:00
parent f416cb5dee
commit 359ae23414
46 changed files with 1327 additions and 1270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
tests/actor.c
View File

@@ -32,20 +32,20 @@ void handle_unhandled_error_noexit(akerr_ErrorContext *errctx)
}
}
int actor_updated;
akerr_ErrorContext *actor_update_noop(actor *obj)
int akgl_actor_updated;
akerr_ErrorContext *akgl_actor_update_noop(akgl_Actor *obj)
{
PREPARE_ERROR(errctx);
actor_updated = 1;
akgl_actor_updated = 1;
SUCCEED_RETURN(errctx);
}
// Currently the renderer assumes there is a global variable named `renderer`
int actor_rendered;
akerr_ErrorContext *actor_render_noop(actor *obj, SDL_Renderer *r)
int akgl_actor_rendered;
akerr_ErrorContext *akgl_actor_render_noop(akgl_Actor *obj, SDL_Renderer *r)
{
PREPARE_ERROR(errctx);
actor_rendered = 1;
akgl_actor_rendered = 1;
SUCCEED_RETURN(errctx);
}
@@ -58,7 +58,7 @@ akerr_ErrorContext *test_registry_actor_iterator_nullpointers(void)
akerr_handler_unhandled_error = handle_unhandled_error_noexit;
ATTEMPT {
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET;
DETECT(unhandled_error_context, registry_iterate_actor(NULL, REGISTRY_ACTOR, ""));
DETECT(unhandled_error_context, akgl_registry_iterate_actor(NULL, AKGL_REGISTRY_ACTOR, ""));
} CLEANUP {
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT;
} PROCESS(unhandled_error_context) {
@@ -74,7 +74,7 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void)
PREPARE_ERROR(errctx);
akerr_ErrorUnhandledErrorHandler defaulthandler = akerr_handler_unhandled_error;
iterator iter = {
akgl_Iterator iter = {
.layerid = 0,
.flags = 0
};
@@ -83,9 +83,9 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void)
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET;
DETECT(
unhandled_error_context,
registry_iterate_actor(
akgl_registry_iterate_actor(
&iter,
REGISTRY_ACTOR,
AKGL_REGISTRY_ACTOR,
"Actor who doesn't exist")
);
} CLEANUP {
@@ -100,10 +100,10 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void)
akerr_ErrorContext *test_registry_actor_iterator_updaterender(void)
{
actor *testactor;
iterator iter = {
akgl_Actor *testactor;
akgl_Iterator iter = {
.layerid = 0,
.flags = ITERATOR_OP_UPDATE | ITERATOR_OP_RENDER
.flags = AKGL_ITERATOR_OP_UPDATE | AKGL_ITERATOR_OP_RENDER
};
akerr_ErrorUnhandledErrorHandler defaulthandler = akerr_handler_unhandled_error;
@@ -111,36 +111,36 @@ akerr_ErrorContext *test_registry_actor_iterator_updaterender(void)
akerr_handler_unhandled_error = handle_unhandled_error_noexit;
ATTEMPT {
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET;
CATCH(unhandled_error_context, heap_next_actor(&testactor));
CATCH(unhandled_error_context, actor_initialize(testactor, "test"));
CATCH(unhandled_error_context, akgl_heap_next_actor(&testactor));
CATCH(unhandled_error_context, akgl_actor_initialize(testactor, "test"));
testactor->layer = 0;
testactor->updatefunc = &actor_update_noop;
testactor->renderfunc = &actor_render_noop;
testactor->updatefunc = &akgl_actor_update_noop;
testactor->renderfunc = &akgl_actor_render_noop;
DETECT(
unhandled_error_context,
registry_iterate_actor(
akgl_registry_iterate_actor(
&iter,
REGISTRY_ACTOR,
AKGL_REGISTRY_ACTOR,
"test")
);
FAIL_ZERO_BREAK(
unhandled_error_context,
actor_updated,
akgl_actor_updated,
AKERR_BEHAVIOR,
"actor->updatefunc not called by the iterator"
);
FAIL_ZERO_BREAK(
unhandled_error_context,
actor_rendered,
akgl_actor_rendered,
AKERR_BEHAVIOR,
"actor->renderfunc not called by the iterator"
);
} CLEANUP {
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT;
IGNORE(heap_release_actor(testactor));
IGNORE(akgl_heap_release_actor(testactor));
} PROCESS(unhandled_error_context) {
} FINISH(unhandled_error_context, true);
@@ -149,15 +149,15 @@ akerr_ErrorContext *test_registry_actor_iterator_updaterender(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_actor_set_character(void)
akerr_ErrorContext *test_akgl_actor_set_character(void)
{
actor *testactor = NULL;
character *testchar = NULL;
akgl_Actor *testactor = NULL;
akgl_Character *testchar = NULL;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, actor_set_character(NULL, "test"));
CATCH(errctx, akgl_actor_set_character(NULL, "test"));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -166,36 +166,36 @@ akerr_ErrorContext *test_actor_set_character(void)
ATTEMPT {
CATCH(errctx, heap_next_actor(&testactor));
CATCH(errctx, akgl_heap_next_actor(&testactor));
CATCH(errctx, actor_initialize(testactor, "test"));
CATCH(errctx, akgl_actor_initialize(testactor, "test"));
testactor->layer = 0;
testactor->updatefunc = &actor_update_noop;
testactor->renderfunc = &actor_render_noop;
testactor->updatefunc = &akgl_actor_update_noop;
testactor->renderfunc = &akgl_actor_render_noop;
CATCH(errctx, actor_set_character(testactor, "test"));
CATCH(errctx, akgl_actor_set_character(testactor, "test"));
} CLEANUP {
IGNORE(heap_release_actor(testactor));
IGNORE(akgl_heap_release_actor(testactor));
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
printf("Handled\n");
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, heap_next_actor(&testactor));
CATCH(errctx, heap_next_character(&testchar));
CATCH(errctx, akgl_heap_next_actor(&testactor));
CATCH(errctx, akgl_heap_next_character(&testchar));
CATCH(errctx, actor_initialize(testactor, "test"));
CATCH(errctx, akgl_actor_initialize(testactor, "test"));
testactor->layer = 0;
testactor->updatefunc = &actor_update_noop;
testactor->renderfunc = &actor_render_noop;
testactor->updatefunc = &akgl_actor_update_noop;
testactor->renderfunc = &akgl_actor_render_noop;
CATCH(errctx, character_initialize(testchar, "test"));
CATCH(errctx, akgl_character_initialize(testchar, "test"));
CATCH(errctx, actor_set_character(testactor, "test"));
CATCH(errctx, akgl_actor_set_character(testactor, "test"));
} CLEANUP {
IGNORE(heap_release_actor(testactor));
IGNORE(heap_release_character(testchar));
IGNORE(akgl_heap_release_actor(testactor));
IGNORE(akgl_heap_release_character(testchar));
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -204,28 +204,28 @@ akerr_ErrorContext *test_actor_set_character(void)
akerr_ErrorContext *test_actor_manage_children(void)
{
actor *parent = NULL;
actor *child = NULL;
string *tmpstring = NULL;
akgl_Actor *parent = NULL;
akgl_Actor *child = NULL;
akgl_String *tmpstring = NULL;
int i = 0;
int j = 0;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_init());
CATCH(errctx, heap_next_string(&tmpstring));
CATCH(errctx, heap_next_actor(&parent));
CATCH(errctx, actor_initialize(parent, "parent"));
for ( i = 0 ; i < ACTOR_MAX_CHILDREN; i++ ) {
CATCH(errctx, akgl_heap_init());
CATCH(errctx, akgl_heap_next_string(&tmpstring));
CATCH(errctx, akgl_heap_next_actor(&parent));
CATCH(errctx, akgl_actor_initialize(parent, "parent"));
for ( i = 0 ; i < AKGL_ACTOR_MAX_CHILDREN; i++ ) {
sprintf((char *)&tmpstring->data, "child %d", i);
CATCH(errctx, heap_next_actor(&child));
CATCH(errctx, actor_initialize(child, (char *)&tmpstring->data));
CATCH(errctx, akgl_heap_next_actor(&child));
CATCH(errctx, akgl_actor_initialize(child, (char *)&tmpstring->data));
CATCH(errctx, parent->addchild(parent, child));
// Release our claim on the actor so the parent can own the child and kill it
CATCH(errctx, heap_release_actor(child));
CATCH(errctx, akgl_heap_release_actor(child));
}
} CLEANUP {
IGNORE(heap_release_string(tmpstring));
IGNORE(akgl_heap_release_string(tmpstring));
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -244,7 +244,7 @@ akerr_ErrorContext *test_actor_manage_children(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, heap_next_actor(&child));
CATCH(errctx, akgl_heap_next_actor(&child));
CATCH(errctx, parent->addchild(parent, child));
} CLEANUP {
if ( errctx == NULL ) {
@@ -257,23 +257,23 @@ akerr_ErrorContext *test_actor_manage_children(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, heap_release_actor(parent));
CATCH(errctx, akgl_heap_release_actor(parent));
// All actor objects on the heap should be empty now
for ( i = 0; i < MAX_HEAP_ACTOR; i++) {
for ( i = 0; i < AKGL_MAX_HEAP_ACTOR; i++) {
FAIL_NONZERO_BREAK(errctx, HEAP_ACTOR[i].refcount, AKERR_VALUE, "Actor not properly cleared");
FAIL_NONZERO_BREAK(errctx, HEAP_ACTOR[i].parent, AKERR_VALUE, "Actor not properly cleared");
for ( j = 0 ; j < ACTOR_MAX_CHILDREN; j++) {
for ( j = 0 ; j < AKGL_ACTOR_MAX_CHILDREN; j++) {
if ( HEAP_ACTOR[i].children[j] != NULL ) {
FAIL(errctx, AKERR_VALUE, "Actor not properly cleared");
goto _test_actor_addchild_heaprelease_cleanup;
}
}
}
for ( j = 0; j < ACTOR_MAX_CHILDREN; j++) {
for ( j = 0; j < AKGL_ACTOR_MAX_CHILDREN; j++) {
sprintf((char *)&tmpstring->data, "child %d", i);
FAIL_NONZERO_BREAK(
errctx,
SDL_GetPointerProperty(REGISTRY_ACTOR, (char *)&tmpstring->data, NULL),
SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, (char *)&tmpstring->data, NULL),
AKERR_KEY,
"Child %s was not removed from the registry",
(char *)&tmpstring->data);
@@ -284,22 +284,22 @@ _test_actor_addchild_heaprelease_cleanup:
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, heap_next_actor(&parent));
CATCH(errctx, actor_initialize(parent, "parent"));
CATCH(errctx, heap_next_actor(&child));
CATCH(errctx, actor_initialize(child, "child"));
CATCH(errctx, akgl_heap_next_actor(&parent));
CATCH(errctx, akgl_actor_initialize(parent, "parent"));
CATCH(errctx, akgl_heap_next_actor(&child));
CATCH(errctx, akgl_actor_initialize(child, "child"));
// Don't release our claim on the child. The child should not be reclaimed.
CATCH(errctx, heap_release_actor(parent));
CATCH(errctx, akgl_heap_release_actor(parent));
FAIL_NONZERO_BREAK(errctx, child->parent, AKERR_VALUE, "Child still references released parent");
FAIL_ZERO_BREAK(errctx, child->refcount, AKERR_VALUE, "Child prematurely released");
FAIL_NONZERO_BREAK(errctx, strcmp(child->name, "child"), AKERR_VALUE, "Child had identity erased");
FAIL_ZERO_BREAK(
errctx,
(child == SDL_GetPointerProperty(REGISTRY_ACTOR, child->name, NULL)),
(child == SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, child->name, NULL)),
AKERR_KEY,
"Child prematurely removed from the registry");
// Now we can release the child
CATCH(errctx, heap_release_actor(child));
CATCH(errctx, akgl_heap_release_actor(child));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -309,20 +309,20 @@ _test_actor_addchild_heaprelease_cleanup:
int main(void)
{
actor_updated = 0;
actor_rendered = 0;
akgl_actor_updated = 0;
akgl_actor_rendered = 0;
UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, registry_init_actor());
CATCH(errctx, registry_init_sprite());
CATCH(errctx, registry_init_spritesheet());
CATCH(errctx, registry_init_character());
CATCH(errctx, akgl_registry_init_actor());
CATCH(errctx, akgl_registry_init_sprite());
CATCH(errctx, akgl_registry_init_spritesheet());
CATCH(errctx, akgl_registry_init_character());
CATCH(errctx, test_registry_actor_iterator_nullpointers());
CATCH(errctx, test_registry_actor_iterator_missingactor());
CATCH(errctx, test_registry_actor_iterator_updaterender());
CATCH(errctx, test_actor_set_character());
CATCH(errctx, test_akgl_actor_set_character());
CATCH(errctx, test_actor_manage_children());
} CLEANUP {
} PROCESS(errctx) {

4
tests/assets/testcharacter.json
View File

@@ -5,8 +5,8 @@
"sprite_mappings": [
{
"state": [
"ACTOR_STATE_ALIVE",
"ACTOR_STATE_FACE_LEFT"
"AKGL_ACTOR_STATE_ALIVE",
"AKGL_ACTOR_STATE_FACE_LEFT"
],
"sprite": "testsprite"
},

30
tests/bitmasks.c
View File

@@ -4,28 +4,28 @@
int main(void)
{
int mask = 0;
BITMASK_ADD(mask, ACTOR_STATE_ALIVE);
if ( mask != ACTOR_STATE_ALIVE )
AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_ALIVE);
if ( mask != AKGL_ACTOR_STATE_ALIVE )
return 1;
BITMASK_ADD(mask, ACTOR_STATE_FACE_LEFT);
if ( mask != (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT) )
AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_LEFT);
if ( mask != (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT) )
return 1;
BITMASK_DEL(mask, ACTOR_STATE_ALIVE);
if ( mask != (ACTOR_STATE_FACE_LEFT) )
AKGL_BITMASK_DEL(mask, AKGL_ACTOR_STATE_ALIVE);
if ( mask != (AKGL_ACTOR_STATE_FACE_LEFT) )
return 1;
BITMASK_CLEAR(mask);
AKGL_BITMASK_CLEAR(mask);
if ( mask != 0 )
return 1;
BITMASK_ADD(mask, ACTOR_STATE_FACE_LEFT);
if ( !(BITMASK_HAS(mask, ACTOR_STATE_FACE_LEFT)) )
AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_LEFT);
if ( !(AKGL_BITMASK_HAS(mask, AKGL_ACTOR_STATE_FACE_LEFT)) )
return 1;
mask = ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_UP;
BITMASK_DEL(mask, ACTOR_STATE_FACE_ALL);
if ( mask != ACTOR_STATE_ALIVE )
mask = AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_UP;
AKGL_BITMASK_DEL(mask, AKGL_ACTOR_STATE_FACE_ALL);
if ( mask != AKGL_ACTOR_STATE_ALIVE )
return 1;
BITMASK_ADD(mask, ACTOR_STATE_MOVING_DOWN);
BITMASK_ADD(mask, ACTOR_STATE_FACE_DOWN);
if ( mask != (ACTOR_STATE_ALIVE | ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_DOWN) )
AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_MOVING_DOWN);
AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_DOWN);
if ( mask != (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_DOWN) )
return 1;
return 0;
}

134
tests/character.c
View File

@@ -11,16 +11,16 @@
SDL_Window *window;
SDL_Renderer *renderer;
akerr_ErrorContext *test_character_initialize()
akerr_ErrorContext *test_akgl_character_initialize()
{
PREPARE_ERROR(errctx);
character *testchar = NULL;
akgl_Character *testchar = NULL;
ATTEMPT {
CATCH(errctx, heap_next_character(&testchar));
CATCH(errctx, character_initialize(testchar, "testchar"));
CATCH(errctx, akgl_heap_next_character(&testchar));
CATCH(errctx, akgl_character_initialize(testchar, "testchar"));
FAIL_ZERO_BREAK(
errctx,
SDL_GetPointerProperty(REGISTRY_CHARACTER, "testchar", NULL),
SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testchar", NULL),
AKERR_KEY,
"Character was not placed in the registry");
FAIL_NONZERO_BREAK(
@@ -35,7 +35,7 @@ akerr_ErrorContext *test_character_initialize()
AKERR_NULLPOINTER,
"Character state sprites map was not initialized");
} CLEANUP {
IGNORE(heap_release_character(testchar));
IGNORE(akgl_heap_release_character(testchar));
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
@@ -43,37 +43,37 @@ akerr_ErrorContext *test_character_initialize()
akerr_ErrorContext *test_character_sprite_mgmt()
{
character *testchar = NULL;
sprite *testsprite = NULL;
sprite *testsprite2 = NULL;
sprite *comparesprite = NULL;
akgl_Character *testchar = NULL;
akgl_Sprite *testsprite = NULL;
akgl_Sprite *testsprite2 = NULL;
akgl_Sprite *comparesprite = NULL;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_next_character(&testchar));
CATCH(errctx, sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL);
CATCH(errctx, akgl_heap_next_character(&testchar));
CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite,
AKERR_KEY,
"Sprite loaded from json but not in registry");
CATCH(errctx, sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL);
CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite2,
AKERR_KEY,
"Sprite 2 loaded from json but not in registry");
CATCH(errctx, testchar->sprite_add(testchar, testsprite, ACTOR_STATE_ALIVE));
CATCH(errctx, testchar->sprite_add(testchar, testsprite2, ACTOR_STATE_DEAD));
CATCH(errctx, testchar->sprite_get(testchar, (ACTOR_STATE_ALIVE), &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT");
CATCH(errctx, testchar->sprite_get(testchar, ACTOR_STATE_DEAD, &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_DEAD");
CATCH(errctx, testchar->sprite_add(testchar, testsprite, AKGL_ACTOR_STATE_ALIVE));
CATCH(errctx, testchar->sprite_add(testchar, testsprite2, AKGL_ACTOR_STATE_DEAD));
CATCH(errctx, testchar->sprite_get(testchar, (AKGL_ACTOR_STATE_ALIVE), &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT");
CATCH(errctx, testchar->sprite_get(testchar, AKGL_ACTOR_STATE_DEAD, &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_DEAD");
} CLEANUP {
IGNORE(heap_release_sprite(testsprite));
IGNORE(heap_release_sprite(testsprite2));
IGNORE(heap_release_character(testchar));
IGNORE(akgl_heap_release_sprite(testsprite));
IGNORE(akgl_heap_release_sprite(testsprite2));
IGNORE(akgl_heap_release_character(testchar));
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
@@ -81,103 +81,103 @@ akerr_ErrorContext *test_character_sprite_mgmt()
akerr_ErrorContext *test_character_iterate_state_sprites()
{
character *testchar = NULL;
sprite *testsprite = NULL;
sprite *testsprite2 = NULL;
iterator opflags = {.flags = ITERATOR_OP_RELEASE, .layerid = 0};
akgl_Character *testchar = NULL;
akgl_Sprite *testsprite = NULL;
akgl_Sprite *testsprite2 = NULL;
akgl_Iterator opflags = {.flags = AKGL_ITERATOR_OP_RELEASE, .layerid = 0};
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_next_character(&testchar));
CATCH(errctx, sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL);
CATCH(errctx, akgl_heap_next_character(&testchar));
CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite,
AKERR_KEY,
"Sprite loaded from json but not in registry");
CATCH(errctx, sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL);
CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite2,
AKERR_KEY,
"Sprite 2 loaded from json but not in registry");
CATCH(errctx, testchar->sprite_add(testchar, testsprite, ACTOR_STATE_ALIVE));
CATCH(errctx, testchar->sprite_add(testchar, testsprite2, ACTOR_STATE_DEAD));
CATCH(errctx, testchar->sprite_add(testchar, testsprite, AKGL_ACTOR_STATE_ALIVE));
CATCH(errctx, testchar->sprite_add(testchar, testsprite2, AKGL_ACTOR_STATE_DEAD));
SDL_EnumerateProperties(testchar->state_sprites, &character_state_sprites_iterate, &opflags);
SDL_EnumerateProperties(testchar->state_sprites, &akgl_character_state_sprites_iterate, &opflags);
// This is called by heap_release_character so we should assume that our property map is being
// This is called by akgl_heap_release_character so we should assume that our property map is being
// deleted soon after this. So we don't care if the sprites have been deleted from the sprite_states.
// We just want to know they've been released.
FAIL_NONZERO_BREAK(
errctx,
(testsprite->refcount > 1),
AKERR_VALUE,
"heap_release_sprite not called for testsprite from iterator");
"akgl_heap_release_sprite not called for testsprite from iterator");
FAIL_NONZERO_BREAK(
errctx,
(testsprite2->refcount > 1),
AKERR_VALUE,
"heap_release_sprite not called for testsprite from iterator");
"akgl_heap_release_sprite not called for testsprite from iterator");
} CLEANUP {
IGNORE(heap_release_sprite(testsprite));
IGNORE(heap_release_sprite(testsprite2));
IGNORE(heap_release_character(testchar));
IGNORE(akgl_heap_release_sprite(testsprite));
IGNORE(akgl_heap_release_sprite(testsprite2));
IGNORE(akgl_heap_release_character(testchar));
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_character_load_json()
akerr_ErrorContext *test_akgl_character_load_json()
{
character *testcharacter = NULL;
sprite *testsprite = NULL;
sprite *testsprite2 = NULL;
sprite *comparesprite = NULL;
akgl_Character *testcharacter = NULL;
akgl_Sprite *testsprite = NULL;
akgl_Sprite *testsprite2 = NULL;
akgl_Sprite *comparesprite = NULL;
int tsrc = 0;
int tsrc2 = 0;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_next_character(&testcharacter));
CATCH(errctx, sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL);
CATCH(errctx, akgl_heap_next_character(&testcharacter));
CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite,
AKERR_KEY,
"Sprite loaded from json but not in registry");
CATCH(errctx, sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL);
CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite2,
AKERR_KEY,
"Sprite 2 loaded from json but not in registry");
CATCH(errctx, character_load_json("assets/testcharacter.json"));
testcharacter = SDL_GetPointerProperty(REGISTRY_CHARACTER, "testcharacter", NULL);
CATCH(errctx, akgl_character_load_json("assets/testcharacter.json"));
testcharacter = SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testcharacter", NULL);
FAIL_ZERO_BREAK(
errctx,
testcharacter,
AKERR_KEY,
"Character loaded from json but not in registry");
CATCH(errctx, testcharacter->sprite_get(testcharacter, (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT), &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_ALIVE");
CATCH(errctx, testcharacter->sprite_get(testcharacter, ACTOR_STATE_DEAD, &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_DEAD");
CATCH(errctx, testcharacter->sprite_get(testcharacter, (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT), &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_ALIVE");
CATCH(errctx, testcharacter->sprite_get(testcharacter, AKGL_ACTOR_STATE_DEAD, &comparesprite));
FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_DEAD");
FAIL_ZERO_BREAK(errctx, (testcharacter->vx != 0.200000003), AKERR_VALUE, "Wrong X velocity for test character");
FAIL_ZERO_BREAK(errctx, (testcharacter->vy != 0.200000003), AKERR_VALUE, "Wrong Y velocity for test character");
// Release our handles on the sprites so the character's heap_release can reduce them to 0
CATCH(errctx, heap_release_sprite(testsprite));
CATCH(errctx, heap_release_sprite(testsprite2));
CATCH(errctx, akgl_heap_release_sprite(testsprite));
CATCH(errctx, akgl_heap_release_sprite(testsprite2));
tsrc = testsprite->refcount;
tsrc2 = testsprite2->refcount;
CATCH(errctx, heap_release_character(testcharacter));
CATCH(errctx, akgl_heap_release_character(testcharacter));
FAIL_ZERO_BREAK(
errctx,
((testsprite->refcount < tsrc) || (testsprite2->refcount < tsrc2)),
@@ -196,19 +196,19 @@ int main(void)
SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest");
if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
}
if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_character", 640, 480, SDL_WINDOW_HIDDEN, &window, &renderer)) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
}
CATCH(errctx, heap_init());
CATCH(errctx, registry_init());
CATCH(errctx, test_character_initialize());
CATCH(errctx, akgl_heap_init());
CATCH(errctx, akgl_registry_init());
CATCH(errctx, test_akgl_character_initialize());
CATCH(errctx, test_character_sprite_mgmt());
CATCH(errctx, test_character_iterate_state_sprites());
CATCH(errctx, test_character_load_json());
CATCH(errctx, test_akgl_character_load_json());
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);

56
tests/charviewer.c
View File

@@ -40,15 +40,15 @@ int main(void)
SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest");
if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
}
if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 640, 480, 0, &window, &renderer)) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
}
CATCH(errctx, heap_init());
CATCH(errctx, registry_init());
CATCH(errctx, akgl_heap_init());
CATCH(errctx, akgl_registry_init());
strcpy((char *)&game.name, "charviewer");
strcpy((char *)&game.version, "0.0.1");
@@ -56,21 +56,21 @@ int main(void)
game.screenwidth = 640;
game.screenheight = 480;
CATCH(errctx, GAME_init());
CATCH(errctx, akgl_GAME_init());
for ( int i = 0; i < numsprites ; i++) {
CATCH(errctx, sprite_load_json(spritepaths[i]));
CATCH(errctx, akgl_sprite_load_json(spritepaths[i]));
}
CATCH(errctx, character_load_json("assets/characters/littleguy.json"));
CATCH(errctx, heap_next_actor(&actorptr));
CATCH(errctx, actor_initialize((actor *)actorptr, "player"));
CATCH(errctx, akgl_character_load_json("assets/characters/littleguy.json"));
CATCH(errctx, akgl_heap_next_actor(&actorptr));
CATCH(errctx, akgl_actor_initialize((actor *)actorptr, "player"));
actorptr->basechar = SDL_GetPointerProperty(
REGISTRY_CHARACTER,
AKGL_REGISTRY_CHARACTER,
"little guy",
NULL);
FAIL_ZERO_BREAK(errctx, actorptr->basechar, AKERR_REGISTRY, "Can't load character 'little guy' from the registry");
actorptr->movement_controls_face = false;
actorptr->state = (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT);
actorptr->state = (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT);
actorptr->x = 320;
actorptr->y = 240;
actorptr->visible = true;
@@ -78,40 +78,40 @@ int main(void)
// set up the control map
controlmap = &GAME_ControlMaps[0];
controlmap->kbid = 0;
controlmap->target = SDL_GetPointerProperty(REGISTRY_ACTOR, "player", NULL);
controlmap->target = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "player", NULL);
// Move down
controlmap->controls[0].key = SDLK_DOWN;
//controlmap->controls[0].target_state_gate = ACTOR_STATE_MOVING_DOWN;
controlmap->controls[0].target_add_state_on = ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_DOWN;
controlmap->controls[0].target_del_state_on = ACTOR_STATE_MOVING_UP | ACTOR_STATE_FACE_ALL;
controlmap->controls[0].target_del_state_off = ACTOR_STATE_MOVING_DOWN;
//controlmap->controls[0].target_state_gate = AKGL_ACTOR_STATE_MOVING_DOWN;
controlmap->controls[0].target_add_state_on = AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_DOWN;
controlmap->controls[0].target_del_state_on = AKGL_ACTOR_STATE_MOVING_UP | AKGL_ACTOR_STATE_FACE_ALL;
controlmap->controls[0].target_del_state_off = AKGL_ACTOR_STATE_MOVING_DOWN;
controlmap->controls[0].event_on = SDL_EVENT_KEY_DOWN;
controlmap->controls[0].event_off = SDL_EVENT_KEY_UP;
// Move up
controlmap->controls[1].key = SDLK_UP;
//controlmap->controls[1].target_state_gate = ACTOR_STATE_MOVING_UP;
controlmap->controls[1].target_add_state_on = ACTOR_STATE_MOVING_UP | ACTOR_STATE_FACE_UP;
controlmap->controls[1].target_del_state_on = ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_ALL;
controlmap->controls[1].target_del_state_off = ACTOR_STATE_MOVING_UP;
//controlmap->controls[1].target_state_gate = AKGL_ACTOR_STATE_MOVING_UP;
controlmap->controls[1].target_add_state_on = AKGL_ACTOR_STATE_MOVING_UP | AKGL_ACTOR_STATE_FACE_UP;
controlmap->controls[1].target_del_state_on = AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_ALL;
controlmap->controls[1].target_del_state_off = AKGL_ACTOR_STATE_MOVING_UP;
controlmap->controls[1].event_on = SDL_EVENT_KEY_DOWN;
controlmap->controls[1].event_off = SDL_EVENT_KEY_UP;
// Move left
controlmap->controls[2].key = SDLK_LEFT;
//controlmap->controls[2].target_state_gate = ACTOR_STATE_MOVING_LEFT;
controlmap->controls[2].target_add_state_on = ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_FACE_LEFT;
controlmap->controls[2].target_del_state_on = ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_FACE_ALL;
controlmap->controls[2].target_del_state_off = ACTOR_STATE_MOVING_LEFT;
//controlmap->controls[2].target_state_gate = AKGL_ACTOR_STATE_MOVING_LEFT;
controlmap->controls[2].target_add_state_on = AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_FACE_LEFT;
controlmap->controls[2].target_del_state_on = AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_FACE_ALL;
controlmap->controls[2].target_del_state_off = AKGL_ACTOR_STATE_MOVING_LEFT;
controlmap->controls[2].event_on = SDL_EVENT_KEY_DOWN;
controlmap->controls[2].event_off = SDL_EVENT_KEY_UP;
// Move right
controlmap->controls[3].key = SDLK_RIGHT;
//controlmap->controls[3].target_state_gate = ACTOR_STATE_MOVING_RIGHT;
controlmap->controls[3].target_add_state_on = ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_FACE_RIGHT;
controlmap->controls[3].target_del_state_on = ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_FACE_ALL;
controlmap->controls[3].target_del_state_off = ACTOR_STATE_MOVING_RIGHT;
//controlmap->controls[3].target_state_gate = AKGL_ACTOR_STATE_MOVING_RIGHT;
controlmap->controls[3].target_add_state_on = AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_FACE_RIGHT;
controlmap->controls[3].target_del_state_on = AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_FACE_ALL;
controlmap->controls[3].target_del_state_off = AKGL_ACTOR_STATE_MOVING_RIGHT;
controlmap->controls[3].event_on = SDL_EVENT_KEY_DOWN;
controlmap->controls[3].event_off = SDL_EVENT_KEY_UP;
} CLEANUP {

14
tests/registry.c
View File

@@ -11,7 +11,7 @@ void *sdl_calloc_always_fails(size_t a, size_t b)
return NULL;
}
akerr_ErrorContext *test_registry_init(RegistryFuncPtr funcptr)
akerr_ErrorContext *test_akgl_registry_init(RegistryFuncPtr funcptr)
{
SDL_malloc_func malloc_func;
SDL_calloc_func calloc_func;
@@ -46,11 +46,11 @@ akerr_ErrorContext *test_registry_init(RegistryFuncPtr funcptr)
FAIL_RETURN(errctx, AKERR_BEHAVIOR, "SDL memory allocator fails but registry reports successful property creation");
}
akerr_ErrorContext *test_registry_init_creation_failures(void)
akerr_ErrorContext *test_akgl_registry_init_creation_failures(void)
{
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, test_registry_init(&registry_init_actor));
CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_actor));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -58,7 +58,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, test_registry_init(&registry_init_sprite));
CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_sprite));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -66,7 +66,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, test_registry_init(&registry_init_spritesheet));
CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_spritesheet));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -74,7 +74,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, test_registry_init(&registry_init_character));
CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_character));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -87,7 +87,7 @@ int main(void)
{
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, test_registry_init_creation_failures());
CATCH(errctx, test_akgl_registry_init_creation_failures());
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);

108
tests/sprite.c
View File

@@ -14,35 +14,35 @@
SDL_Window *window;
SDL_Renderer *renderer;
akerr_ErrorContext *test_spritesheet_initialize(void)
akerr_ErrorContext *test_akgl_spritesheet_initialize(void)
{
PREPARE_ERROR(errctx);
spritesheet *sheet = NULL;
akgl_SpriteSheet *sheet = NULL;
SDL_Texture *image = NULL;
string *tmpstr = NULL;
akgl_String *tmpstr = NULL;
// Does the image file get loaded?
// Is the image file loaded correctly? (Surface comparison)
// Is the spritesheet in the registry?
ATTEMPT {
CATCH(errctx, heap_next_spritesheet(&sheet));
CATCH(errctx, heap_next_string(&tmpstr));
CATCH(errctx, akgl_heap_next_spritesheet(&sheet));
CATCH(errctx, akgl_heap_next_string(&tmpstr));
snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
CATCH(errctx, spritesheet_initialize(sheet, 48, 48, "assets/spritesheet.png"));
FAIL_ZERO_BREAK(errctx, sheet->texture, AKERR_VALUE, "spritesheet_initialize failed to load the sprite texture");
snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
CATCH(errctx, akgl_spritesheet_initialize(sheet, 48, 48, "assets/spritesheet.png"));
FAIL_ZERO_BREAK(errctx, sheet->texture, AKERR_VALUE, "akgl_spritesheet_initialize failed to load the sprite texture");
FAIL_NONZERO_BREAK(
errctx,
((sheet->texture->w != 576) || (sheet->texture->h != 384)),
AKERR_VALUE,
"Loaded texture was not the correct size");
snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
image = IMG_LoadTexture(renderer, (char *)&tmpstr->data);
FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image");
FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image");
CATCH(
errctx,
render_and_compare(
akgl_render_and_compare(
sheet->texture,
image,
0, 0, 576, 384,
@@ -51,13 +51,13 @@ akerr_ErrorContext *test_spritesheet_initialize(void)
FAIL_ZERO_BREAK(
errctx,
SDL_GetPointerProperty(REGISTRY_SPRITESHEET, "assets/spritesheet.png", NULL),
SDL_GetPointerProperty(AKGL_AKGL_REGISTRY_SPRITESHEET, "assets/spritesheet.png", NULL),
AKERR_KEY,
"Spritesheet was not placed in the registry");
} CLEANUP {
IGNORE(heap_release_string(tmpstr));
IGNORE(heap_release_spritesheet(sheet));
IGNORE(akgl_heap_release_string(tmpstr));
IGNORE(akgl_heap_release_spritesheet(sheet));
if ( image != NULL )
SDL_DestroyTexture(image);
} PROCESS(errctx) {
@@ -65,48 +65,48 @@ akerr_ErrorContext *test_spritesheet_initialize(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_sprite_initialize(void)
akerr_ErrorContext *test_akgl_sprite_initialize(void)
{
PREPARE_ERROR(errctx);
spritesheet *testsheet = NULL;
sprite *testsprite = NULL;
string *tmpstr = NULL;
akgl_SpriteSheet *testsheet = NULL;
akgl_Sprite *testsprite = NULL;
akgl_String *tmpstr = NULL;
// Does the sprite get loaded?
// Do all frames of the sprite get loaded?
// Are all the frames of the sprite what we expect? (Surface comparison)
// Is the sprite added to the registry?
ATTEMPT {
CATCH(errctx, heap_next_spritesheet(&testsheet));
CATCH(errctx, heap_next_sprite(&testsprite));
CATCH(errctx, heap_next_string(&tmpstr));
CATCH(errctx, akgl_heap_next_spritesheet(&testsheet));
CATCH(errctx, akgl_heap_next_sprite(&testsprite));
CATCH(errctx, akgl_heap_next_string(&tmpstr));
snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
CATCH(errctx, spritesheet_initialize(testsheet, 48, 48, "assets/spritesheet.png"));
FAIL_ZERO_BREAK(errctx, testsheet, AKERR_VALUE, "spritesheet_initialize failed");
snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
CATCH(errctx, akgl_spritesheet_initialize(testsheet, 48, 48, "assets/spritesheet.png"));
FAIL_ZERO_BREAK(errctx, testsheet, AKERR_VALUE, "akgl_spritesheet_initialize failed");
CATCH(errctx, sprite_initialize(testsprite, "test", testsheet));
CATCH(errctx, akgl_sprite_initialize(testsprite, "test", testsheet));
FAIL_NONZERO_BREAK(errctx, (testsprite->sheet != testsheet), AKERR_VALUE, "Initialized sprite uses wrong sheet");
FAIL_ZERO_BREAK(
errctx,
SDL_GetPointerProperty(REGISTRY_SPRITE, "test", NULL),
SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "test", NULL),
AKERR_KEY,
"Sprite was not placed in the registry");
} CLEANUP {
IGNORE(heap_release_sprite(testsprite));
IGNORE(heap_release_string(tmpstr));
IGNORE(akgl_heap_release_sprite(testsprite));
IGNORE(akgl_heap_release_string(tmpstr));
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_sprite_load_json(void)
akerr_ErrorContext *test_akgl_sprite_load_json(void)
{
PREPARE_ERROR(errctx);
sprite *testsprite = NULL;
sprite *testsprite2 = NULL;
string *tmpstr = NULL;
akgl_Sprite *testsprite = NULL;
akgl_Sprite *testsprite2 = NULL;
akgl_String *tmpstr = NULL;
SDL_Texture *image = NULL;
// Does the sprite get loaded?
@@ -114,15 +114,15 @@ akerr_ErrorContext *test_sprite_load_json(void)
// Are all the frames of the sprite what we expect? (Surface comparison)
// Is the sprite added to the registry?
ATTEMPT {
CATCH(errctx, heap_next_string(&tmpstr));
CATCH(errctx, akgl_heap_next_string(&tmpstr));
CATCH(errctx, sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL);
CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json"));
testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite,
AKERR_KEY,
"sprite_load_json succeeds but sprite is not placed in the registry");
"akgl_sprite_load_json succeeds but sprite is not placed in the registry");
FAIL_ZERO_BREAK(errctx, (testsprite->width == 48), AKERR_VALUE, "width incorrect (48 : %d)", testsprite->width);
FAIL_ZERO_BREAK(errctx, (testsprite->height == 48), AKERR_VALUE, "height incorrect (48 : %d)", testsprite->height);
@@ -137,13 +137,13 @@ akerr_ErrorContext *test_sprite_load_json(void)
// Is it using the right spritesheet?
snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png");
image = IMG_LoadTexture(renderer, (char *)&tmpstr->data);
FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image");
FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image");
CATCH(
errctx,
render_and_compare(
akgl_render_and_compare(
testsprite->sheet->texture,
image,
0, 0, 576, 384,
@@ -152,14 +152,14 @@ akerr_ErrorContext *test_sprite_load_json(void)
);
// If we load a second sprite using the same sheet name, do they use the same sheet in memory?
snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testsprite2.json");
CATCH(errctx, sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL);
snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testsprite2.json");
CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json"));
testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL);
FAIL_ZERO_BREAK(
errctx,
testsprite,
AKERR_KEY,
"sprite_load_json succeeds but second sprite is not placed in the registry");
"akgl_sprite_load_json succeeds but second sprite is not placed in the registry");
FAIL_ZERO_BREAK(
errctx,
@@ -169,12 +169,12 @@ akerr_ErrorContext *test_sprite_load_json(void)
} CLEANUP {
if ( testsprite != NULL ) {
IGNORE(heap_release_sprite(testsprite));
IGNORE(akgl_heap_release_sprite(testsprite));
}
if ( testsprite2 != NULL ) {
IGNORE(heap_release_sprite(testsprite2));
IGNORE(akgl_heap_release_sprite(testsprite2));
}
IGNORE(heap_release_string(tmpstr));
IGNORE(akgl_heap_release_string(tmpstr));
if ( image != NULL )
SDL_DestroyTexture(image);
} PROCESS(errctx) {
@@ -191,20 +191,20 @@ int main(void)
SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest");
if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
}
if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 640, 480, 0, &window, &renderer)) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
}
CATCH(errctx, heap_init());
CATCH(errctx, registry_init_sprite());
CATCH(errctx, registry_init_spritesheet());
CATCH(errctx, akgl_heap_init());
CATCH(errctx, akgl_registry_init_sprite());
CATCH(errctx, akgl_registry_init_spritesheet());
CATCH(errctx, test_spritesheet_initialize());
CATCH(errctx, test_sprite_initialize());
CATCH(errctx, test_sprite_load_json());
CATCH(errctx, test_akgl_spritesheet_initialize());
CATCH(errctx, test_akgl_sprite_initialize());
CATCH(errctx, test_akgl_sprite_load_json());
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);

62
tests/staticstring.c
View File

@@ -7,12 +7,12 @@ void reset_string_heap(void);
akerr_ErrorContext *test_fresh_heap_gives_strings(void)
{
string *ptr = NULL;
akgl_String *ptr = NULL;
PREPARE_ERROR(errctx);
for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) {
for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) {
ATTEMPT {
CATCH(errctx, heap_next_string(&ptr));
CATCH(errctx, akgl_heap_next_string(&ptr));
} CLEANUP {
reset_string_heap();
} PROCESS(errctx) {
@@ -24,14 +24,14 @@ akerr_ErrorContext *test_fresh_heap_gives_strings(void)
akerr_ErrorContext *test_string_heap_error_when_no_strings_left(void)
{
string *ptr;
akgl_String *ptr;
PREPARE_ERROR(errctx);
for ( int i = 0; i < MAX_HEAP_STRING; i++ ) {
for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) {
HEAP_STRING[i].refcount = 1;
}
for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) {
for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) {
ATTEMPT {
CATCH(errctx, heap_next_string(&ptr));
CATCH(errctx, akgl_heap_next_string(&ptr));
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -44,12 +44,12 @@ akerr_ErrorContext *test_string_heap_error_when_no_strings_left(void)
akerr_ErrorContext *test_string_heap_honors_refcount(void)
{
string *firstptr = &HEAP_STRING[0];
string *secondptr = &HEAP_STRING[1];
string *testptr = NULL;
akgl_String *firstptr = &HEAP_STRING[0];
akgl_String *secondptr = &HEAP_STRING[1];
akgl_String *testptr = NULL;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_next_string(&testptr));
CATCH(errctx, akgl_heap_next_string(&testptr));
if ( testptr != firstptr ) {
FAIL_RETURN(
errctx,
@@ -59,7 +59,7 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void)
testptr
);
}
CATCH(errctx, string_initialize(testptr, NULL));
CATCH(errctx, akgl_string_initialize(testptr, NULL));
if ( testptr->refcount == 0 ) {
FAIL_RETURN(errctx, AKERR_VALUE, "Expected string reference count to be nonzero but got 0");
}
@@ -72,7 +72,7 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void)
testptr
);
}
CATCH(errctx, heap_next_string(&testptr));
CATCH(errctx, akgl_heap_next_string(&testptr));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -81,14 +81,14 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void)
akerr_ErrorContext *test_strcpy_to_all_strings_no_segfault(void)
{
char copybuf[MAX_STRING_LENGTH];
string *ptr;
memset((void *)&copybuf, 'a', MAX_STRING_LENGTH);
char copybuf[AKGL_MAX_STRING_LENGTH];
akgl_String *ptr;
memset((void *)&copybuf, 'a', AKGL_MAX_STRING_LENGTH);
PREPARE_ERROR(errctx);
ATTEMPT {
for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) {
CATCH(errctx, heap_next_string(&ptr));
strncpy(ptr->data, (char *)&copybuf, MAX_STRING_LENGTH);
for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) {
CATCH(errctx, akgl_heap_next_string(&ptr));
strncpy(ptr->data, (char *)&copybuf, AKGL_MAX_STRING_LENGTH);
}
} CLEANUP {
} PROCESS(errctx) {
@@ -96,21 +96,21 @@ akerr_ErrorContext *test_strcpy_to_all_strings_no_segfault(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_string_initialize(void)
akerr_ErrorContext *test_akgl_string_initialize(void)
{
string *ptr;
akgl_String *ptr;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, heap_next_string(&ptr));
CATCH(errctx, string_initialize(ptr, NULL));
CATCH(errctx, akgl_heap_next_string(&ptr));
CATCH(errctx, akgl_string_initialize(ptr, NULL));
FAIL_NONZERO_BREAK(errctx, ptr->data[0], AKERR_VALUE, "Expected empty zero length string data");
CATCH(errctx, heap_release_string(ptr));
CATCH(errctx, heap_next_string(&ptr));
CATCH(errctx, string_initialize(ptr, "Test value"));
CATCH(errctx, akgl_heap_release_string(ptr));
CATCH(errctx, akgl_heap_next_string(&ptr));
CATCH(errctx, akgl_string_initialize(ptr, "Test value"));
FAIL_NONZERO_BREAK(errctx, strcmp((char *)&ptr->data, "Test value"), AKERR_VALUE, "Expected 'Test value', got %s", (char *)&ptr->data);
CATCH(errctx, heap_release_string(NULL));
CATCH(errctx, akgl_heap_release_string(NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Failure to properly handle NULL pointer");
} CLEANUP {
} PROCESS(errctx) {
@@ -122,8 +122,8 @@ akerr_ErrorContext *test_string_initialize(void)
void reset_string_heap(void)
{
for ( int i = 0; i < MAX_HEAP_STRING; i++ ) {
memset(&HEAP_STRING[i], 0x00, sizeof(string));
for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) {
memset(&HEAP_STRING[i], 0x00, sizeof(akgl_String));
}
}
@@ -144,8 +144,8 @@ int main(void)
printf("test_strcpy_to_all_strings_no_segfault ...\n");
test_strcpy_to_all_strings_no_segfault();
reset_string_heap();
printf("test_string_initialize....\n");
test_string_initialize();
printf("test_akgl_string_initialize....\n");
test_akgl_string_initialize();
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);

158
tests/tilemap.c
View File

@@ -11,28 +11,28 @@
#include <sdl3game/game.h>
#include <sdl3game/json_helpers.h>
akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void)
akerr_ErrorContext *test_tilemap_akgl_get_json_tilemap_property(void)
{
PREPARE_ERROR(errctx);
json_t *jsondoc = NULL;
json_error_t jsonerr;
string *tmpstr = NULL;
akgl_String *tmpstr = NULL;
int propnum;
ATTEMPT {
CATCH(errctx, heap_next_string(&tmpstr));
CATCH(errctx, akgl_heap_next_string(&tmpstr));
snprintf(
(char *)&tmpstr->data,
MAX_STRING_LENGTH,
AKGL_MAX_STRING_LENGTH,
"%s%s",
SDL_GetBasePath(),
"assets/snippets/test_tilemap_get_json_tilemap_property.json"
"assets/snippets/test_tilemap_akgl_get_json_tilemap_property.json"
);
jsondoc = json_load_file((char *)&tmpstr->data, 0, (json_error_t *)&jsonerr);
FAIL_ZERO_BREAK(errctx, jsondoc, AKERR_NULLPOINTER, "Failure loading json fixture: %s", (char *)jsonerr.text);
CATCH(
errctx,
get_json_properties_string(
akgl_get_json_properties_string(
jsondoc,
"character",
&tmpstr
@@ -47,7 +47,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void)
);
CATCH(
errctx,
get_json_properties_integer(
akgl_get_json_properties_integer(
jsondoc,
"state",
&propnum
@@ -62,7 +62,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void)
);
} CLEANUP {
if ( tmpstr != NULL ) {
IGNORE(heap_release_string(tmpstr));
IGNORE(akgl_heap_release_string(tmpstr));
}
if ( jsondoc != NULL ) {
json_decref(jsondoc);
@@ -72,7 +72,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void)
akerr_ErrorContext *test_akgl_tilemap_compute_tileset_offsets(void)
{
int comparison_values[8] = {
0, // Tile 0 X
@@ -96,7 +96,7 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void)
};
int i = 0;
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
gamemap.tilesets[0].tilecount = 4;
gamemap.tilesets[0].columns = 2;
gamemap.tilesets[0].firstgid = 1;
@@ -110,7 +110,7 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void)
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, tilemap_compute_tileset_offsets(&gamemap, 0));
CATCH(errctx, akgl_tilemap_compute_tileset_offsets(&gamemap, 0));
// Tile 0 X offset
for ( i = 0; i < 8; i++ ) {
FAIL_NONZERO_BREAK(
@@ -129,34 +129,34 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_load_layer_objects(void)
akerr_ErrorContext *test_akgl_tilemap_load_layer_objects(void)
{
string *pathstr;
akgl_String *pathstr;
PREPARE_ERROR(errctx);
json_t *doc = NULL;
json_t *layers = NULL;
json_t *objectlayer = NULL;
json_error_t errdata;
actor *testactor;
akgl_Actor *testactor;
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
CATCH(errctx, heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
CATCH(errctx, akgl_heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
doc = json_load_file((char *)&pathstr->data, 0, &errdata);
FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text);
CATCH(errctx, get_json_array_value(doc, "layers", &layers));
CATCH(errctx, get_json_array_index_object(layers, 1, &objectlayer));
CATCH(errctx, tilemap_load_layer_objects(&gamemap, objectlayer, 1));
CATCH(errctx, akgl_get_json_array_value(doc, "layers", &layers));
CATCH(errctx, akgl_get_json_array_index_object(layers, 1, &objectlayer));
CATCH(errctx, akgl_tilemap_load_layer_objects(&gamemap, objectlayer, 1));
testactor = SDL_GetPointerProperty(REGISTRY_ACTOR, "testactor", NULL);
testactor = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "testactor", NULL);
FAIL_ZERO_BREAK(
errctx,
testactor,
AKERR_NULLPOINTER,
"Test Actor was not loaded from the test map"
);
if ( (testactor->basechar != SDL_GetPointerProperty(REGISTRY_CHARACTER, "testcharacter", NULL)) ||
if ( (testactor->basechar != SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testcharacter", NULL)) ||
(testactor->layer != 1) ||
(testactor->state != 6) ||
(testactor->visible != true) ||
@@ -166,7 +166,7 @@ akerr_ErrorContext *test_tilemap_load_layer_objects(void)
}
} CLEANUP {
if ( pathstr != NULL ) {
IGNORE(heap_release_string(pathstr));
IGNORE(akgl_heap_release_string(pathstr));
}
if ( doc != NULL ) {
json_decref(doc);
@@ -176,9 +176,9 @@ akerr_ErrorContext *test_tilemap_load_layer_objects(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_load_layer_tile(void)
akerr_ErrorContext *test_akgl_tilemap_load_layer_tile(void)
{
string *pathstr;
akgl_String *pathstr;
PREPARE_ERROR(errctx);
json_t *doc = NULL;
json_t *layers = NULL;
@@ -186,17 +186,17 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void)
json_t *tiledata = NULL;
json_error_t errdata;
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
CATCH(errctx, heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
CATCH(errctx, akgl_heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
doc = json_load_file((char *)&pathstr->data, 0, &errdata);
FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text);
CATCH(errctx, get_json_array_value(doc, "layers", &layers));
CATCH(errctx, get_json_array_index_object(layers, 0, &tilelayer));
CATCH(errctx, get_json_array_value(tilelayer, "data", &tiledata));
CATCH(errctx, tilemap_load_layer_tile(&gamemap, tilelayer, 0));
CATCH(errctx, akgl_get_json_array_value(doc, "layers", &layers));
CATCH(errctx, akgl_get_json_array_index_object(layers, 0, &tilelayer));
CATCH(errctx, akgl_get_json_array_value(tilelayer, "data", &tiledata));
CATCH(errctx, akgl_tilemap_load_layer_tile(&gamemap, tilelayer, 0));
if ( (gamemap.layers[0].data[0] != 1) ||
(gamemap.layers[0].data[1] != 2) ||
(gamemap.layers[0].data[2] != 3) ||
@@ -205,7 +205,7 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void)
}
} CLEANUP {
if ( pathstr != NULL ) {
IGNORE(heap_release_string(pathstr));
IGNORE(akgl_heap_release_string(pathstr));
}
if ( doc != NULL ) {
json_decref(doc);
@@ -215,22 +215,22 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_load_layers(void)
akerr_ErrorContext *test_akgl_tilemap_load_layers(void)
{
string *pathstr;
akgl_String *pathstr;
PREPARE_ERROR(errctx);
json_t *doc = NULL;
json_error_t errdata;
int i = 0;
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
CATCH(errctx, heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
CATCH(errctx, akgl_heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
doc = json_load_file((char *)&pathstr->data, 0, &errdata);
FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text);
CATCH(errctx, tilemap_load_layers(&gamemap, doc));
CATCH(errctx, akgl_tilemap_load_layers(&gamemap, doc));
FAIL_NONZERO_BREAK(
errctx,
(gamemap.numlayers != 3),
@@ -244,26 +244,26 @@ akerr_ErrorContext *test_tilemap_load_layers(void)
(gamemap.layers[i].x != 0) ||
(gamemap.layers[i].y != 0) ) {
FAIL(errctx, AKERR_VALUE, "Map layer data loaded incorrectly (see gdb)");
goto _test_tilemap_load_layers_cleanup;
goto _test_akgl_tilemap_load_layers_cleanup;
}
}
// Layer 2 should have 1 object loaded
if ( (gamemap.layers[1].objects[0].actorptr != SDL_GetPointerProperty(REGISTRY_ACTOR, "testactor", NULL)) ||
if ( (gamemap.layers[1].objects[0].actorptr != SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "testactor", NULL)) ||
(gamemap.layers[1].objects[1].name[0] != '\0' ) ||
(gamemap.layers[1].objects[1].id != 0) ) {
FAIL_BREAK(errctx, AKERR_VALUE, "Map layer 2 should have 1 loaded object (testactor) and nothing else (see gdb)");
}
// Layer 1 and 3 should have no objects
for ( i = 0; i < TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) {
for ( i = 0; i < AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) {
if ( gamemap.layers[0].objects[i].id != 0 ) {
FAIL(errctx, AKERR_VALUE, "Map layers 1 and 3 should have no objects loaded but found objects");
goto _test_tilemap_load_layers_cleanup;
goto _test_akgl_tilemap_load_layers_cleanup;
}
}
for ( i = 0; i < TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) {
for ( i = 0; i < AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) {
if ( gamemap.layers[2].objects[i].id != 0 ) {
FAIL(errctx, AKERR_VALUE, "Map layers 1 and 3 should have no objects loaded but found objects");
goto _test_tilemap_load_layers_cleanup;
goto _test_akgl_tilemap_load_layers_cleanup;
}
}
// Layers 1 and 3 should have tile data
@@ -278,10 +278,10 @@ akerr_ErrorContext *test_tilemap_load_layers(void)
) {
FAIL_BREAK(errctx, AKERR_VALUE, "Map layers 1 and 3 should have tile data but it is incorrect");
}
_test_tilemap_load_layers_cleanup:
_test_akgl_tilemap_load_layers_cleanup:
} CLEANUP {
if ( pathstr != NULL ) {
IGNORE(heap_release_string(pathstr));
IGNORE(akgl_heap_release_string(pathstr));
}
if ( doc != NULL ) {
json_decref(doc);
@@ -291,22 +291,22 @@ _test_tilemap_load_layers_cleanup:
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_load_tilesets(void)
akerr_ErrorContext *test_akgl_tilemap_load_tilesets(void)
{
string *pathstr = NULL;
akgl_String *pathstr = NULL;
PREPARE_ERROR(errctx);
json_t *doc = NULL;
json_error_t errdata;
SDL_Texture *image = NULL;
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
CATCH(errctx, heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
CATCH(errctx, akgl_heap_next_string(&pathstr));
snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj");
doc = json_load_file((char *)&pathstr->data, 0, &errdata);
FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text);
CATCH(errctx, tilemap_load_tilesets(&gamemap, doc));
CATCH(errctx, akgl_tilemap_load_tilesets(&gamemap, doc));
FAIL_NONZERO_BREAK(errctx, (gamemap.numtilesets != 1), AKERR_VALUE, "Incorrect number of tilesets loaded for map");
if ( (gamemap.tilesets[0].columns != 48 ) ||
(gamemap.tilesets[0].firstgid != 1) ||
@@ -325,22 +325,22 @@ akerr_ErrorContext *test_tilemap_load_tilesets(void)
AKERR_VALUE,
"Tileset loaded with incorrect name");
snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/World_A1.png");
snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/World_A1.png");
image = IMG_LoadTexture(renderer, (char *)&pathstr->data);
FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image");
FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image");
CATCH(
errctx,
render_and_compare(
akgl_render_and_compare(
gamemap.tilesets[0].texture,
image,
0, 0, 768, 576,
"test_tilemap_loaded_tileset.png")
"test_akgl_tilemap_loaded_tileset.png")
);
} CLEANUP {
if ( pathstr != NULL ) {
IGNORE(heap_release_string(pathstr));
IGNORE(akgl_heap_release_string(pathstr));
}
if ( doc != NULL ) {
json_decref(doc);
@@ -350,21 +350,21 @@ akerr_ErrorContext *test_tilemap_load_tilesets(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_load(void)
akerr_ErrorContext *test_akgl_tilemap_load(void)
{
PREPARE_ERROR(errctx);
memset((void *)&gamemap, 0x00, sizeof(tilemap));
memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
CATCH(errctx, tilemap_load("assets/testmap.tmj", &gamemap));
CATCH(errctx, akgl_tilemap_load("assets/testmap.tmj", &gamemap));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_tilemap_draw(void)
akerr_ErrorContext *test_akgl_tilemap_draw(void)
{
PREPARE_ERROR(errctx);
@@ -376,7 +376,7 @@ akerr_ErrorContext *test_tilemap_draw(void)
}
akerr_ErrorContext *test_tilemap_draw_tileset(void)
akerr_ErrorContext *test_akgl_tilemap_draw_tileset(void)
{
PREPARE_ERROR(errctx);
@@ -395,28 +395,28 @@ int main(void)
SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest");
if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError());
}
if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 768, 576, 0, &window, &renderer)) {
FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError());
}
CATCH(errctx, registry_init());
CATCH(errctx, heap_init());
CATCH(errctx, sprite_load_json("assets/testsprite.json"));
CATCH(errctx, sprite_load_json("assets/testsprite2.json"));
CATCH(errctx, character_load_json("assets/testcharacter.json"));
CATCH(errctx, akgl_registry_init());
CATCH(errctx, akgl_heap_init());
CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json"));
CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json"));
CATCH(errctx, akgl_character_load_json("assets/testcharacter.json"));
CATCH(errctx, test_tilemap_get_json_tilemap_property());
CATCH(errctx, test_tilemap_compute_tileset_offsets());
CATCH(errctx, test_tilemap_load_layer_objects());
CATCH(errctx, test_tilemap_load_layer_tile());
CATCH(errctx, test_tilemap_load_layers());
CATCH(errctx, test_tilemap_load_tilesets());
//CATCH(errctx, test_tilemap_load());
//CATCH(errctx, test_tilemap_draw_tileset());
//CATCH(errctx, test_tilemap_draw());
CATCH(errctx, test_tilemap_akgl_get_json_tilemap_property());
CATCH(errctx, test_akgl_tilemap_compute_tileset_offsets());
CATCH(errctx, test_akgl_tilemap_load_layer_objects());
CATCH(errctx, test_akgl_tilemap_load_layer_tile());
CATCH(errctx, test_akgl_tilemap_load_layers());
CATCH(errctx, test_akgl_tilemap_load_tilesets());
//CATCH(errctx, test_akgl_tilemap_load());
//CATCH(errctx, test_akgl_tilemap_draw_tileset());
//CATCH(errctx, test_akgl_tilemap_draw());
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);

100
tests/util.c
View File

@@ -2,15 +2,15 @@
#include <akerror.h>
#include <sdl3game/util.h>
akerr_ErrorContext *test_rectangle_points_nullpointers(void)
akerr_ErrorContext *test_akgl_rectangle_points_nullpointers(void)
{
RectanglePoints points;
SDL_FRect testrect;
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, rectangle_points(NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with all NULL pointers");
CATCH(errctx, akgl_rectangle_points(NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with all NULL pointers");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -18,8 +18,8 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, rectangle_points(NULL, &testrect));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with NULL SDL_FRect pointer");
CATCH(errctx, akgl_rectangle_points(NULL, &testrect));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL SDL_FRect pointer");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -27,8 +27,8 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, rectangle_points(&points, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with NULL RectanglePoints pointer");
CATCH(errctx, akgl_rectangle_points(&points, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL RectanglePoints pointer");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -36,7 +36,7 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, rectangle_points(&points, &testrect));
CATCH(errctx, akgl_rectangle_points(&points, &testrect));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -44,7 +44,7 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_rectangle_points_math(void)
akerr_ErrorContext *test_akgl_rectangle_points_math(void)
{
RectanglePoints points;
SDL_FRect testrect = {.x = 0, .y = 0, .w = 32, .h = 32};
@@ -52,7 +52,7 @@ akerr_ErrorContext *test_rectangle_points_math(void)
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, rectangle_points(&points, &testrect));
CATCH(errctx, akgl_rectangle_points(&points, &testrect));
if ( points.topleft.x != 0 ||
points.topleft.y != 0 ||
points.topright.x != 32 ||
@@ -64,7 +64,7 @@ akerr_ErrorContext *test_rectangle_points_math(void)
FAIL_BREAK(
errctx,
AKERR_BEHAVIOR,
"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}}",
"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,
@@ -77,7 +77,7 @@ akerr_ErrorContext *test_rectangle_points_math(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
akerr_ErrorContext *test_akgl_collide_point_rectangle_nullpointers(void)
{
point testpoint;
RectanglePoints testrectpoints;
@@ -86,8 +86,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(*, *, NULL) failed");
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(*, *, NULL) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -95,8 +95,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_point_rectangle(&testpoint, NULL, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(*, NULL, *) failed");
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, NULL, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(*, NULL, *) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -104,8 +104,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_point_rectangle(NULL, &testrectpoints, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(NULL, *, *) failed");
CATCH(errctx, akgl_collide_point_rectangle(NULL, &testrectpoints, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, *, *) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -113,8 +113,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_point_rectangle(NULL, NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(NULL, NULL, NULL) failed");
CATCH(errctx, akgl_collide_point_rectangle(NULL, NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, NULL, NULL) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -122,7 +122,7 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -130,7 +130,7 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_collide_point_rectangle_logic(void)
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};
@@ -139,15 +139,15 @@ akerr_ErrorContext *test_collide_point_rectangle_logic(void)
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, rectangle_points(&testrectpoints, &testrect));
CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
CATCH(errctx, akgl_rectangle_points(&testrectpoints, &testrect));
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
testpoint.x = 48;
testpoint.y = 48;
CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide));
if ( testcollide == true ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Invalid collision reported");
}
@@ -157,7 +157,7 @@ akerr_ErrorContext *test_collide_point_rectangle_logic(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
akerr_ErrorContext *test_akgl_collide_rectangles_nullpointers(void)
{
SDL_FRect testrect1;
SDL_FRect testrect2;
@@ -166,8 +166,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(*, *, NULL) failed");
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(*, *, NULL) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -175,8 +175,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_rectangles(&testrect1, NULL, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(*, NULL, *) failed");
CATCH(errctx, akgl_collide_rectangles(&testrect1, NULL, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(*, NULL, *) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -184,8 +184,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_rectangles(NULL, &testrect2, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(NULL, *, *) failed");
CATCH(errctx, akgl_collide_rectangles(NULL, &testrect2, &testcollide));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(NULL, *, *) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -193,8 +193,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_rectangles(NULL, NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(NULL, NULL, NULL) failed");
CATCH(errctx, akgl_collide_rectangles(NULL, NULL, NULL));
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(NULL, NULL, NULL) failed");
} CLEANUP {
} PROCESS(errctx) {
} HANDLE(errctx, AKERR_NULLPOINTER) {
@@ -202,7 +202,7 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
} FINISH(errctx, true);
ATTEMPT {
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -210,7 +210,7 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *test_collide_rectangles_logic(void)
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};
@@ -220,14 +220,14 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
ATTEMPT {
// Collision overlapping on the top left
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
// Collision overlapping on the top right
testrect1.x = 64;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -235,7 +235,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
// Collision overlapping on the bottom left
testrect1.x = 0;
testrect1.y = 32;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -243,7 +243,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
// Collision overlapping on the bottom right
testrect1.x = 32;
testrect1.y = 32;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -253,7 +253,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
testrect1.y = 0;
testrect1.w = 60;
testrect1.h = 32;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -263,7 +263,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
testrect1.y = 0;
testrect1.w = 35;
testrect1.h = 80;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -273,7 +273,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
testrect1.y = 0;
testrect1.w = 60;
testrect1.h = 80;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -283,7 +283,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
testrect1.y = 65;
testrect1.w = 80;
testrect1.h = 32;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == false ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed");
}
@@ -293,7 +293,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void)
testrect1.y = 0;
testrect1.w = 16;
testrect1.h = 16;
CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide));
CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide));
if ( testcollide == true ) {
FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Invalid collision reported");
}
@@ -309,11 +309,11 @@ int main(void)
{
PREPARE_ERROR(errctx);
ATTEMPT {
CATCH(errctx, test_rectangle_points_nullpointers());
CATCH(errctx, test_rectangle_points_math());
CATCH(errctx, test_collide_point_rectangle_nullpointers());
CATCH(errctx, test_collide_rectangles_nullpointers());
CATCH(errctx, test_collide_rectangles_logic());
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());
} CLEANUP {
} PROCESS(errctx) {
} FINISH_NORETURN(errctx);