formatting: formatted against new .clang-format

12 files changed, 282 insertions, 154 deletions

diff --git a/Makefile b/Makefile
index 9474fc8..b8e7157 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,8 @@ RUN_TESTS=./run_tests
 ifneq ($(shell uname -s),Darwin)
 	CFLAGS+= -s
 else
-	RUN_TESTS=DYLD_FALLBACK_LIBRARY_PATH="/usr/local/lib:$DYLD_FALLBACK_LIBRARY_PATH" ./run_tests; rm -rf run_tests.dSYM/
+	RUN_TESTS=DYLD_FALLBACK_LIBRARY_PATH="/usr/local/lib:$DYLD_FALLBACK_LIBRARY_PATH"
+	RUN_TESTS+= ./run_tests; rm -rf run_tests.dSYM/
 endif
 
 both: shared static clean
diff --git a/README.md b/README.md
index b36913f..e3d3bc7 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # Personal library for a bunch of useful stuff
 
-Just a bunch of useful code for me, put into a single lib, so I don't have to reimplement it every single time.  
+Just a bunch of useful code for me, put into a single lib,  
+so I don't have to reimplement it every single time.  
 Defnitely not the best implementations ever made, but they're mine, so idc.
 
 ## Contains:
diff --git a/include/moslib/ds/array.h b/include/moslib/ds/array.h
index 36acc03..cc0c174 100644
--- a/include/moslib/ds/array.h
+++ b/include/moslib/ds/array.h
@@ -1,8 +1,8 @@
 // moslib/ds/array.h
 // Implementation of dynamic array
 
-// ======================================== QUICK USAGE GUIDE =========================================
-// ----------------------------------------------------------------------------------------------------
+// ======================================= QUICK USAGE GUIDE =======================================
+// -------------------------------------------------------------------------------------------------
 //
 // Define the dynamic array of type T as:
 //
@@ -14,7 +14,7 @@
 //
 //      #define MOS_ARR_INIT_CAP <desired_init_cap>
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // You can access the items simply by array indexing:
 //
@@ -29,7 +29,7 @@
 // It will provide bounds checking - arr_get returning NULL when index is out of bounds
 //                                 - both arr_first and arr_last returning NULL when array is empty
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To append/push to the array use:
 //
@@ -46,15 +46,15 @@
 //      size_t index = arr_insert(array, i, item);
 //
 // It returns the index of the newly inserted item
-// If index is greater or equal to array length then it functions identically to arr_append/arr_push.
+// If index >= array length then it functions identically to arr_append/arr_push.
 //
 // To put into specific index (and update if value exists) use:
 //
 //      size_t index = arr_put(array, i, item);
 //
 // It returns the index of the newly put item
-// If index is greater or equal to array length it will extend the length to the put item and it will
-// zero all items between previously last item to the new item.
+// If index >= array length it will extend the length to the put item and it will zero all items
+// between previously last item to the new item.
 //
 // If you want to add more items than 1 at once, you can use these:
 //
@@ -65,7 +65,7 @@
 //
 // They work the same way as their counterparts without n, but accept an array of items instead.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To concatenate two dynamic arrays of the same type use:
 //
@@ -75,7 +75,7 @@
 // Returns index of the first item of array2 in array1.
 // If array 2 is NULL or has length 0 - returns (size_t)-1.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To delete and retrieve the last item from an array use:
 //
@@ -102,7 +102,7 @@
 //
 // They work like arr_del_n without needing to specify the indices.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // You can use these to get a pointer to the previous or next item in array:
 //
@@ -112,7 +112,7 @@
 // When p_item is NULL it will return pointer to the last/first item.
 // When there's no prev/next item - it will return NULL.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To get array's current length use:
 //
@@ -126,7 +126,7 @@
 // If it's smaller than current length - it will delete items.
 // Returns amount of items deleted in this way.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To get array's current capacity use:
 //
@@ -139,14 +139,14 @@
 // When target_cap is lower than array length it will set capacity to array length.
 // Returns the new capacity.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To free the array from memory use:
 //
 //      arr_free(array);
 //
-// ----------------------------------------------------------------------------------------------------
-// ===================================== END OF QUICK USAGE GUIDE =====================================
+// -------------------------------------------------------------------------------------------------
+// ===================================== END OF QUICK USAGE GUIDE ==================================
 
 #include "moslib/safe.h"
 
@@ -220,8 +220,6 @@
 //   pointer to the last item or NULL if array is empty
 #define mos_arr_last(arr) (mos_arr_len(arr) == 0 ? NULL : (arr) + mos_arr_len(arr) - 1)
 
-// clang-format off
-
 // Append a given item to the array
 //
 // Arguments:
@@ -235,11 +233,10 @@
 // Returns:
 //   index of the appended item
 #define mos_arr_push mos_arr_append
-#define mos_arr_append(arr, ...) (                               \
-    mos_arr_append_fn(&(arr), sizeof(*(arr)), MOS_ARR_INIT_CAP), \
-    (arr)[mos_arr_len(arr) - 1] = __VA_ARGS__,                   \
-    mos_arr_len(arr) - 1                                         \
-)
+#define mos_arr_append(arr, ...)                                                                   \
+    (mos_arr_append_fn(&(arr), sizeof(*(arr)), MOS_ARR_INIT_CAP),                                  \
+     (arr)[mos_arr_len(arr) - 1] = __VA_ARGS__,                                                    \
+     mos_arr_len(arr) - 1)
 
 // Insert a given item at the specific position in the array
 // Move everything after it to the right
@@ -258,15 +255,12 @@
 //
 // Returns:
 //   index of the inserted item
