From c4619e22d571bffa75ab033fceda7915c676f90d Mon Sep 17 00:00:00 2001 From: sanine Date: Mon, 4 Apr 2022 12:39:36 -0500 Subject: add basic mock queue + test --- CMakeLists.txt | 1 + lily-test.c | 85 +++++++++++++++++++++++++++++++++++++++++++++++++----- lily-test.h | 40 +++++++++++++++++++++++++ tests/main.c | 2 ++ tests/mock_queue.c | 37 ++++++++++++++++++++++++ tests/tests.h | 4 +++ 6 files changed, 161 insertions(+), 8 deletions(-) create mode 100644 tests/mock_queue.c diff --git a/CMakeLists.txt b/CMakeLists.txt index d36e1b3..397284c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,6 +14,7 @@ add_executable(lily-metatest ${TEST_SRC}/main.c ${TEST_SRC}/helpers.c ${TEST_SRC}/assertions.c + ${TEST_SRC}/mock_queue.c ) set_target_properties(lily-metatest PROPERTIES C_STANDARD 99 diff --git a/lily-test.c b/lily-test.c index cae4657..7484894 100644 --- a/lily-test.c +++ b/lily-test.c @@ -9,6 +9,7 @@ struct lily_globals_t _lily_globals; void lily_init() { + _lily_globals.error_msg_len = 0; _lily_globals.error_msg = NULL; _lily_globals.error_location = ""; } @@ -29,19 +30,30 @@ static void _lily_assert_msg(bool statement, const char *location, size_t length = vsnprintf(NULL, 0, format_string, args_len); va_end(args_len); - char *msg = realloc(_lily_globals.error_msg, (length+1) * sizeof(char)); - if (msg == NULL) { - fprintf(stderr, "WARNING: failed to allocate memory for failed test message!\n"); - if (_lily_globals.error_msg != NULL) { + if (_lily_globals.error_msg_len < length+1) { + 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; + printf("reallocated global msg: %p ", msg); } - } - else { - vsnprintf(msg, length+1, format_string, args); - _lily_globals.error_msg = msg; } + printf("length: %lu ", length); + + vsnprintf(_lily_globals.error_msg, length+1, format_string, args); + va_end(args); longjmp(_lily_globals.env, 1); } @@ -175,3 +187,60 @@ void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, lily_assert_msg(memcmp(a, b, size) == 0, "%s contains the same data s %s", name_a, name_b); } + + +lily_mock_queue_t* lily_queue_create() +{ + const size_t size = 256 * sizeof(uint8_t); + + lily_mock_queue_t *q = malloc(sizeof(lily_mock_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_mock_queue_t *q) +{ + free(q->buf); + free(q); +} + + +void _lily_enqueue(lily_mock_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_mock_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; +} diff --git a/lily-test.h b/lily-test.h index de69e92..783e134 100644 --- a/lily-test.h +++ b/lily-test.h @@ -18,6 +18,7 @@ struct lily_globals_t { jmp_buf env; + size_t error_msg_len; char *error_msg; const char *error_location; }; @@ -25,6 +26,14 @@ struct lily_globals_t { extern struct lily_globals_t _lily_globals; void lily_init(); + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * assertions + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + void lily_assert_msg(bool statement, const char *location, const char *format_string, ...); @@ -97,4 +106,35 @@ void _lily_assert_memory_equal(const char *name_a, const char *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); + +/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * mocks + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +typedef struct lily_mock_queue_t { + size_t buf_size; + uint8_t *buf; + uint8_t *front, *back; +} lily_mock_queue_t; + + +lily_mock_queue_t* lily_queue_create(); +void lily_queue_destroy(lily_mock_queue_t *q); + +#define lily_enqueue(q, type, value) \ + do { \ + type _var = value; \ + _lily_enqueue(q, sizeof(type), (uint8_t*)(&_var)); \ + } while(0) +void _lily_enqueue(lily_mock_queue_t *q, size_t size, uint8_t *data); + + +#define lily_dequeue(q, type, ptr) \ + _lily_dequeue(q, sizeof(type), (uint8_t*) ptr) +void _lily_dequeue(lily_mock_queue_t *q, size_t size, uint8_t *ptr); + + #endif diff --git a/tests/main.c b/tests/main.c index 3c94cf7..f8e272f 100644 --- a/tests/main.c +++ b/tests/main.c @@ -20,6 +20,8 @@ int main() run_test(test_assert_ptr_not_equal); run_test(test_assert_int_equal); run_test(test_assert_int_not_equal); + + run_test(test_mock_enqueue_dequeue_int); return 0; } diff --git a/tests/mock_queue.c b/tests/mock_queue.c new file mode 100644 index 0000000..e9527b2 --- /dev/null +++ b/tests/mock_queue.c @@ -0,0 +1,37 @@ +#include +#include + +#include "lily-test.h" +#include "tests.h" + + +const char* test_mock_enqueue_dequeue_int() { + lily_mock_queue_t *q = lily_queue_create(); + + /* enqueue A259482, for no particular reason */ + lily_enqueue(q, int, 2); + lily_enqueue(q, int, 6); + lily_enqueue(q, int, 44); + int n = 2014; + lily_enqueue(q, int, n); + + lily_dequeue(q, int, &n); + if (n != 2) return "dequeued incorrect first value"; + lily_dequeue(q, int, &n); + + /* queue next value after already popping */ + lily_enqueue(q, long, 1651377); + + if (n != 6) return "dequeued incorrect second value"; + lily_dequeue(q, int, &n); + if (n != 44) return "dequeued incorrect third value"; + lily_dequeue(q, int, &n); + if (n != 2014) return "dequeued incorrect fourth value"; + long m; + lily_dequeue(q, long, &m); + if (m != 1651377) return "dequeued incorrect fifth value"; + + lily_queue_destroy(q); + + return 0; +} diff --git a/tests/tests.h b/tests/tests.h index 995beaf..266cc04 100644 --- a/tests/tests.h +++ b/tests/tests.h @@ -17,4 +17,8 @@ const char* test_assert_ptr_equal(); const char* test_assert_ptr_not_equal(); const char* test_assert_int_equal(); const char* test_assert_int_not_equal(); + +const char* test_mock_enqueue_dequeue_int(); +const char* test_mock_enqueue_dequeue_heterogenous(); + #endif -- cgit v1.2.1