From a033103e60aca0c17afa6117e8e46b197aa90109 Mon Sep 17 00:00:00 2001 From: JP Appel Date: Wed, 3 Sep 2025 23:41:53 -0400 Subject: Simplify namespace prefix --- README.md | 22 +++++++++++----------- examples/basics.c | 34 +++++++++++++++++----------------- eztester.c | 41 +++++++++++++++++++++++------------------ eztester.h | 40 ++++++++++++++++++++-------------------- eztester_list.c | 18 +++++++++--------- 5 files changed, 80 insertions(+), 75 deletions(-) diff --git a/README.md b/README.md index f89c277..269b970 100644 --- a/README.md +++ b/README.md @@ -34,8 +34,8 @@ int sum_of_integers(const int max){ eztester_status sample_test(){ const int max = 100; - eztester_log("Inside of Sample Test"); - eztester_log("adding %d consectuive positive integers", max); + ez_log("Inside of Sample Test"); + ez_log("adding %d consectuive positive integers", max); int actual = 0; for(int i = 1; i <= max; i++){ @@ -55,7 +55,7 @@ eztester_status sample_test(){ } } -eztester_status sample_shell_test(){ +ez_status sample_shell_test(){ // eztester_shell is a wrapper function for `system` // see `eztester.h` for more info int status = eztester_shell("curl invalid.url"); @@ -74,21 +74,21 @@ eztester_status sample_shell_test(){ } int main(int argc, char* argv[]){ - eztester_list *tests = ezterster_create_list(2); + ez_list *tests = ezterster_create_list(2); // runners that always return the same status are provided - eztester_register(tests, (eztester_test){eztester_always_pass, "Always Pass", 0}); - eztester_register(tests, (eztester_test){sample_test, "Sample Test", 0}); // our test, can be defined in a different translation unit + ez_register(tests, (ez_test){ez_always_pass, "Always Pass", 0}); + ez_register(tests, (ez_test){sample_test, "Sample Test", 0}); // our test, can be defined in a different translation unit // a list will resize on register when it doesn't have capacity - eztester_register(tests, (eztester_test){eztester_always_fail, "Always Fail", 0}); - eztester_register(tests, (eztester_test){eztester_always_warn, "Always Warn", 0}); + ez_register(tests, (ez_test){ez_always_fail, "Always Fail", 0}); + ez_register(tests, (ez_test){ez_always_warn, "Always Warn", 0}); - eztester_register(tests, (eztester_test){sample_shell_test, "Check a non existent url"); + ez_register(tests, (ez_test){sample_shell_test, "Check a non existent url"); - eztester_run(tests, EXIT_ON_FAIL | EXIT_ON_TIMEOUT ); + ez_run(tests, EXIT_ON_FAIL | EXIT_ON_TIMEOUT ); - eztester_destroy_list(tests); + ez_destroy_list(tests); return 0; } ``` diff --git a/examples/basics.c b/examples/basics.c index 6aab9d2..8b4938b 100644 --- a/examples/basics.c +++ b/examples/basics.c @@ -6,8 +6,8 @@ #include "../build/header/eztester.h" #undef EZTESTER_IMPLEMENTATION -eztester_status shell_exists() { - int status = eztester_shell(NULL); +ez_status shell_exists() { + int status = ez_shell(NULL); if (status) { return TEST_FAIL; } else { @@ -15,8 +15,8 @@ eztester_status shell_exists() { } } -eztester_status python3_exists() { - int status = eztester_shell("/usr/bin/env python3 --version"); +ez_status python3_exists() { + int status = ez_shell("/usr/bin/env python3 --version"); if (status) { return TEST_FAIL; } else { @@ -24,28 +24,28 @@ eztester_status python3_exists() { } } -eztester_status sleepy() { - eztester_log("Im feeling sleepy"); +ez_status sleepy() { + ez_log("Im feeling sleepy"); sleep(2); - eztester_log("zzzzzzz"); + ez_log("zzzzzzz"); sleep(1); - eztester_log("ZZZZZZZZ"); + ez_log("ZZZZZZZZ"); sleep(2); - eztester_log("oh, hello there."); + ez_log("oh, hello there."); return TEST_PASS; } int main(int argc, char *argv[]) { - eztester_list *list = eztester_create_list(5); + ez_list *list = ez_create_list(5); - eztester_register( - list, (eztester_test){eztester_always_pass_test, "Always pass", 0}); - eztester_register( - list, (eztester_test){eztester_always_warn_test, "Always warn", 0}); - eztester_register(list, (eztester_test){sleepy, "Timeout test", 4e3}); - eztester_register(list, (eztester_test){python3_exists, "Python3 Exists", 0}); + ez_register( + list, (ez_test){ez_always_pass_test, "Always pass", 0}); + ez_register( + list, (ez_test){ez_always_warn_test, "Always warn", 0}); + ez_register(list, (ez_test){sleepy, "Timeout test", 4e3}); + ez_register(list, (ez_test){python3_exists, "Python3 Exists", 0}); - eztester_run(list, EXIT_ON_FAIL); + ez_run(list, EXIT_ON_FAIL); return 0; } diff --git a/eztester.c b/eztester.c index b0a2322..06f9f78 100644 --- a/eztester.c +++ b/eztester.c @@ -15,8 +15,8 @@ struct _ez_shared_mem { int work_in_queue : 1; - eztester_status status : 3; - eztester_behavior behavior : 3; + ez_status status : 3; + ez_behavior behavior : 3; size_t index; }; @@ -106,7 +106,7 @@ void _ez_premature_exit(const char *message, const pid_t worker, } void _ez_worker(volatile struct _ez_shared_mem *mem, - const eztester_list *list) { + const ez_list *list) { while (mem->index < list->length) { // wait for work while (!mem->work_in_queue) { @@ -143,7 +143,12 @@ void _ez_chld_handler(int signum) { } } -void eztester_run(eztester_list *test_list, eztester_behavior behavior) { +void _ez_int_handler(int signum) { + // TODO: catch various "kill" signals on the main process and terminate + // gracefully +} + +void ez_run(ez_list *test_list, ez_behavior behavior) { struct _ez_shared_mem *mem = _ez_create_shared_memory(); mem->index = 0; @@ -161,8 +166,8 @@ void eztester_run(eztester_list *test_list, eztester_behavior behavior) { } child_pgid = pid; - eztester_status status; - eztester_test test; + ez_status status; + ez_test test; struct _ez_tests_results results = { .current = 0, .passed = 0, .total = test_list->length}; @@ -267,28 +272,28 @@ void eztester_run(eztester_list *test_list, eztester_behavior behavior) { _ez_destroy_shared_memory(mem); } -int eztester_shell(const char *command) { +int ez_shell(const char *command) { int result; if (command == NULL) { - eztester_log("Recieved NULL as command, checking for shell availability"); + ez_log("Recieved NULL as command, checking for shell availability"); result = !system(command); - eztester_log("Shell %s available", (result) ? "is not" : "is"); + ez_log("Shell %s available", (result) ? "is not" : "is"); return result; } - eztester_log("Executing %s", command); + ez_log("Executing %s", command); result = system(command); if (result == -1) { - eztester_log("Error with child process"); + ez_log("Error with child process"); perror(command); } else { - eztester_log("Process exited with a status of %d", result); + ez_log("Process exited with a status of %d", result); } return result; } -void eztester_log(const char *restrict format, ...) { +void ez_log(const char *restrict format, ...) { va_list args; va_start(args, format); printf("> "); @@ -297,8 +302,8 @@ void eztester_log(const char *restrict format, ...) { va_end(args); } -eztester_status eztester_always_pass_test() { return TEST_PASS; } -eztester_status eztester_always_warn_test() { return TEST_WARNING; } -eztester_status eztester_always_timeout_test() { return TEST_TIMEOUT; } -eztester_status eztester_always_fail_test() { return TEST_FAIL; } -eztester_status eztester_always_error_test() { return TEST_ERROR; } +ez_status ez_always_pass_test() { return TEST_PASS; } +ez_status ez_always_warn_test() { return TEST_WARNING; } +ez_status ez_always_timeout_test() { return TEST_TIMEOUT; } +ez_status ez_always_fail_test() { return TEST_FAIL; } +ez_status ez_always_error_test() { return TEST_ERROR; } diff --git a/eztester.h b/eztester.h index 9a68651..d1fbe3c 100644 --- a/eztester.h +++ b/eztester.h @@ -12,7 +12,7 @@ typedef enum { TEST_TIMEOUT, TEST_FAIL, TEST_ERROR -} eztester_status; +} ez_status; /* how eztester should behave when encountering a non passing test. */ @@ -21,39 +21,39 @@ typedef enum { EXIT_ON_WARNING = 1, EXIT_ON_TIMEOUT = 2, EXIT_ON_FAIL = 4 -} eztester_behavior; +} ez_behavior; // a single individual test to be ran -typedef eztester_status(eztester_runner)(); +typedef ez_status(ez_runner)(); typedef struct { - eztester_runner *runner; + ez_runner *runner; const char *name; unsigned int max_time_ms; -} eztester_test; +} ez_test; typedef struct { - eztester_test *tests; + ez_test *tests; size_t length; size_t capacity; -} eztester_list; +} ez_list; // create a list with a given capacity -eztester_list *eztester_create_list(const size_t capacity); +ez_list *ez_create_list(const size_t capacity); /* add a test to a list. * the same test can be registered multiple times. * will resize the list as necessary */ -void eztester_register(eztester_list *test_list, const eztester_test new_test); +void ez_register(ez_list *test_list, const ez_test new_test); // remove all tests from a list but do not free the list itself -void eztester_clear_list(eztester_list *test_list); +void ez_clear_list(ez_list *test_list); // clears a list and free's the list -void eztester_destroy_list(eztester_list *test_list); +void ez_destroy_list(ez_list *test_list); // log info during a test -void eztester_log(const char *__restrict format, ...); +void ez_log(const char *__restrict format, ...); // run all tests with a list with a given behavior -void eztester_run(eztester_list *test_list, const eztester_behavior behavior); +void ez_run(ez_list *test_list, const ez_behavior behavior); /* Wrapper for `system` function * @@ -62,19 +62,19 @@ void eztester_run(eztester_list *test_list, const eztester_behavior behavior); * * If command is not null return the exit status of the process */ -int eztester_shell(const char *command); +int ez_shell(const char *command); -// tests that always return an eztester_status +// tests that always return an ez_status // always return pass -eztester_status eztester_always_pass_test(); +ez_status ez_always_pass_test(); // always return warning -eztester_status eztester_always_warn_test(); +ez_status ez_always_warn_test(); // always return timeout -eztester_status eztester_always_timeout_test(); +ez_status ez_always_timeout_test(); // always return fail -eztester_status eztester_always_fail_test(); +ez_status ez_always_fail_test(); // always return error -eztester_status eztester_always_error_test(); +ez_status ez_always_error_test(); #endif diff --git a/eztester_list.c b/eztester_list.c index bac6fc2..42ebcbc 100644 --- a/eztester_list.c +++ b/eztester_list.c @@ -3,8 +3,8 @@ #include #include -eztester_list *eztester_create_list(const size_t capacity) { - eztester_list *list = malloc(sizeof(eztester_list)); +ez_list *ez_create_list(const size_t capacity) { + ez_list *list = malloc(sizeof(ez_list)); if (!list) { return NULL; } @@ -17,7 +17,7 @@ eztester_list *eztester_create_list(const size_t capacity) { return list; } - eztester_test *tests = malloc(capacity * sizeof(eztester_test)); + ez_test *tests = malloc(capacity * sizeof(ez_test)); if (!tests) { free(list); return NULL; @@ -28,28 +28,28 @@ eztester_list *eztester_create_list(const size_t capacity) { return list; } -void eztester_register(eztester_list *test_list, const eztester_test new_test) { +void ez_register(ez_list *test_list, const ez_test new_test) { if (test_list->capacity == 0) { - test_list->tests = realloc(test_list->tests, 2 * sizeof(eztester_test)); + test_list->tests = realloc(test_list->tests, 2 * sizeof(ez_test)); test_list->capacity = 2; } if (test_list->capacity <= test_list->length + 1) { test_list->capacity *= 2; test_list->tests = - realloc(test_list->tests, test_list->capacity * sizeof(eztester_test)); + realloc(test_list->tests, test_list->capacity * sizeof(ez_test)); assert(test_list->tests); } test_list->tests[test_list->length++] = new_test; } -void eztester_clear_list(eztester_list *test_list) { +void ez_clear_list(ez_list *test_list) { free(test_list->tests); test_list->length = 0; test_list->capacity = 0; } -void eztester_destroy_list(eztester_list *test_list) { - eztester_clear_list(test_list); +void ez_destroy_list(ez_list *test_list) { + ez_clear_list(test_list); free(test_list); } -- cgit v1.2.3