-#define mos_arr_insert(arr, i, ...) (                                   \
-    (size_t)(i) >= mos_arr_len(arr) ? (                                 \
-        mos_arr_append(arr, __VA_ARGS__)                                \
-    ) : (                                                               \
-        mos_arr_insert_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP), \
-        (arr)[(size_t)(i)] = __VA_ARGS__,                               \
-        (size_t)(i)                                                     \
-    )                                                                   \
-)
+#define mos_arr_insert(arr, i, ...)                                                                \
+    ((size_t)(i) >= mos_arr_len(arr)                                                               \
+         ? (mos_arr_append(arr, __VA_ARGS__))                                                      \
+         : (mos_arr_insert_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP),                        \
+            (arr)[(size_t)(i)] = __VA_ARGS__,                                                      \
+            (size_t)(i)))
 
 // Put a given item at the specific position in the array
 // If index is within array bounds - it overwrites the item at given spot
@@ -286,13 +280,10 @@
 //
 // Returns:
 //   index of the put item
-#define mos_arr_put(arr, i, ...) (                               \
-    mos_arr_put_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP), \
-    (arr)[(size_t)(i)] = __VA_ARGS__,                            \
-    (size_t)(i)                                                  \
-)
-
-// clang-format on
+#define mos_arr_put(arr, i, ...)                                                                   \
+    (mos_arr_put_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP),                                  \
+     (arr)[(size_t)(i)] = __VA_ARGS__,                                                             \
+     (size_t)(i))
 
 // Append n given items to the array
 //
@@ -309,7 +300,8 @@
 // Returns:
 //   index of the first appended item
 #define mos_arr_push_n mos_arr_append_n
-#define mos_arr_append_n(arr, items, n) mos_arr_append_n_fn(&(arr), items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
+#define mos_arr_append_n(arr, items, n)                                                            \
+    mos_arr_append_n_fn(&(arr), items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Insert n given items at the specific position in the array
 // Move everything after them to the right
@@ -330,7 +322,8 @@
 //
 // Returns:
 //   index of the first inserted item
-#define mos_arr_insert_n(arr, i, items, n) mos_arr_insert_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
+#define mos_arr_insert_n(arr, i, items, n)                                                         \
+    mos_arr_insert_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Put n given items at the specific position in the array
 // If index is within array bounds - it overwrites the items at given spots
@@ -352,7 +345,8 @@
 //
 // Returns:
 //   index of the first put item
-#define mos_arr_put_n(arr, i, items, n) mos_arr_put_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
+#define mos_arr_put_n(arr, i, items, n)                                                            \
+    mos_arr_put_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Concatenate two dynamic arrays of the same type
 //
@@ -365,7 +359,8 @@
 //
 // Returns:
 //   index of the first new item in arr1 or (size_t)-1 if arr2 is NULL or has length 0
-#define mos_arr_concat(arr1, arr2) mos_arr_concat_fn(&(arr1), arr2, sizeof(*(arr1)), MOS_ARR_INIT_CAP)
+#define mos_arr_concat(arr1, arr2)                                                                 \
+    mos_arr_concat_fn(&(arr1), arr2, sizeof(*(arr1)), MOS_ARR_INIT_CAP)
 
 // Delete and retrieve the last item from the array
 // No bounds checking
@@ -448,7 +443,10 @@
 //
 // Returns:
 //   pointer to the previous item or NULL if there's no more items
-#define mos_arr_prev(arr, curr) ((!(arr) || !(curr)) ? mos_arr_last(arr) : ((curr) == mos_arr_first(arr) ? NULL : (arr) + mos_arr_p_diff(curr, arr) - 1))
+#define mos_arr_prev(arr, curr)                                                                    \
+    ((!(arr) || !(curr))                                                                           \
+         ? mos_arr_last(arr)                                                                       \
+         : ((curr) == mos_arr_first(arr) ? NULL : (arr) + mos_arr_p_diff(curr, arr) - 1))
 
 // Get the pointer to the next item in the array from the pointer to the current one
 // If pointer is NULL - gets the first item from the array
@@ -462,7 +460,10 @@
 //
 // Returns:
 //   pointer to the next item or NULL if there's no more items
-#define mos_arr_next(arr, curr) ((!(arr) || !(curr)) ? mos_arr_first(arr) : ((curr) == mos_arr_last(arr) ? NULL : (arr) + mos_arr_p_diff(curr, arr) + 1))
+#define mos_arr_next(arr, curr)                                                                    \
+    ((!(arr) || !(curr))                                                                           \
+         ? mos_arr_first(arr)                                                                      \
+         : ((curr) == mos_arr_last(arr) ? NULL : (arr) + mos_arr_p_diff(curr, arr) + 1))
 
 // Get the length of the array
 //
@@ -526,9 +527,14 @@ extern void mos_arr_free(void *arr);
 extern void mos_arr_append_fn(void *p_arr, size_t el_size, size_t init_cap);
 extern void mos_arr_insert_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap);
 extern void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap);
-extern size_t mos_arr_append_n_fn(void *p_arr, const void *items, size_t n, size_t el_size, size_t init_cap);
-extern size_t mos_arr_insert_n_fn(void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap);
-extern size_t mos_arr_put_n_fn(void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap);
+extern size_t
+mos_arr_append_n_fn(void *p_arr, const void *items, size_t n, size_t el_size, size_t init_cap);
+extern size_t mos_arr_insert_n_fn(
+    void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap
+);
+extern size_t mos_arr_put_n_fn(
+    void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap
+);
 extern size_t mos_arr_concat_fn(void *p_arr, const void *arr2, size_t el_size, size_t init_cap);
 extern size_t mos_arr_del_fn(void *arr, size_t i, size_t el_size);
 extern size_t mos_arr_del_n_fn(void *arr, size_t i, size_t n, size_t el_size);
diff --git a/include/moslib/ds/hashmap.h b/include/moslib/ds/hashmap.h
index cd17d0f..09a27e2 100644
--- a/include/moslib/ds/hashmap.h
+++ b/include/moslib/ds/hashmap.h
@@ -1,8 +1,8 @@
 // moslib/ds/hashmap.h
 // Implementation of hashmap
 
