diff options
| -rw-r--r-- | CMakeLists.txt | 44 | ||||
| -rw-r--r-- | src/logging/.logging.h.swp | bin | 0 -> 12288 bytes | |||
| -rw-r--r-- | src/logging/logging.c | 13 | ||||
| -rw-r--r-- | src/logging/logging.h | 22 | ||||
| -rw-r--r-- | src/logging/logging.test.c | 110 | ||||
| -rw-r--r-- | src/main.c | 0 | ||||
| -rw-r--r-- | src/test/honey-test.c | 7 | ||||
| -rw-r--r-- | src/test/honey-test.h | 9 | ||||
| -rw-r--r-- | src/test/lily-test.c | 359 | ||||
| -rw-r--r-- | src/test/lily-test.h | 252 |
10 files changed, 790 insertions, 26 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index a29a6f1..6b37672 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,7 +16,7 @@ include_directories(${LUA_INCLUDE_DIR} ${CMAKE_SOURCE_DIR}/src) link_directories(${LIB_ROOT}/assimp/lib) link_directories(${LIB_ROOT}/honeysuckle) -add_library(glad ${SRC_ROOT}/gl/glad/glad.c) +# add_library(glad ${SRC_ROOT}/gl/glad/glad.c) # add_library(stb_image src/stb_image/stb_image.c) add_subdirectory(${LIB_ROOT}/assimp) add_subdirectory(${LIB_ROOT}/honeysuckle) @@ -24,47 +24,39 @@ add_subdirectory(${LIB_ROOT}/cglm) set(HONEY_LIB_FILES - ${SRC_ROOT}/logging/logging.c - - ${SRC_ROOT}/gl/honey_window.c - ${SRC_ROOT}/gl/honey_shader.c - ${SRC_ROOT}/gl/honey_gl_error.c - ${SRC_ROOT}/gl/honey_gl.c - - ${SRC_ROOT}/options/honey_options.c - ) + ${SRC_ROOT}/logging/logging.c +) set(SOURCE_FILES - ${SRC_ROOT}/main.c - ${HONEY_LIB_FILES} - ) - + ${SRC_ROOT}/main.c + ${HONEY_LIB_FILES} + ) + add_executable(honey ${SOURCE_FILES}) set(LIBRARIES ${LUA_LIBRARIES} honeysuckle assimp glad cairo m) if (WIN32) - set(LIBRARIES ${LIBRARIES} glfw3 opengl32) + set(LIBRARIES ${LIBRARIES} glfw3 opengl32) else() - set(LIBRARIES ${LIBRARIES} glfw GL dl) + set(LIBRARIES ${LIBRARIES} glfw GL dl) endif() target_link_libraries(honey ${LIBRARIES}) # build tests (optional) -set(TEST_SOURCES - ${SRC_ROOT}/test/test_main.c - ${HONEY_LIB_FILES} +string(LENGTH "${CMAKE_SOURCE_DIR}/" SOURCE_PATH_SIZE) +add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}") - ${SRC_ROOT}/test/mock_queue.c - ${SRC_ROOT}/test/mock_queue.test.c +set(TEST_SOURCES + ${SRC_ROOT}/test/lily-test.c + ${SRC_ROOT}/test/honey-test.c - ${SRC_ROOT}/logging/logging.test.c - ${SRC_ROOT}/gl/honey_gl.test.c - ) + ${SRC_ROOT}/logging/logging.test.c +) add_executable(test EXCLUDE_FROM_ALL ${TEST_SOURCES}) set_target_properties(test PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") + C_STANDARD 99 + CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") target_link_libraries(test ${LUA_LIBRARIES} honeysuckle) diff --git a/src/logging/.logging.h.swp b/src/logging/.logging.h.swp Binary files differnew file mode 100644 index 0000000..e2c510a --- /dev/null +++ b/src/logging/.logging.h.swp diff --git a/src/logging/logging.c b/src/logging/logging.c new file mode 100644 index 0000000..4f717cb --- /dev/null +++ b/src/logging/logging.c @@ -0,0 +1,13 @@ +#include <stdio.h> +#include "logging/logging.h" + +int _honey_log_level = HONEY_WARN; + +void honey_log(int level, const char *fmt, ...) { + //if (level > _honey_log_level) return; + + va_list args; + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); +} diff --git a/src/logging/logging.h b/src/logging/logging.h new file mode 100644 index 0000000..2618d2b --- /dev/null +++ b/src/logging/logging.h @@ -0,0 +1,22 @@ +#ifndef HONEY_LOGGING_H +#define HONEY_LOGGING_H + +#define HONEY_FATAL 0 +#define HONEY_ERROR 1 +#define HONEY_WARN 2 +#define HONEY_INFO 3 +#define HONEY_DEBUG 4 +#define HONEY_TRACE 5 + +extern int _honey_log_level; + +void honey_log(int level, const char *fmt, ...); + +#define honey_fatal(...) honey_log(HONEY_FATAL, "[FATAL] "__VA_ARGS__) +#define honey_error(...) honey_log(HONEY_ERROR, "[ERROR] "__VA_ARGS__) +#define honey_warn(...) honey_log(HONEY_WARN, "[WARN] " __VA_ARGS__) +#define honey_info(...) honey_log(HONEY_INFO, "[INFO] " __VA_ARGS__) +#define honey_debug(...) honey_log(HONEY_DEBUG, "[DEBUG] "__VA_ARGS__) +#define honey_trace(...) honey_log(HONEY_TRACE, "[TRACE] "__VA_ARGS__) + +#endif diff --git a/src/logging/logging.test.c b/src/logging/logging.test.c new file mode 100644 index 0000000..e227381 --- /dev/null +++ b/src/logging/logging.test.c @@ -0,0 +1,110 @@ +#include <string.h> +#include <stdarg.h> +#include <stdio.h> + +#include "test/lily-test.h" +#include "test/honey-test.h" + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * include C file and declare mocks + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ +#define vfprintf(file, fmt, vl) mock_vfprintf(file, fmt, vl) +void mock_vfprintf(FILE*, const char*, va_list vl); +#include "logging.c" +#undef vfprintf + + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * define mock functions + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +lily_mock_t *vfprintf_mock_data; +void mock_vfprintf(FILE *file, const char *fmt, va_list vl) +{ + /* to avoid basically just re-implementing printf parsing here, + i am limiting this function to be able to receive strings only */ + + /* count format specifiers */ + char *ptr = strchr(fmt, '%'); + int n_args = 0; + while (ptr != NULL) { + n_args += 1; + ptr = strchr(ptr+1, '%'); + } + + /* store arguments */ + struct lily_mock_arg_t args[] = { + { sizeof(FILE*), &file }, + { sizeof(const char*), &fmt }, + { sizeof(int), &n_args }, + }; + lily_mock_call(vfprintf_mock_data, args); + + /* store format arguments */ + lily_queue_t *queue = vfprintf_mock_data->values; + for (int i=0; i<n_args; i++) { + char *str = va_arg(vl, char*); + lily_enqueue(queue, char*, str); + } +} + + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * declare tests and define suite + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +void clean_mock(lily_mock_t **m) +{ + if (*m != NULL) { + lily_mock_destroy(*m); + *m = NULL; + } +} + +void test_log_fatal_succeeds(); + +void suite_logging() +{ + vfprintf_mock_data = NULL; + lily_run_test(test_log_fatal_succeeds); + if (vfprintf_mock_data != NULL) + lily_mock_destroy(vfprintf_mock_data); +} + + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * define tests + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +void test_log_fatal_succeeds() +{ + clean_mock(&vfprintf_mock_data); + vfprintf_mock_data = lily_mock_create(); + + honey_fatal("some message"); + lily_assert_int_equal(vfprintf_mock_data->n_calls, 1); + + FILE *file; const char *fmt; int n_strings; + struct lily_mock_arg_t args[] = { + { sizeof(FILE*), &file }, + { sizeof(const char*), &fmt }, + { sizeof(int), &n_strings }, + }; + lily_get_call(vfprintf_mock_data, args, 0); + + lily_assert_ptr_equal(file, stderr); + lily_assert_string_equal(fmt, "[FATAL] some message"); + lily_assert_int_equal(n_strings, 0); +} diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/main.c diff --git a/src/test/honey-test.c b/src/test/honey-test.c new file mode 100644 index 0000000..6980d36 --- /dev/null +++ b/src/test/honey-test.c @@ -0,0 +1,7 @@ +#include "test/honey-test.h" + +int main() +{ + RUN_TESTS(); + return 0; +} diff --git a/src/test/honey-test.h b/src/test/honey-test.h new file mode 100644 index 0000000..4aa1827 --- /dev/null +++ b/src/test/honey-test.h @@ -0,0 +1,9 @@ +#ifndef HONEY_TEST_H +#define HONEY_TEST_H + +void suite_logging(); + +#define RUN_TESTS() \ + suite_logging(); + +#endif diff --git a/src/test/lily-test.c b/src/test/lily-test.c new file mode 100644 index 0000000..20728fe --- /dev/null +++ b/src/test/lily-test.c @@ -0,0 +1,359 @@ +/**************************************************************** + * + * ======== lily-test ======== + * + * a midsize C unit testing library + * copyright (c) 2022 kate swanson (sanine) + * + * This is anti-capitalist software, released for free use by individuals and + * organizations that do not operate by capitalist principles. + * + * Permission is hereby granted, free of charge, to any person or + * organization (the "User") obtaining a copy of this software and associated + * documentation files (the "Software"), to use, copy, modify, merge, + * distribute, and/or sell copies of the Software, subject to the following + * conditions: + * + * 1. The above copyright notice and this permission notice shall be included + * in all copies or modified versions of the Software. + * + * 2. The User is one of the following: + * a. An individual person, laboring for themselves + * b. A non-profit organization + * c. An educational institution + * d. An organization that seeks shared profit for all of its members, and + * allows non-members to set the cost of their labor + * + * 3. If the User is an organization with owners, then all owners are workers + * and all workers are owners with equal equity and/or equal vote. + * + * 4. If the User is an organization, then the User is not law enforcement or + * military, or working for or under either. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT EXPRESS OR IMPLIED WARRANTY OF + * ANY KIND, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * https://anticapitalist.software/ + * https://sanine.net + * + ****************************************************************/ + + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "lily-test.h" + +struct lily_globals_t _lily_globals = { {0}, 0, NULL, "" }; + +/* run an individual test */ +void _lily_run_test(const char *name, lily_test_t test) +{ + printf(" %s: ", name); + + _lily_globals.error_msg = NULL; + _lily_globals.error_location = ""; + int val = setjmp(_lily_globals.env); + + if (val) { + /* test failed */ + printf("FAIL - %s (%s)\n", + _lily_globals.error_msg, + _lily_globals.error_location); + free(_lily_globals.error_msg); /* error message was allocated! */ + return; + } + + test(); + + /* test succeeded */ + printf("OK\n"); +} + +/* run a suite */ +void _lily_run_suite(const char *name, lily_test_t suite) +{ + printf("=== %s ===\n", name); + suite(); + printf("\n"); +} + + +/* ======== ASSERTIONS ======== */ + +static void _lily_assert_msg(bool statement, const char *location, + const char *format_string, va_list args) +{ + if (statement) { + va_end(args); + return; // no error, return + } + + _lily_globals.error_location = location; + + va_list args_len; + va_copy(args_len, args); + size_t length = vsnprintf(NULL, 0, format_string, args_len); + va_end(args_len); + + if (_lily_globals.error_msg_len < length+1 || + _lily_globals.error_msg == NULL) { + if (_lily_globals.error_msg != NULL) + free(_lily_globals.error_msg); + + char *msg = malloc((length+2) * sizeof(char)); + + if (msg == NULL) { + fprintf(stderr, "WARNING: failed to allocate memory for failed test message!\n"); + _lily_globals.error_msg = NULL; + va_end(args); + longjmp(_lily_globals.env, 1); + return; + } + else { + _lily_globals.error_msg = msg; + _lily_globals.error_msg_len = length+1; + } + } + + vsnprintf(_lily_globals.error_msg, length+1, format_string, args); + + va_end(args); + longjmp(_lily_globals.env, 1); +} + + +void lily_assert_msg(bool statement, const char *location, + const char *format_string, ...) +{ + va_list args; + va_start(args, format_string); + // _lily_assert_msg may long jump, so it takes calls va_end(args) for you + _lily_assert_msg(statement, location, format_string, args); +} + + +void _lily_assert_true(const char *statement, bool value, const char *location) +{ + lily_assert_msg(value, location, + "%s is not true", + statement); +} + + +void _lily_assert_false(const char *statement, bool value, const char *location) +{ + lily_assert_msg(!value, location, + "%s is not false", + statement); +} + + +void _lily_assert_not_null(const char *name, void *ptr, const char *location) +{ + lily_assert_msg(ptr != NULL, location, + "%s is NULL", + name); +} + + +void _lily_assert_null(const char *name, void *ptr, const char *location) +{ + lily_assert_msg(ptr == NULL, location, + "%s (%p) is not NULL", + name, ptr); +} + + +void _lily_assert_ptr_equal(const char *name_a, const char *name_b, + void *a, void *b, const char *location) +{ + lily_assert_msg(a == b, location, + "%s (%p) is not equal to %s (%p)", + name_a, a, name_b, b); +} + + +void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b, + void *a, void *b, const char *location) +{ + lily_assert_msg(a != b, location, + "%s (%p) is equal to %s", + name_a, a, name_b); +} + + +void _lily_assert_int_equal(const char *name_a, const char *name_b, + intmax_t a, intmax_t b, const char *location) +{ + lily_assert_msg(a == b, location, + "%s (%d) is not equal to %s (%d)", + name_a, a, name_b, b); +} + + +void _lily_assert_int_not_equal(const char *name_a, const char *name_b, + intmax_t a, intmax_t b, const char *location) +{ + lily_assert_msg(a != b, location, + "%s (%d) is equal to %s", + name_a, a, name_b); +} + + +void _lily_assert_float_equal(const char *name_a, const char *name_b, + double a, double b, double epsilon, const char *location) +{ + lily_assert_msg(abs(a - b) <= epsilon, + "%s (%f) is not equal to %s (%f) (epsilon: %f)", + name_a, a, name_b, b, epsilon); +} + + +void _lily_assert_float_not_equal(const char *name_a, const char *name_b, + double a, double b, double epsilon, const char *location) +{ + lily_assert_msg(abs(a - b) > epsilon, + "%s (%f) is equal to %s (%f) (epsilon: %f)", + name_a, a, name_b, b, epsilon); +} + + +void _lily_assert_string_equal(const char *name_a, const char *name_b, + char *a, char *b, const char *location) +{ + lily_assert_msg(strcmp(a, b) == 0, + "%s ('%s') is not equal to %s ('%s')", + name_a, a, name_b, b); +} + + +void _lily_assert_string_not_equal(const char *name_a, const char *name_b, + char *a, char *b, const char *location) +{ + lily_assert_msg(strcmp(a, b) != 0, + "%s ('%s') is equal to %s", + name_a, a, name_b); +} + + +void _lily_assert_memory_equal(const char *name_a, const char *name_b, + void *a, void *b, size_t size, const char *location) +{ + lily_assert_msg(memcmp(a, b, size) == 0, + "%s and %s contain different data", name_a, name_b); +} + + +void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, + void *a, void *b, size_t size, const char *location) +{ + lily_assert_msg(memcmp(a, b, size) == 0, + "%s contains the same data s %s", name_a, name_b); +} + + +/* ======== MOCKS ======== */ + +lily_queue_t* lily_queue_create() +{ + const size_t size = 256 * sizeof(uint8_t); + + lily_queue_t *q = malloc(sizeof(lily_queue_t)); + q->buf_size = size; + q->buf = malloc(size); + q->front = q->buf; + q->back = q->front; + + return q; +} + + +void lily_queue_destroy(lily_queue_t *q) +{ + free(q->buf); + free(q); +} + + +void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data) +{ + size_t used = q->back - q->buf; + size_t remaining = q->buf_size - used; + + if (remaining < size) { + /* re-allocate bigger buffer */ + size_t size_new = 2 * q->buf_size; + uint8_t *buf_new = realloc(q->buf, size_new); + if (buf_new == NULL) { + fprintf(stderr, "failed to allocated %lu bytes for queue %p!\n", + size_new, q); + return; + } + q->buf = buf_new; + } + + memcpy(q->back, data, size); + q->back += size; +} + + +void _lily_dequeue(lily_queue_t *q, size_t size, uint8_t *ptr) +{ + size_t dist = q->back - q->front; + if (dist < size) { + fprintf(stderr, "attempted to read %lu bytes out of queue %p, " + "which has %lu bytes presently queued\n", size, q, dist); + return; + } + + memcpy(ptr, q->front, size); + q->front += size; +} + + +lily_mock_t * lily_mock_create() +{ + lily_mock_t *m = malloc(sizeof(lily_mock_t)); + m->n_calls = 0; + m->arguments = lily_queue_create(); + m->values = lily_queue_create(); + return m; +} + +void lily_mock_destroy(lily_mock_t *m) +{ + lily_queue_destroy(m->arguments); + lily_queue_destroy(m->values); + free(m); +} + +void _lily_mock_call(lily_mock_t *m, struct lily_mock_arg_t *args, size_t n_args) +{ + m->n_calls += 1; + + for (int i=0; i<n_args; i++) { + _lily_enqueue(m->arguments, args[i].size, args[i].var); + } +} + +void _lily_get_call(lily_mock_t *m, + struct lily_mock_arg_t *args, + size_t n_args, + unsigned int call_num) +{ + size_t stride = 0; + for (int i=0; i<n_args; i++) { + stride += args[i].size; + } + + m->arguments->front = m->arguments->buf + (call_num * stride); + for (int i=0; i<n_args; i++) { + _lily_dequeue(m->arguments, args[i].size, args[i].var); + } +} diff --git a/src/test/lily-test.h b/src/test/lily-test.h new file mode 100644 index 0000000..90fc2c8 --- /dev/null +++ b/src/test/lily-test.h @@ -0,0 +1,252 @@ +/**************************************************************** + * + * ======== lily-test ======== + * + * a midsize C unit testing library + * copyright (c) 2022 kate swanson (sanine) + * + * This is anti-capitalist software, released for free use by individuals and + * organizations that do not operate by capitalist principles. + * + * Permission is hereby granted, free of charge, to any person or + * organization (the "User") obtaining a copy of this software and associated + * documentation files (the "Software"), to use, copy, modify, merge, + * distribute, and/or sell copies of the Software, subject to the following conditions: + * + * 1. The above copyright notice and this permission notice shall be included + * in all copies or modified versions of the Software. + * + * 2. The User is one of the following: + * a. An individual person, laboring for themselves + * b. A non-profit organization + * c. An educational institution + * d. An organization that seeks shared profit for all of its members, and + * allows non-members to set the cost of their labor + * + * 3. If the User is an organization with owners, then all owners are workers + * and all workers are owners with equal equity and/or equal vote. + * + * 4. If the User is an organization, then the User is not law enforcement or + * military, or working for or under either. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT EXPRESS OR IMPLIED WARRANTY OF + * ANY KIND, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * https://anticapitalist.software/ + * https://sanine.net + * + ****************************************************************/ + + +#ifndef LILY_TEST_H +#define LILY_TEST_H + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <setjmp.h> + +#define STR_IMP(x) #x +#define STR(x) STR_IMP(x) +/* define SOURCE_PATH_SIZE to strip away the + leading parts of the full compilation path */ +#ifndef SOURCE_PATH_SIZE +#define LILY_LOCATION (__FILE__ ":" STR(__LINE__)) +#else +#define LILY_LOCATION ((__FILE__ ":" STR(__LINE__)) + SOURCE_PATH_SIZE) +#endif + +/** a few nasty globals that make everything clean for the end user */ +struct lily_globals_t { + jmp_buf env; + size_t error_msg_len; + char *error_msg; + const char *error_location; +}; +extern struct lily_globals_t _lily_globals; + +typedef void (*lily_test_t)(void); + +/** run a single test */ +#define lily_run_test(test) _lily_run_test(#test, test) +void _lily_run_test(const char *name, lily_test_t test); + +/** run a suite */ +#define lily_run_suite(suite) _lily_run_suite(#suite, suite) +void _lily_run_suite(const char *name, lily_test_t suite); + + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * assertions + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +/** basic assertion function, mostly used by the other assertions */ +void lily_assert_msg(bool statement, const char *location, + const char *format_string, ...); + +#define lily_assert_true(statement) _lily_assert_true(#statement, statement, LILY_LOCATION) +void _lily_assert_true(const char *statement, bool value, const char *location); + + +#define lily_assert_false(statement) _lily_assert_false(#statement, statement, LILY_LOCATION) +void _lily_assert_false(const char *statement, bool value, const char *location); + + +#define lily_assert_not_null(ptr) _lily_assert_not_null(#ptr, ptr, LILY_LOCATION) +void _lily_assert_not_null(const char *name, void *ptr, const char *location); + + +#define lily_assert_null(ptr) _lily_assert_null(#ptr, ptr, LILY_LOCATION) +void _lily_assert_null(const char *name, void *ptr, const char *location); + + +#define lily_assert_ptr_equal(a, b) _lily_assert_ptr_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_ptr_equal(const char *name_a, const char *name_b, + void *a, void *b, const char *location); + + +#define lily_assert_ptr_not_equal(a, b) _lily_assert_ptr_not_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b, + void *a, void *b, const char *location); + + +#define lily_assert_int_equal(a, b) _lily_assert_int_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_int_equal(const char *name_a, const char *name_b, + intmax_t a, intmax_t b, const char *location); + + +#define lily_assert_int_not_equal(a, b) _lily_assert_int_not_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_int_not_equal(const char *name_a, const char *name_b, + intmax_t a, intmax_t b, const char *location); + + +#define lily_assert_float_equal(a, b, epsilon) \ + _lily_assert_float_equal(#a, #b, a, b, epsilon, LILY_LOCATION) +void _lily_assert_float_equal(const char *name_a, const char *name_b, + double a, double b, double epsilon, const char *location); + + +#define lily_assert_float_not_equal(a, b, epsilon) \ + _lily_assert_float_not_equal(#a, #b, a, b, epsilon, LILY_LOCATION) +void _lily_assert_float_not_equal(const char *name_a, const char *name_b, + double a, double b, double epsilon, const char *location); + + +#define lily_assert_string_equal(a, b) _lily_assert_string_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_string_equal(const char *name_a, const char *name_b, + char *a, char *b, const char *location); + + +#define lily_assert_string_not_equal(a, b) _lily_assert_string_not_equal(#a, #b, a, b, LILY_LOCATION) +void _lily_assert_string_not_equal(const char *name_a, const char *name_b, + char *a, char *b, const char *location); + + +#define lily_assert_memory_equal(a, b, size) \ + _lily_assert_memory_equal(#a, #b, a, b, size, LILY_LOCATION) +void _lily_assert_memory_equal(const char *name_a, const char *name_b, + void *a, void *b, size_t size, const char *location); + + +#define lily_assert_memory_not_equal(a, b, size) \ + _lily_assert_memory_not_equal(#a, #b, a, b, size, LILY_LOCATION) +void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, + void *a, void *b, size_t size, const char *location); + + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * mocks + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + + +/** queue structure capable of containing arbitrary data */ +typedef struct lily_queue_t { + size_t buf_size; + uint8_t *buf; + uint8_t *front, *back; +} lily_queue_t; + + +/** create a queue */ +lily_queue_t* lily_queue_create(); + +/** destroy a queue */ +void lily_queue_destroy(lily_queue_t *q); + + +/** enqueue a value + * + * q - the queue to append to + * type - the type of the value to append + * value - the value to append + */ +#define lily_enqueue(q, type, value) \ + do { \ + type _var = value; \ + _lily_enqueue(q, sizeof(type), (uint8_t*)(&_var)); \ + } while(0) +void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data); + + +/** pop a value from the queue + * + * q - the queue to pop from + * type - the type of the value to pop + * ptr - the location to store the popped value + */ +#define lily_dequeue(q, type, ptr) \ + _lily_dequeue(q, sizeof(type), (uint8_t*) ptr) +void _lily_dequeue(lily_queue_t *q, size_t size, uint8_t *ptr); + + +struct lily_mock_arg_t { + size_t size; + void *var; +}; + +#define LILY_NARGS(args) (sizeof(args)/sizeof(struct lily_mock_arg_t)) + +/** structure to store data for mock functions */ +typedef struct lily_mock_t { + unsigned int n_calls; + lily_queue_t *arguments; + lily_queue_t *values; +} lily_mock_t; + +/** setup mock function storage */ +lily_mock_t * lily_mock_create(); +/** tear down mock function storage */ +void lily_mock_destroy(lily_mock_t *m); + + +/** store a call to a mock function */ +#define lily_mock_call(m, args) \ + _lily_mock_call(m, args, LILY_NARGS(args)) +void _lily_mock_call(lily_mock_t *m, struct lily_mock_arg_t *args, size_t n_args); + +/** retrieve a call to a mock function */ +#define lily_get_call(m, args, call_num) \ + _lily_get_call(m, args, LILY_NARGS(args), call_num) +void _lily_get_call(lily_mock_t *m, + struct lily_mock_arg_t *args, + size_t n_args, + unsigned int call_num); + +/** store a value in a mock structure */ +#define lily_store_value(m, type, value) \ + lily_enqueue(m->values, type, value) +/** retrieve a value from a mock structure */ +#define lily_get_value(m, type, ptr) \ + lily_dequeue(m->values, type, ptr) + +#endif |