Simplify namespace prefix

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 <assert.h>
 #include <stdlib.h>
 
-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);
 }