-// ======================================== QUICK USAGE GUIDE =========================================
-// ----------------------------------------------------------------------------------------------------
+// ======================================= QUICK USAGE GUIDE =======================================
+// -------------------------------------------------------------------------------------------------
 //
 // Start by defining an Entry struct:
 //
@@ -36,8 +36,6 @@
 //
 // .hash and .eq will overwrite the functions set by .key.
 //
-// It's better to assign NULL than to call hm_new with no arguments when you don't redefine anything.
-//
 // Examples:
 //
 //      HM_DEF(str_int, char *, int);
@@ -52,13 +50,13 @@
 //      HM_DEF(int_int, int, int);
 //      int_int *hm3 = hm_new(.hash = hash_int);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To set the hashmap load factor, define (before including the header):
 //
 //      #define MOS_HM_LOAD_FACTOR <desired_load_factor_in_%>
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To put a key/value pair or an entry into a hashmap use:
 //
@@ -67,7 +65,7 @@
 //
 // If an entry with the same key already exists - it will be overwritten.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To get a value from a hashmap use:
 //
@@ -80,9 +78,9 @@
 //      struct Entry *entry = hm_get_e(hm, key);
 //
 // If an entry of given key is not in the hashmap it will return NULL.
-// Note that hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
+// Note: hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To delete an an entry from a hashmap use:
 //
@@ -97,7 +95,7 @@
 // It works the same as hm_del - it just ensures no reallocation.
 // Useful when you want to delete entries while looping over them.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // You can loop over the hashmap using these functions:
 //
@@ -106,28 +104,28 @@
 //
 // hm_first will return the pointer to the "first entry" (with the lowest hash) in the hashmap.
 // If hashmap is empty - it will return NULL.
-// Note that hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
+// Note: hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
 //
 // hm_next returns the pointer to the next entry in the hashmap from the pointer to the current one.
 // If hashmap is empty        - it will return NULL.
 // If curr is NULL            - same as hm_first.
 // If curr is the last entry  - it will return NULL.
-// Note that hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
+// Note: hm_put, hm_put_e and hm_del might cause a rehash which will leave that pointer dangling.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To get the count of entries in the hashmap, use:
 //
 //      hm_size(hm);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Free the hashmap with:
 //
 //      hm_free(hm);
 //
-// ----------------------------------------------------------------------------------------------------
-// ===================================== END OF QUICK USAGE GUIDE =====================================
+// -------------------------------------------------------------------------------------------------
+// =================================== END OF QUICK USAGE GUIDE ====================================
 
 #include <stddef.h>
 #include <stdint.h>
@@ -166,10 +164,12 @@ typedef struct {
     int (*eq)(const void *key1, const void *key2);
 } MosHmNewArgs;
 
-// clang-format off
 // Macro to define Entry struct easier
-#define MOS_HM_DEF(name, key_t, val_t) typedef struct {key_t key; val_t val;} name
-// clang-format on
+#define MOS_HM_DEF(name, key_t, val_t)                                                             \
+    typedef struct {                                                                               \
+        key_t key;                                                                                 \
+        val_t val;                                                                                 \
+    } name
 
 // Create a new hashmap
 //
@@ -204,7 +204,11 @@ typedef struct {
 //   ...
 //     value of the entry to put
 //     variadic to make things like (struct Val){1,1} work properly
-#define mos_hm_put(hm, k, ...) (mos_hm_ini(hm), (hm)->val = __VA_ARGS__, (hm)->key = k, mos_hm_put_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR))
+#define mos_hm_put(hm, k, ...)                                                                     \
+    (mos_hm_ini(hm),                                                                               \
+     (hm)->val = __VA_ARGS__,                                                                      \
+     (hm)->key = k,                                                                                \
+     mos_hm_put_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR))
 
 // Put a given entry in the hashmap
 // If entry of the same key exists - overwrites it
@@ -216,7 +220,10 @@ typedef struct {
 //   ...
 //     entry to put into hashmap
 //     variadic to make things like (struct Entry){"key","val"} work properly
-#define mos_hm_put_e(hm, ...) (mos_hm_ini(hm), (hm)[0] = __VA_ARGS__, mos_hm_put_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR))
+#define mos_hm_put_e(hm, ...)                                                                      \
+    (mos_hm_ini(hm),                                                                               \
+     (hm)[0] = __VA_ARGS__,                                                                        \
+     mos_hm_put_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR))
 
 // Get the value of entry with specific key
 //
