libakgl/tests/staticstring.c

#include <string.h>
#include <akerror.h>
#include <akgl/error.h>
#include <akgl/heap.h>
#include <akgl/staticstring.h>

void reset_string_heap(void);

akerr_ErrorContext *test_fresh_heap_gives_strings(void)
{
    akgl_String *ptr = NULL;

    PREPARE_ERROR(errctx);
    for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) {
	ATTEMPT {
	    CATCH(errctx, akgl_heap_next_string(&ptr));
	} CLEANUP {
	    reset_string_heap();
	} PROCESS(errctx) {
	} FINISH(errctx, true);
    }

    return 0;
}

akerr_ErrorContext *test_string_heap_error_when_no_strings_left(void)
{
    akgl_String *ptr;
    PREPARE_ERROR(errctx);
    for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) {
	HEAP_STRING[i].refcount = 1;
    }
    for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) {
	ATTEMPT {
	    CATCH(errctx, akgl_heap_next_string(&ptr));
	} CLEANUP {
	} PROCESS(errctx) {
	} HANDLE(errctx, AKERR_NULLPOINTER) {
	    return 0;
	} FINISH(errctx, true);
    }
    FAIL_RETURN(errctx, AKERR_OUTOFBOUNDS, "Expected AKERR_NULLPOINTER when accessing beyond string heap bounds");
    SUCCEED_RETURN(errctx);
}

akerr_ErrorContext *test_string_heap_honors_refcount(void)
{
    akgl_String *firstptr = &HEAP_STRING[0];
    akgl_String *secondptr = &HEAP_STRING[1];
    akgl_String *testptr = NULL;
    PREPARE_ERROR(errctx);
    ATTEMPT {
	CATCH(errctx, akgl_heap_next_string(&testptr));
	if ( testptr != firstptr ) {
	    FAIL_RETURN(
		errctx,
		AKERR_VALUE,
		"Expected testptr to equal (HEAP_STRING[0] = %p) but got %p",
		firstptr,
		testptr
		);
	}
	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");
	}
	if ( testptr != firstptr ) {
	    FAIL_RETURN(
		errctx,
		AKERR_VALUE,
		"Expected testptr to equal (HEAP_STRING[1] = %p) but got %p",
		secondptr,
		testptr
		);
	}
	CATCH(errctx, akgl_heap_next_string(&testptr));
    } CLEANUP {
    } PROCESS(errctx) {
    } FINISH(errctx, true);
    SUCCEED_RETURN(errctx);
}

akerr_ErrorContext *test_strcpy_to_all_strings_no_segfault(void)
{
    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 < 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) {
    } FINISH(errctx, true);
    SUCCEED_RETURN(errctx);
}

akerr_ErrorContext *test_akgl_string_initialize(void)
{
    akgl_String *ptr;
    PREPARE_ERROR(errctx);
    ATTEMPT {
	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, 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, akgl_heap_release_string(NULL));
	FAIL_BREAK(errctx, AKGL_ERR_BEHAVIOR, "Failure to properly handle NULL pointer");
    } CLEANUP {
    } PROCESS(errctx) {
    } FINISH(errctx, true);

    SUCCEED_RETURN(errctx);
}


void reset_string_heap(void)
{
    for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) {
	memset(&HEAP_STRING[i], 0x00, sizeof(akgl_String));
    }
}

int main(void)
{

    PREPARE_ERROR(errctx);
    ATTEMPT {
	printf("test_fresh_heap_gives_string ....\n");
	test_fresh_heap_gives_strings();
	reset_string_heap();
	printf("test_string_heap_error_when_no_strings_left ...\n");
	test_string_heap_error_when_no_strings_left();
	reset_string_heap();
	printf("test_string_heap_honors_refcount ...\n");
	test_string_heap_honors_refcount();
	reset_string_heap();
	printf("test_strcpy_to_all_strings_no_segfault ...\n");
	test_strcpy_to_all_strings_no_segfault();
	reset_string_heap();
	printf("test_akgl_string_initialize....\n");
	test_akgl_string_initialize();
    } CLEANUP {
    } PROCESS(errctx) {
    } FINISH_NORETURN(errctx);

    return 0;
}