Added a README

added macros to run function at the start and end of each test

- SETUP     = runs once at the start
- TEARDOWN  = runs once at the end
- BEFORE    = runs before each test
- AFTER     = runs after each test

README.md

@@ -0,0 +1,76 @@
+# test.h
+
+A simple header file to get test statistics.
+
+
+> Currently under development things might change without notice
+
+## Usage
+
+Here is a simple simple example for `test.h`
+
+```c
+// sample_test.c
+
+#include "test.h"
+
+TEST(sample1, {
+    ASSERT(1 == 1, "");
+})
+
+TEST_INIT({})
+```
+
+You can compile and rum this test file, and will get an output like this.
+
+```console
+=========================================================================
+TEST doc.c
+
+test_sample1
+	(1/1) passed (0) failed
+
+PASSED - (1/1) passed (0) failed
+=========================================================================
+```
+
+An example with two tests.
+
+```c
+#include "test.h"
+
+TEST(sample1, {
+    ASSERT(1 == 1, "");
+})
+
+TEST(sample2, {
+    ASSERT(1 == 1, "");
+    ASSERT(1 == 0, "This assertion will fail");
+})
+
+TEST_INIT({})
+```
+
+```console
+=========================================================================
+TEST doc.c
+
+test_sample1
+	(1/1) passed (0) failed
+
+test_sample2
+	assertion failed (l.no - 9) [1 == 0]  - This assertion will fail
+	(1/2) passed (1) failed
+
+FAILED - (1/2) passed (1) failed
+=========================================================================
+```
+
+
+To know about all the macros that you can use, check the [examples](./examples/) folder.
+
+---
+
+If you have any issues or want to discuss, [Join my Discord](https://discord.gg/BxMbWzZe2Z)
+
+## Bye....

examples/basic.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+
+// #define MAX_TEST_FUNCS 0
+#include "test.h"
+
+BEFORE({
+    printf("run before each test.\n");
+})
+
+AFTER({
+    printf("runs after each test\n");
+})
+
+SETUP({
+    printf("runs once at the start\n");
+})
+
+TEARDOWN({
+    printf("runs once at the end\n");
+})
+
+TEST(simple_test, {
+    ASSERT(1 == 1, "");
+    // ASSERT(0 == 1, "This assertion will fail");
+})
+
+TEST(simple_test_2, {
+    ASSERT(1 == 1, "");
+    ASSERT(0 == 1, "This assertion will fail");
+})
+
+TEST_INIT()

test.h

@@ -1,7 +1,7 @@
 // include this file in all the test files
 
-#ifndef _TEST_MDB_H
-#define _TEST_MDB_H
+#ifndef _TEST_H
+#define _TEST_H
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,29 +14,84 @@
 #define COLOR_YELLOW "\x1b[33;1m"
 #define COLOR_RESET "\x1b[0m"
 
+#define BEFORE_IDX 0
+#define AFTER_IDX 1
+#define SETUP_IDX 2
+#define TEARDOWN_IDX 3
+
+#ifndef MAX_TEST_FUNCS
 #define MAX_TEST_FUNCS 256
+#endif
 
 typedef int (*test_func_t)();
+typedef void (*special_func_t)();
 
 int total = 0;
 int success = 0;
 static test_func_t test_functions[MAX_TEST_FUNCS];
 
+// before, after, setup, teardown
+static special_func_t special_funcs[4] = {NULL};
+
 #define TEST_INIT(...)                                                                                                                                \
     int main(void) {                                                                                                                                  \
         printf("=========================================================================\n");                                                        \
         printf("TEST %s\n", __FILE__);                                                                                                                \
         __VA_ARGS__                                                                                                                                   \
+        if (special_funcs[SETUP_IDX] != NULL) special_funcs[SETUP_IDX]();                                                                             \
         for (int i = 0; i < total; i++) {                                                                                                             \
+            if (special_funcs[BEFORE_IDX] != NULL) special_funcs[BEFORE_IDX]();                                                                       \
             if (test_functions[i]()) success++;                                                                                                       \
+            if (special_funcs[AFTER_IDX] != NULL) special_funcs[AFTER_IDX]();                                                                         \
         }                                                                                                                                             \
+        if (special_funcs[TEARDOWN_IDX] != NULL) special_funcs[TEARDOWN_IDX]();                                                                       \
         int failed = total - success;                                                                                                                 \
         printf("\n%s - (%d/%d) passed (%d) failed\n" COLOR_RESET, (failed == 0) ? COLOR_GREEN "PASSED" : COLOR_RED "FAILED", success, total, failed); \
         printf("=========================================================================\n");                                                        \
         return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;                                                                                           \
     }
 
-#define TEST(NAME, BLOCK)                                                                                    \
+// special ones :)
+
+#define SETUP(...)                                                    \
+    static void _test_setup();                                        \
+    __attribute__((constructor)) static void register__test_setup() { \
+        special_funcs[SETUP_IDX] = _test_setup;                       \
+    }                                                                 \
+    static void _test_setup() {                                       \
+        __VA_ARGS__                                                   \
+    }
+
+#define TEARDOWN(...)                                                    \
+    static void _test_teardown();                                        \
+    __attribute__((constructor)) static void register__test_teardown() { \
+        special_funcs[TEARDOWN_IDX] = _test_teardown;                    \
+    }                                                                    \
+    static void _test_teardown() {                                       \
+        __VA_ARGS__                                                      \
+    }
+
+#define BEFORE(...)                                                    \
+    static void _test_before();                                        \
+    __attribute__((constructor)) static void register__test_before() { \
+        special_funcs[BEFORE_IDX] = _test_before;                      \
+    }                                                                  \
+    static void _test_before() {                                       \
+        __VA_ARGS__                                                    \
+    }
+
+#define AFTER(...)                                                    \
+    static void _test_after();                                        \
+    __attribute__((constructor)) static void register__test_after() { \
+        special_funcs[AFTER_IDX] = _test_after;                       \
+    }                                                                 \
+    static void _test_after() {                                       \
+        __VA_ARGS__                                                   \
+    }
+
+// test stuff
+
+#define TEST(NAME, ...)                                                                                      \
     static int test_##NAME();                                                                                \
     __attribute__((constructor)) static void register_test_##NAME() {                                        \
         if (total < MAX_TEST_FUNCS) {                                                                        \
@@ -50,7 +105,7 @@ static test_func_t test_functions[MAX_TEST_FUNCS];
         printf("\ntest_" #NAME "\n");                                                                        \
         int total_assert = 0;                                                                                \
         int total_success = 0;                                                                               \
-        BLOCK                                                                                                \
+        __VA_ARGS__                                                                                          \
         printf("\t(%d/%d) passed (%d) failed\n", total_success, total_assert, total_assert - total_success); \
         return (total_assert == total_success);                                                              \
     }