@@ -229,7 +236,8 @@ typedef struct {
 //
 // Returns:
 //   value of the entry with given key or 0 if no such entry exist
-#define mos_hm_get(hm, k) (mos_hm_ini(hm), (hm)->key = k, (hm)[mos_hm_get_fn(hm, mos_hm_fn_args(hm))].val)
+#define mos_hm_get(hm, k)                                                                          \
+    (mos_hm_ini(hm), (hm)->key = k, (hm)[mos_hm_get_fn(hm, mos_hm_fn_args(hm))].val)
 
 // Get a pointer to an entry with specific key in hashmap
 //
@@ -314,14 +322,20 @@ extern void mos_hm_init(void *p_hm, size_t entry_size);
 
 #define mos_hm_fn_args(hm) &(hm)->key, sizeof(*(hm)), sizeof((hm)->key)
 
-#define mos_hm_del_(hm, k, reh) (mos_hm_ini(hm), (hm)->key = k, mos_hm_del_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR, reh))
+#define mos_hm_del_(hm, k, reh)                                                                    \
+    (mos_hm_ini(hm),                                                                               \
+     (hm)->key = k,                                                                                \
+     mos_hm_del_fn(&(hm), mos_hm_fn_args(hm), MOS_HM_LOAD_FACTOR, reh))
 
 // Function prototypes for macros
 extern void *mos_hm_new_fn(MosHmNewArgs args);
-extern void mos_hm_put_fn(void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor);
+extern void
+mos_hm_put_fn(void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor);
 extern size_t mos_hm_get_fn(void *hm, void *key, size_t entry_size, size_t key_size);
 extern void *mos_hm_get_e_fn(void *hm, void *key, size_t entry_size, size_t key_size);
-extern int mos_hm_del_fn(void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor, int reh);
+extern int mos_hm_del_fn(
+    void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor, int reh
+);
 extern void *mos_hm_first_fn(const void *hm, size_t entry_size);
 extern void *mos_hm_next_fn(const void *hm, const void *curr, size_t entry_size);
 
diff --git a/include/moslib/string.h b/include/moslib/string.h
index 165bdf7..65a38c5 100644
--- a/include/moslib/string.h
+++ b/include/moslib/string.h
@@ -1,8 +1,8 @@
 // moslib/string.h
 // Length aware string slices
 
-// ======================================== QUICK USAGE GUIDE =========================================
-// ----------------------------------------------------------------------------------------------------
+// ======================================= QUICK USAGE GUIDE =======================================
+// -------------------------------------------------------------------------------------------------
 //
 // StringSlice is defined as a struct which contains a pointer to the beginning of a string and its
 // length:
@@ -12,7 +12,7 @@
 //          size_t len;
 //      } StringSlice;
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To get a string slice from a C string you can use:
 //
@@ -45,7 +45,7 @@
 //
 //      StringSlice ss = ss_from_vars("[in][out]", 4);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To print a slice you can either use:
 //
@@ -57,14 +57,14 @@
 //
 //      printf("Slice: " SS_FMT "\n", SS_ARGS(ss));
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To check if two slices / slice and string are equal, use:
 //
 //      int are_eq = ss_eq(ss1, ss2);
 //      int are_eq = ss_eq_str(ss1, "string");
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // You can trim a slice from whitespace using:
 //
@@ -72,7 +72,7 @@
 //      StringSlice trimmed_l = ss_trim_left(ss);
 //      StringSlice trimmed_r = ss_trim_right(ss);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To check whether a slice starts or ends with a slice / string, you can use:
 //
@@ -81,7 +81,7 @@
 //      int flag = ss_starts_with_str(ss, str_prefix);
 //      int flag = ss_ends_with_str(ss, str_suffix);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To delete from the left or the right, use:
 //
@@ -100,7 +100,7 @@
 // It will return whether or not the slice started / ended with the prefix / suffix and delete it if
 // it did.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // You can split a slice by a delimiter using ss_split functions:
 //
@@ -123,27 +123,27 @@
 //
 // It will return the "split" part and leave the remainder in the argument slice.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // To find within a slice a part which begins with given target, use:
 //
 //      StringSlice target1 = ss_find(ss, ss_target);
 //      StringSlice target2 = ss_find_str(ss, str_target);
 //
-// The return value is a slice that begins at the beginning of the specified target and ends at the end
-// of the original slice.
+// The return value is a slice that begins at the beginning of the specified target and ends
+// at the end of the original slice.
 // If the target was an emptry slice / string - returns the entire slice.
 // If the target was not found - returns empty slice.
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // If you want to get length of a slice then you can simply use the len field of the struct.
 // However, if you want to know the length which respects utf-8 encoding, use:
 //
 //      size_t utf8_len = ss_utf8_len(ss);
 //
-// ----------------------------------------------------------------------------------------------------
-// ===================================== END OF QUICK USAGE GUIDE =====================================
+// -------------------------------------------------------------------------------------------------
+// =================================== END OF QUICK USAGE GUIDE ====================================
 
 #include <stddef.h>
 
diff --git a/include/moslib/tester.h b/include/moslib/tester.h
index f8cc8b1..9f3b482 100644
--- a/include/moslib/tester.h
+++ b/include/moslib/tester.h
@@ -1,8 +1,8 @@
 // moslib/tester.h
 // Helper functions for writing and running tests
 
-// ======================================== QUICK USAGE GUIDE =========================================
-// ----------------------------------------------------------------------------------------------------
+// ======================================= QUICK USAGE GUIDE =======================================
+// -------------------------------------------------------------------------------------------------
 //
 // Define the tester:
 //
@@ -14,13 +14,13 @@
 //
 //      Tester *tester = new_tester();
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Add test groups:
 //
 //      TestGroup *test_group = add_test_group(tester, group_name);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Create tests.
 // They should use test_assert functions to check correctness.
@@ -67,26 +67,26 @@
 //          test_assert(code == 0, "function didn't fail");
 //      }
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Add tests to test group:
 //
 //      add_test(test_group, test_fn);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Run tests:
 //
 //      int all_passed = run_tests(tester);
 //
-// ----------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 // Free tester:
 //
 //      free_tester(tester);
 //
-// ----------------------------------------------------------------------------------------------------
-// ===================================== END OF QUICK USAGE GUIDE =====================================
+// -------------------------------------------------------------------------------------------------
+// =================================== END OF QUICK USAGE GUIDE ====================================
 
 #include <stdio.h>
 
@@ -137,7 +137,8 @@ extern MosTester *mos_new_tester(void);
 //
 // Returns:
 //   pointer to the added group
-#define mos_add_test_group(tester, group_name) ((!(tester) ? (tester) = mos_new_tester() : 0), mos_add_test_group_fn(tester, group_name))
+#define mos_add_test_group(tester, group_name)                                                     \
+    ((!(tester) ? (tester) = mos_new_tester() : 0), mos_add_test_group_fn(tester, group_name))
 
 // Assert that an expression is true
 // Use in test functions to test correctness
@@ -159,7 +160,7 @@ extern void mos_test_assert(int expression, const char *fail_message);
 //
 //   code
 //     expected exit code
-#define mos_test_assert_exit(function, code) mos_test_assert_exit_fn(function, code, #function);
+#define mos_test_assert_exit(function, code) mos_test_assert_exit_fn(function, code, #function)
 
 // Assert that function writes correct output to specified stream
 //
@@ -172,7 +173,8 @@ extern void mos_test_assert(int expression, const char *fail_message);
 //
 //   output
 //     expected output of the function
-#define mos_test_assert_out(function, stream, output) mos_test_assert_out_fn(function, stream, output, #function, #stream);
+#define mos_test_assert_out(function, stream, output)                                              \
+    mos_test_assert_out_fn(function, stream, output, #function, #stream)
 
 // Suppress given output
 //
@@ -193,7 +195,7 @@ extern void mos_unsuppress_outputs(void);
 //
 //   test
 //     test to add to the group
-#define mos_add_test(group, test) mos_add_test_fn(group, test, #test);
+#define mos_add_test(group, test) mos_add_test_fn(group, test, #test)
 
 // Run defined tests
 //
@@ -215,7 +217,13 @@ extern void mos_free_tester(MosTester *tester);
 // Function prototypes for macros
 extern MosTestGroup *mos_add_test_group_fn(MosTester *tester, const char *group_name);
 extern void mos_test_assert_exit_fn(MosTestFn function, int code, const char *name);
-extern void mos_test_assert_out_fn(MosTestFn function, FILE *stream, const char *output, const char *fn_name, const char *stream_name);
+extern void mos_test_assert_out_fn(
+    MosTestFn function,
+    FILE *stream,
+    const char *output,
+    const char *fn_name,
+    const char *stream_name
+);
 extern void mos_add_test_fn(MosTestGroup *group, MosTestFn test, const char *name);
 
 #endif // MOSLIB_TESTER_H
diff --git a/src/ds/array.c b/src/ds/array.c
index 3d0baa3..21d8be5 100644
--- a/src/ds/array.c
+++ b/src/ds/array.c
@@ -41,15 +41,13 @@ static void *expand(void *arr, size_t min_cap, size_t el_size) {
     return hdr2arr(hdr);
 }
 
-// clang-format off
 // init array if it's not, define arr, hdr vars and expand to fit min_cap
-#define ini(min_cap)                                                    \
-    !*(void**)p_arr ? *(void **)p_arr = init(init_cap, el_size) : 0;    \
-    Header *hdr = arr2hdr(*(void**)p_arr);                              \
-    *(void **)p_arr = expand(*(void**)p_arr, min_cap, el_size);         \
-    void *arr = *(void **)p_arr;                                        \
+#define ini(min_cap)                                                                               \
+    !*(void **)p_arr ? *(void **)p_arr = init(init_cap, el_size) : 0;                              \
+    Header *hdr = arr2hdr(*(void **)p_arr);                                                        \
+    *(void **)p_arr = expand(*(void **)p_arr, min_cap, el_size);                                   \
+    void *arr = *(void **)p_arr;                                                                   \
     hdr = arr2hdr(arr)
-// clang-format on
 
 void mos_arr_append_fn(void *p_arr, size_t el_size, size_t init_cap) {
     ini(hdr->len + 1);
@@ -70,7 +68,8 @@ void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap) {
     }
 }
 
-size_t mos_arr_append_n_fn(void *p_arr, const void *items, size_t n, size_t el_size, size_t init_cap) {
+size_t
+mos_arr_append_n_fn(void *p_arr, const void *items, size_t n, size_t el_size, size_t init_cap) {
     ini(hdr->len + n);
     size_t i = hdr->len;
 
@@ -79,7 +78,9 @@ size_t mos_arr_append_n_fn(void *p_arr, const void *items, size_t n, size_t el_s
     return i;
 }
 
-size_t mos_arr_insert_n_fn(void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap) {
+size_t mos_arr_insert_n_fn(
+    void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap
+) {
     ini(hdr->len + n);
     if (i >= hdr->len)
         return mos_arr_append_n_fn(p_arr, items, n, el_size, init_cap);
@@ -90,7 +91,9 @@ size_t mos_arr_insert_n_fn(void *p_arr, size_t i, const void *items, size_t n, s
     return i;
 }
 
-size_t mos_arr_put_n_fn(void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap) {
+size_t mos_arr_put_n_fn(
+    void *p_arr, size_t i, const void *items, size_t n, size_t el_size, size_t init_cap
+) {
     ini(i + n + 1);
     if (i > hdr->len) {
         memset((char *)arr + hdr->len * el_size, 0, (i - hdr->len) * el_size);
@@ -123,7 +126,9 @@ size_t mos_arr_del_n_fn(void *arr, size_t i, size_t n, size_t el_size) {
         return 0;
 
     size_t new_n = n > hdr->len - i ? hdr->len - i : n;
-    memmove((char *)arr + i * el_size, (char *)arr + (i + new_n) * el_size, (hdr->len - i) * el_size);
+    memmove(
+        (char *)arr + i * el_size, (char *)arr + (i + new_n) * el_size, (hdr->len - i) * el_size
+    );
     hdr->len -= new_n;
     return new_n;
 }
diff --git a/src/ds/hashmap.c b/src/ds/hashmap.c
index 2b74b35..a983fc2 100644
--- a/src/ds/hashmap.c
+++ b/src/ds/hashmap.c
@@ -139,7 +139,9 @@ void *mos_hm_new_fn(MosHmNewArgs args) {
     return hdr2hm(hdr);
 }
 
-static size_t probe(const void *hm, const void *key, size_t entry_size, size_t key_size, size_t key_off, int put) {
+static size_t probe(
+    const void *hm, const void *key, size_t entry_size, size_t key_size, size_t key_off, int put
+) {
     Header *hdr = hm2hdr(hm);
     uint32_t hash = hdr->hash ? hdr->hash(key) : default_hash(key, key_size);
     size_t i = hash % hdr->cap;
@@ -161,7 +163,8 @@ static size_t probe(const void *hm, const void *key, size_t entry_size, size_t k
     exit(EXIT_FAILURE);
 }
 
-static void rehash(void *p_hm, size_t entry_size, size_t key_size, size_t key_off, uint8_t load_factor) {
+static void
+rehash(void *p_hm, size_t entry_size, size_t key_size, size_t key_off, uint8_t load_factor) {
     void *hm = *(void **)p_hm;
     Header *hdr = hm2hdr(hm);
     size_t size = mos_hm_size(hm);
@@ -243,7 +246,9 @@ void *mos_hm_get_e_fn(void *hm, void *key, size_t entry_size, size_t key_size) {
     return (char *)hm + (i + 1) * entry_size;
 }
 
-int mos_hm_del_fn(void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor, int reh) {
+int mos_hm_del_fn(
+    void *p_hm, void *key, size_t entry_size, size_t key_size, uint8_t load_factor, int reh
+) {
     void *hm = *(void **)p_hm;
     Header *hdr = hm2hdr(hm);
     size_t key_off = (char *)key - (char *)hm;
diff --git a/src/tester.c b/src/tester.c
index b36a4d2..42f0486 100644
--- a/src/tester.c
+++ b/src/tester.c
@@ -130,7 +130,13 @@ void mos_test_assert_exit_fn(MosTestFn function, int code, const char *name) {
     }
 }
 
-void mos_test_assert_out_fn(MosTestFn function, FILE *stream, const char *output, const char *fn_name, const char *stream_name) {
+void mos_test_assert_out_fn(
+    MosTestFn function,
+    FILE *stream,
+    const char *output,
+    const char *fn_name,
+    const char *stream_name
+) {
     size_t n = strlen(output);
     char *out = mos_safe_calloc(n + 2, 1);
 
diff --git a/tests/ds/array_tests.c b/tests/ds/array_tests.c
index c5d7c4d..975443c 100644
--- a/tests/ds/array_tests.c
+++ b/tests/ds/array_tests.c
@@ -16,10 +16,16 @@ TEST(cap_test) {
     test_assert(arr_cap(arr) == 2 * MOS_ARR_INIT_CAP, "capacity didn't increase 2 times");
 
     size_t new_cap = arr_set_cap(arr, 3 * MOS_ARR_INIT_CAP);
-    test_assert(new_cap == arr_cap(arr) && new_cap == 3 * MOS_ARR_INIT_CAP, "set cap didn't set correct capacity (cap >= len)");
+    test_assert(
+        new_cap == arr_cap(arr) && new_cap == 3 * MOS_ARR_INIT_CAP,
+        "set cap didn't set correct capacity (cap >= len)"
+    );
 
     new_cap = arr_set_cap(arr, 0);
-    test_assert(new_cap == arr_cap(arr) && new_cap == MOS_ARR_INIT_CAP + 1, "set cap didn't set correct capacity (cap < len)");
+    test_assert(
+        new_cap == arr_cap(arr) && new_cap == MOS_ARR_INIT_CAP + 1,
+        "set cap didn't set correct capacity (cap < len)"
+    );
 
     arr_free(arr);
 }
@@ -95,10 +101,14 @@ TEST(getting_items) {
     test_assert(arr_last(arr) == NULL, "last of empty array isn't null");
 
     arr_append(arr, (struct test){0});
-    test_assert(arr_first(arr) == arr_last(arr), "first and last are different for array of length 1");
+    test_assert(
+        arr_first(arr) == arr_last(arr), "first and last are different for array of length 1"
+    );
 
     arr_append(arr, (struct test){1, 1});
-    test_assert(arr_first(arr) != arr_last(arr), "first and last are the same for array of length >1");
+    test_assert(
+        arr_first(arr) != arr_last(arr), "first and last are the same for array of length >1"
+    );
 
     struct test *next_first = arr_next(arr, NULL);
     struct test *next_last = arr_next(arr, next_first);
@@ -108,15 +118,24 @@ TEST(getting_items) {
     struct test *prev_null = arr_prev(arr, prev_first);
     test_assert(next_first && next_last, "next gave NULL when it shouldn't have");
     test_assert(prev_first && prev_last, "prev gave NULL when it shouldn't have");
-    test_assert(next_first == prev_first && next_last == prev_last, "next and prev gave different values for the same element");
+    test_assert(
+        next_first == prev_first && next_last == prev_last,
+        "next and prev gave different values for the same element"
+    );
     test_assert(!next_null, "next didn't give NULL after running out of items");
     test_assert(!prev_null, "prev didn't give NULL after running out of items");
 
-    test_assert(arr_get(arr, -1) == NULL && arr_get(arr, 2) == NULL, "arr_get didn't give NULL when out of bounds");
+    test_assert(
+        arr_get(arr, -1) == NULL && arr_get(arr, 2) == NULL,
+        "arr_get didn't give NULL when out of bounds"
+    );
 
     struct test i0 = *arr_get(arr, 0);
     struct test i1 = *arr_get(arr, 1);
-    test_assert(!memcmp(&i0, &arr[0], sizeof(struct test)) && !memcmp(&i1, &arr[1], sizeof(struct test)), "arr_get(arr, i) gives different result than arr[i]");
+    test_assert(
+        !memcmp(&i0, &arr[0], sizeof(struct test)) && !memcmp(&i1, &arr[1], sizeof(struct test)),
+        "arr_get(arr, i) gives different result than arr[i]"
+    );
 
     arr_free(arr);
 }
@@ -176,7 +195,9 @@ TEST(arr_concat_test) {
     test_assert(index == 2, "arr_concat returned wrong index");
     unsigned long expected[] = {4, 5, 1, 2, 3, 4, 5};
     test_assert(arr_len(arr2) == 7, "arr_concat produced array of wrong length");
-    test_assert(!memcmp(arr2, expected, 7 * sizeof(unsigned long)), "arr_concat produced wrong array");
+    test_assert(
+        !memcmp(arr2, expected, 7 * sizeof(unsigned long)), "arr_concat produced wrong array"
+    );
 
     arr_free(arr1);
     arr_free(arr2);
diff --git a/tests/ds/hashmap_tests.c b/tests/ds/hashmap_tests.c
index 4c615a7..268bc29 100644
--- a/tests/ds/hashmap_tests.c
+++ b/tests/ds/hashmap_tests.c
@@ -45,13 +45,19 @@ TEST(put_e_get_e) {
     hm_put_e(hm, (E){0.0f, 69});
     hm_put_e(hm, (E){1.0f, 420});
     E e = {0.0f, 69};
-    test_assert(memcmp(&e, hm_get_e(hm, 0.0f), sizeof(E)) == 0, "hm_get_e got entry not from hm_put_e");
+    test_assert(
+        memcmp(&e, hm_get_e(hm, 0.0f), sizeof(E)) == 0, "hm_get_e got entry not from hm_put_e"
+    );
     e = (E){1.0f, 420};
-    test_assert(memcmp(&e, hm_get_e(hm, 1.0f), sizeof(E)) == 0, "hm_get_e got entry not from hm_put_e");
+    test_assert(
+        memcmp(&e, hm_get_e(hm, 1.0f), sizeof(E)) == 0, "hm_get_e got entry not from hm_put_e"
+    );
 
     e = (E){1.0f, 2137};
     hm_put_e(hm, e);
-    test_assert(memcmp(&e, hm_get_e(hm, 1.0f), sizeof(E)) == 0, "hm_put_e didn't update entry properly");
+    test_assert(
+        memcmp(&e, hm_get_e(hm, 1.0f), sizeof(E)) == 0, "hm_put_e didn't update entry properly"
+    );
 
     hm_free(hm);
 }
@@ -137,7 +143,9 @@ TEST(looping) {
     E items[] = {{1, 10}, {2, 20}, {3, 30}};
     arr_append_n(allowed, items, 3);
 
-    test_assert(memcmp(hm_first(hm), hm_next(hm, NULL), sizeof(E)) == 0, "hm_next(hm, NULL) != hm_first(hm)");
+    test_assert(
+        memcmp(hm_first(hm), hm_next(hm, NULL), sizeof(E)) == 0, "hm_next(hm, NULL) != hm_first(hm)"
+    );
     E *e = NULL;
     while ((e = hm_next(hm, e))) {
         int flag = 0;
@@ -150,7 +158,10 @@ TEST(looping) {
         }
         test_assert(flag, "hm_next produced an entry that wasn't put in the hashmap");
     }
-    test_assert(arr_len(allowed) == 0, "hm_next didn't produce every entry from hashmap when it looped over it");
+    test_assert(
+        arr_len(allowed) == 0,
+        "hm_next didn't produce every entry from hashmap when it looped over it"
+    );
 
     arr_free(allowed);
     hm_free(hm);
diff --git a/tests/string_tests.c b/tests/string_tests.c
index 0d0d7e2..f600400 100644
--- a/tests/string_tests.c
+++ b/tests/string_tests.c
@@ -26,7 +26,9 @@ TEST(creating) {
     test_assert(ss3.data == str && ss3.len == str_len, "ss_from_vars created wrong slice");
 
     StringSlice ss4 = SS_LIT(HELLO_WORLD_LIT);
-    test_assert(ss4.data == str && ss4.len == sizeof(HELLO_WORLD_LIT) - 1, "SS_LIT created wrong slice");
+    test_assert(
+        ss4.data == str && ss4.len == sizeof(HELLO_WORLD_LIT) - 1, "SS_LIT created wrong slice"
+    );
 
     StringSlice ss5 = ss_copy(ss1);
     test_assert(ss5.data == ss1.data && ss5.len == ss1.len, "ss_from_arr created wrong slice");
@@ -58,11 +60,15 @@ TEST(comparing) {
     free(hw);
 
     StringSlice ss3 = ss_from_vars(ss.data, ss.len - 1);
-    test_assert(ss_eq(ss, ss3) == 0, "slice is equal when the pointer is the same but length differs");
+    test_assert(
+        ss_eq(ss, ss3) == 0, "slice is equal when the pointer is the same but length differs"
+    );
 
     StringSlice ss4 = ss_from_str("hello");
     StringSlice ss5 = ss_from_str("world");
-    test_assert(ss_eq(ss4, ss5) == 0, "slice is equal when the length is the same but pointer differs");
+    test_assert(
+        ss_eq(ss4, ss5) == 0, "slice is equal when the length is the same but pointer differs"
+    );
     test_assert(ss_eq_str(ss4, "world") == 0, "slice is equal to different string");
 }
 
@@ -86,7 +92,9 @@ TEST(trimming) {
 TEST(prefix_suffix) {
     StringSlice ss = ss_from_str("pre mid suf");
 
-    test_assert(ss_starts_with(ss, ss_from_str("pre")), "slice doesn't start with its slice prefix");
+    test_assert(
+        ss_starts_with(ss, ss_from_str("pre")), "slice doesn't start with its slice prefix"
+    );
     test_assert(ss_starts_with(ss, ss_from_str("suf")) == 0, "slice starts with not slice prefix");
 
     test_assert(ss_ends_with(ss, ss_from_str("suf")), "slice doesn't end with its slice suffix");
@@ -99,7 +107,9 @@ TEST(prefix_suffix) {
     test_assert(ss_ends_with_str(ss, "pre") == 0, "slice ends with not string suffix");
 
     StringSlice ss2 = ss_from_str("");
-    test_assert(ss_starts_with(ss2, ss_from_str("")), "starts_with breaks for empty slice and prefix");
+    test_assert(
+        ss_starts_with(ss2, ss_from_str("")), "starts_with breaks for empty slice and prefix"
+    );
     test_assert(ss_ends_with(ss2, ss_from_str("")), "ends_with breaks for empty slice and suffix");
 }
 
@@ -151,7 +161,9 @@ TEST(splitting) {
     StringSlice ss1 = ss_from_str("Hello, World!");
 
     StringSlice ss2 = ss_split(&ss1, ',');
-    test_assert(ss_eq_str(ss2, "Hello") && ss_eq_str(ss1, " World!"), "ss_split didn't split proprely");
+    test_assert(
+        ss_eq_str(ss2, "Hello") && ss_eq_str(ss1, " World!"), "ss_split didn't split proprely"
+    );
 
     StringSlice ss3 = ss_split_str(&ss2, "ll");
     test_assert(ss_eq_str(ss3, "He") && ss_eq_str(ss2, "o"), "ss_split_str didn't split proprely");
@@ -162,47 +174,85 @@ TEST(splitting) {
     ss1 = ss_from_str("hiii");
 
     ss2 = ss_split_str(&ss1, "");
-    test_assert(ss_eq_str(ss2, "") && ss_eq_str(ss1, "hiii"), "ss_split_str fails empty str edge case");
+    test_assert(
+        ss_eq_str(ss2, "") && ss_eq_str(ss1, "hiii"), "ss_split_str fails empty str edge case"
+    );
 
     ss2 = ss_split_ss(&ss1, SS_LIT(""));
-    test_assert(ss_eq_str(ss2, "") && ss_eq_str(ss1, "hiii"), "ss_split_ss fails empty ss edge case");
+    test_assert(
+        ss_eq_str(ss2, "") && ss_eq_str(ss1, "hiii"), "ss_split_ss fails empty ss edge case"
+    );
 
     ss2 = ss_split(&ss1, '.');
-    test_assert(ss_eq_str(ss2, "hiii") && ss_eq_str(ss1, ""), "ss_split fails not found delim edge case");
+    test_assert(
+        ss_eq_str(ss2, "hiii") && ss_eq_str(ss1, ""), "ss_split fails not found delim edge case"
+    );
 
     ss1 = ss_split_str(&ss2, "..");
-    test_assert(ss_eq_str(ss1, "hiii") && ss_eq_str(ss2, ""), "ss_split_str fails not found delim edge case");
+    test_assert(
+        ss_eq_str(ss1, "hiii") && ss_eq_str(ss2, ""), "ss_split_str fails not found delim edge case"
+    );
 
     ss2 = ss_split_ss(&ss1, SS_LIT("..."));
-    test_assert(ss_eq_str(ss2, "hiii") && ss_eq_str(ss1, ""), "ss_split_ss fails not found delim edge case");
+    test_assert(
+        ss_eq_str(ss2, "hiii") && ss_eq_str(ss1, ""), "ss_split_ss fails not found delim edge case"
+    );
 
     StringSlice ss_middle = ss_from_str("[left][middle][right]");
 
     StringSlice ss_left = ss_split_left(&ss_middle, 6);
-    test_assert(ss_eq_str(ss_left, "[left]") && ss_eq_str(ss_middle, "[middle][right]"), "ss_split_left didn't split properly");
+    test_assert(
+        ss_eq_str(ss_left, "[left]") && ss_eq_str(ss_middle, "[middle][right]"),
+        "ss_split_left didn't split properly"
+    );
 
     StringSlice ss_right = ss_split_right(&ss_middle, 7);
-    test_assert(ss_eq_str(ss_right, "[right]") && ss_eq_str(ss_middle, "[middle]"), "ss_split_right didn't split properly");
+    test_assert(
+        ss_eq_str(ss_right, "[right]") && ss_eq_str(ss_middle, "[middle]"),
+        "ss_split_right didn't split properly"
+    );
 
     ss_left = ss_split_left(&ss_middle, 20);
-    test_assert(ss_eq_str(ss_left, "[middle]") && ss_eq_str(ss_middle, ""), "ss_split_left didn't split properly (n > len)");
+    test_assert(
+        ss_eq_str(ss_left, "[middle]") && ss_eq_str(ss_middle, ""),
+        "ss_split_left didn't split properly (n > len)"
+    );
 
     ss_right = ss_split_right(&ss_middle, 500);
-    test_assert(ss_eq_str(ss_right, "") && ss_eq_str(ss_middle, ""), "ss_split_right didn't split properly (n > len)");
+    test_assert(
+        ss_eq_str(ss_right, "") && ss_eq_str(ss_middle, ""),
+        "ss_split_right didn't split properly (n > len)"
+    );
 }
 
 TEST(finding) {
     char *txt = "a slice of FINDME text";
     StringSlice ss = ss_from_str(txt);
 
-    test_assert(ss_eq_str(ss_find(ss, ss_from_str("FINDME")), "FINDME text"), "find didn't find a part of the slice");
-    test_assert(ss_eq_str(ss_find_str(ss, "FINDME"), "FINDME text"), "find_str didn't find a part of the slice");
-
-    test_assert(ss_eq(ss_find(ss, ss_from_str("")), ss), "find didn't return whole slice for empty target");
-    test_assert(ss_eq(ss_find_str(ss, ""), ss), "find_str didn't return whole slice for empty target");
-
-    test_assert(ss_eq_str(ss_find(ss, ss_from_str("abcd")), ""), "find didn't return empty slice for not found target");
-    test_assert(ss_eq_str(ss_find_str(ss, "abcd"), ""), "find_str didn't return empty slice for not found target");
+    test_assert(
+        ss_eq_str(ss_find(ss, ss_from_str("FINDME")), "FINDME text"),
+        "find didn't find a part of the slice"
+    );
+    test_assert(
+        ss_eq_str(ss_find_str(ss, "FINDME"), "FINDME text"),
+        "find_str didn't find a part of the slice"
+    );
+
+    test_assert(
+        ss_eq(ss_find(ss, ss_from_str("")), ss), "find didn't return whole slice for empty target"
+    );
+    test_assert(
+        ss_eq(ss_find_str(ss, ""), ss), "find_str didn't return whole slice for empty target"
+    );
+
+    test_assert(
+        ss_eq_str(ss_find(ss, ss_from_str("abcd")), ""),
+        "find didn't return empty slice for not found target"
+    );
+    test_assert(
+        ss_eq_str(ss_find_str(ss, "abcd"), ""),
+        "find_str didn't return empty slice for not found target"
+    );
 }
 
 TEST(utf8_len_test) {