From 089eead7853a9a211253f720c309328a90669b25 Mon Sep 17 00:00:00 2001 From: sanine Date: Thu, 14 Jul 2022 10:31:00 -0500 Subject: refactor: spaces -> tabs --- lily-test.h | 74 ++++++++++++++++++++++++++++++------------------------------- 1 file changed, 37 insertions(+), 37 deletions(-) (limited to 'lily-test.h') diff --git a/lily-test.h b/lily-test.h index b3df728..bf896a6 100644 --- a/lily-test.h +++ b/lily-test.h @@ -57,7 +57,7 @@ #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 */ + leading parts of the full compilation path */ #ifndef SOURCE_PATH_SIZE #define LILY_LOCATION (__FILE__ ":" STR(__LINE__)) #else @@ -66,10 +66,10 @@ /** 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; + jmp_buf env; + size_t error_msg_len; + char *error_msg; + const char *error_location; }; extern struct lily_globals_t _lily_globals; @@ -93,7 +93,7 @@ void _lily_run_suite(const char *name, lily_test_t suite); /** basic assertion function, mostly used by the other assertions */ void lily_assert_msg(bool statement, const char *location, - const char *format_string, ...); + 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); @@ -113,7 +113,7 @@ 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); + 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) @@ -123,7 +123,7 @@ void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b, #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); + 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) @@ -132,37 +132,37 @@ void _lily_assert_int_not_equal(const char *name_a, const char *name_b, #define lily_assert_float_equal(a, b, epsilon) \ - _lily_assert_float_equal(#a, #b, a, b, epsilon, LILY_LOCATION) + _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); + 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) + _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); + 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); + 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) + _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); + 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) + _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); + void *a, void *b, size_t size, const char *location); /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -175,9 +175,9 @@ void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, /** queue structure capable of containing arbitrary data */ typedef struct lily_queue_t { - size_t buf_size; - uint8_t *buf; - uint8_t *front, *back; + size_t buf_size; + uint8_t *buf; + uint8_t *front, *back; } lily_queue_t; @@ -195,10 +195,10 @@ void lily_queue_destroy(lily_queue_t *q); * 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) + 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); @@ -209,22 +209,22 @@ void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data); * ptr - the location to store the popped value */ #define lily_dequeue(q, type, ptr) \ - _lily_dequeue(q, sizeof(type), (uint8_t*) 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; + 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; + unsigned int n_calls; + lily_queue_t *arguments; + lily_queue_t *values; } lily_mock_t; /** setup mock function storage */ @@ -235,22 +235,22 @@ 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)) + _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) + _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); + 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) + 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) + lily_dequeue(m->values, type, ptr) #endif -- cgit v1.2.1