Update .gitea/workflows/run_tests.yaml

.gitea/workflows/run_tests.yaml

@@ -13,25 +13,12 @@ jobs:
       - uses: actions/checkout@v4
       - name: Configure
         run: meson setup build
-        # run: meson setup -Db_coverage=true build
+      - name: Run tests
-
-      - name: Run Tests
         run: meson test -C build
 
-      - name: Run Memory Tests
+      - name: Upload Meson Logs
         if: always()
-        run: meson test -C build --wrapper=valgrind
+        uses: christopherHX/gitea-upload-artifact@v4
-
-      # - name: Generate coverage report
-      #   if: always()
-      #   run: ninja coverage-html -C build
-
-      - name: Upload Logs
-        if: always()
-        uses: https://git.neosisyphus.com/mo7sen/upload-artifact-gitea@v7
         with:
-          path: |
+          name: meson-logs
-            build/meson-logs/meson-log.txt
+          path: build/meson-logs/
-            build/meson-logs/meson-setup.txt
-            build/meson-logs/testlog.txt
-          archive: false

build_options/meson-clang-linux

@@ -1,11 +1,11 @@
 [binaries]
-c = 'clang-19'
+c = 'clang-22'
-c_ld = 'lld-19'
+c_ld = 'lld-22'
-cpp = 'clang++-19'
+cpp = 'clang++-22'
-cpp_ld = 'lld-19'
+cpp_ld = 'lld-22'
 
 [properties]
 c_args = ['-DEV_CC_CLANG=1','-fcolor-diagnostics', '-fansi-escape-codes']
 
 [cmake]
-CMAKE_C_COMPILER = 'clang-19'
+CMAKE_C_COMPILER = 'clang-22'

ev_hash.h

@@ -6,7 +6,7 @@
 /*!
  * \brief MurmurHash3 64-bit version. Returns 64-bit hash instead of 128
  */
-u64 ev_hash_murmur3(const void *data, u32 len, u32 seed);
+u64 ev_hash_murmur3(const void *data, u32 len, u64 seed);
 
 #ifdef EV_HASH_IMPLEMENTATION
 #undef EV_HASH_IMPLEMENTATION
@@ -151,7 +151,7 @@ void MurmurHash3_x64_128 ( const void * key, const u32 len,
 
 //-----------------------------------------------------------------------------
 
-u64 ev_hash_murmur3(const void *data, u32 len, u32 seed)
+u64 ev_hash_murmur3(const void *data, u32 len, u64 seed)
 {
   u64 out[2];
   MurmurHash3_x64_128(data, len, (u32)seed, out);

ev_internal.h

@@ -1,17 +1,15 @@
 #ifndef EV_HEADERS_INTERNAL_H
 #define EV_HEADERS_INTERNAL_H
 
-#include <stdint.h>
+typedef signed char   i8;
+typedef short int     i16;
+typedef int           i32;
+typedef long long int i64;
 
-typedef int8_t  i8;
+typedef unsigned char          u8;
-typedef int16_t i16;
+typedef unsigned short int     u16;
-typedef int32_t i32;
+typedef unsigned int           u32;
-typedef int64_t i64;
+typedef unsigned long long int u64;
-
-typedef uint8_t  u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
 
 typedef float  f32;
 typedef double f64;

ev_numeric.h

@@ -5,20 +5,20 @@
 #include "ev_types.h"
 
 // Signed integers
-TYPEDATA_GEN(i8)
+TYPEDATA_GEN(i8);
-TYPEDATA_GEN(i16)
+TYPEDATA_GEN(i16);
-TYPEDATA_GEN(i32)
+TYPEDATA_GEN(i32);
-TYPEDATA_GEN(i64)
+TYPEDATA_GEN(i64);
 
 // Unsigned integers
-TYPEDATA_GEN(u8 )
+TYPEDATA_GEN(u8 );
-TYPEDATA_GEN(u16)
+TYPEDATA_GEN(u16);
-TYPEDATA_GEN(u32)
+TYPEDATA_GEN(u32);
-TYPEDATA_GEN(u64)
+TYPEDATA_GEN(u64);
 
 // Floating-Point Numbers
-TYPEDATA_GEN(f32)
+TYPEDATA_GEN(f32);
-TYPEDATA_GEN(f64)
+TYPEDATA_GEN(f64);
 
 struct Int8Data  { i8  MIN; i8  MAX; };
 struct Int16Data { i16 MIN; i16 MAX; };

ev_str.h

@@ -43,25 +43,18 @@
 #define EV_STR_GROWTH_FACTOR 3 / 2
 #endif
 
-#ifndef EV_STR_MIN_CAPACITY
-/*!
- * \brief Rate at which an evstring grows whenever a resize is needed
- */
-#define EV_STR_MIN_CAPACITY 4
-#endif
-
 typedef char *evstring;
 
 typedef enum {
     EV_STR_ERR_NONE = 0,
     EV_STR_ERR_OOM = -1,
 } evstring_error_t;
-TYPEDATA_GEN(evstring_error_t, DEFAULT(EV_STR_ERR_NONE))
+TYPEDATA_GEN(evstring_error_t, DEFAULT(EV_STR_ERR_NONE));
 
 struct evstr_meta_t {
     EV_DEBUG(u64 magic;)
     u64 length;
-    u64 capacity;
+    u64 size;
     enum {
         EV_STR_ALLOCATION_TYPE_STACK,
         EV_STR_ALLOCATION_TYPE_HEAP
@@ -74,7 +67,7 @@ struct evstr_meta_t {
     (( struct { struct evstr_meta_t meta; char data[len]; } ) { \
         EV_DEBUG(.meta.magic = EV_STR_evstring_MAGIC,) \
         .meta.length = len-1, \
-        .meta.capacity = len, \
+        .meta.size = len, \
         .meta.allocationType = EV_STR_ALLOCATION_TYPE_STACK, \
         .data = str \
     }).data
@@ -127,11 +120,6 @@ evstring_cmp(
     const evstring s1,
     const evstring s2);
 
-EV_STR_API i32
-evstring_view_cmp(
-    const evstring_view v1,
-    const evstring_view v2);
-
 EV_STR_API evstring_error_t
 evstring_pushChar(
     evstring *s,
@@ -183,6 +171,11 @@ evstring_findFirst(
     const evstring text,
     const evstring query);
 
+evstring_view
+__evstring_findFirst_impl(
+    evstring_view text,
+    evstring_view query);
+
 EV_STR_API evstring
 evstring_replaceFirst(
     const evstring text,
@@ -218,16 +211,7 @@ TYPEDATA_GEN(evstring,
     EQUAL(Default),
     COPY(Default),
     FREE(Default)
-)
+);
-
-DEFINE_EQUAL_FUNCTION(evstring_view, Default)
-{
-  return evstring_view_cmp(*self, *other) == 0;
-}
-
-TYPEDATA_GEN(evstring_view,
-    EQUAL(Default),
-)
 
 
 #if defined(EV_STR_IMPLEMENTATION)
@@ -265,10 +249,9 @@ evstring_new_impl(
     const char *data,
     u64 len)
 {
-    u64 str_cap = len + 1;
+    u64 size = sizeof(struct evstr_meta_t) + len + 1;
-    u64 alloc_size = sizeof(struct evstr_meta_t) + str_cap;
 
-    void *p = ev_str_malloc(alloc_size);
+    void *p = ev_str_malloc(size);
     assert(p); // Raised if malloc fails
 
     struct evstr_meta_t *meta = (struct evstr_meta_t *)p;
@@ -277,7 +260,7 @@ EV_DEBUG
     meta->magic = EV_STR_evstring_MAGIC;
 )
     meta->length = len;
-    meta->capacity = str_cap;
+    meta->size = size;
     meta->allocationType = EV_STR_ALLOCATION_TYPE_HEAP;
 
     evstring s = (evstring)(meta + 1);
@@ -298,11 +281,10 @@ evstring_newFmt_v(
 {
     va_list test;
     va_copy(test, args);
-    i32 expected_len = vsnprintf(NULL, 0, fmt, test);
+    i32 len = vsnprintf(NULL, 0, fmt, test);
-    if(expected_len < 0) {
+    if(len < 0) {
         return EV_INVALID(evstring);
     }
-    size_t len = (size_t)expected_len; 
     evstring res = evstring_new_impl(NULL, 0);
     evstring_setLength(&res, len);
     vsnprintf(res, len + 1, fmt, args);
@@ -361,9 +343,9 @@ evstring_getLength(
 }
 
 evstring_error_t
-evstring_setCapacity(
+evstring_setSize(
     evstring *s,
-    size_t new_capacity)
+    size_t newsize)
 {
     evstr_asserttype(*s);
     struct evstr_meta_t *meta = META(*s);
@@ -371,12 +353,12 @@ evstring_setCapacity(
         return EV_STR_ERR_OOM;
     }
 
-    if(meta->capacity == new_capacity) {
+    if(meta->size == newsize) {
         return EV_STR_ERR_NONE;
     }
 
     void *buf = (void*)meta;
-    void *tmp = ev_str_realloc(buf, sizeof(struct evstr_meta_t) + new_capacity);
+    void *tmp = ev_str_realloc(buf, sizeof(struct evstr_meta_t) + newsize);
 
     if (!tmp) {
         return EV_STR_ERR_OOM;
@@ -388,7 +370,7 @@ evstring_setCapacity(
         *s = (evstring)(meta+1);
     }
 
-    meta->capacity = new_capacity;
+    meta->size = newsize;
     return EV_STR_ERR_NONE;
 }
 
@@ -397,8 +379,7 @@ evstring_grow(
     evstring *s)
 {
     evstr_asserttype(*s);
-    u64 new_cap = max(EV_STR_MIN_CAPACITY, META(*s)->capacity * EV_STR_GROWTH_FACTOR);
+    return evstring_setSize(s, META(*s)->size * EV_STR_GROWTH_FACTOR);
-    return evstring_setCapacity(s, new_cap);
 }
 
 evstring_error_t
@@ -412,8 +393,8 @@ evstring_setLength(
         return EV_STR_ERR_NONE;
     }
 
-    u64 required_capacity = newlen + 1;
+    u64 required_size = sizeof(struct evstr_meta_t) + newlen + 1;
-    while(required_capacity > meta->capacity) {
+    while(required_size > meta->size) {
         evstring_error_t grow_err = evstring_grow(s);
         if(grow_err) {
             return grow_err;
@@ -449,19 +430,6 @@ evstring_cmp(
     return memcmp(s1, s2, len1);
 }
 
-i32
-evstring_view_cmp(
-    const evstring_view v1,
-    const evstring_view v2)
-{
-    evstr_asserttype(v1.data);
-    evstr_asserttype(v2.data);
-    if(v1.len != v2.len) {
-        return 1;
-    }
-    return memcmp(v1.data+v1.offset, v2.data+v2.offset, v1.len);
-}
-
 
 evstring_error_t
 evstring_push_impl(
@@ -472,18 +440,9 @@ evstring_push_impl(
     evstr_asserttype(*s);
     struct evstr_meta_t *meta = META(*s);
 
-    // Overlapping ranges, need to copy `data` to keep it alive after growing
-    if(*s < data + sz && data < *s + meta->length)
-    {
-      char *old_data = data;
-      data = ev_str_malloc(sz);
-      if(data == NULL) return EV_STR_ERR_OOM;
-      memcpy(data, old_data, sz);
-    }
-
     // TODO Find a more efficient approach?
-    u64 required_capacity = meta->length + sz + 1;
+    u64 required_size = sizeof(struct evstr_meta_t) + meta->length + sz + 1;
-    while(required_capacity > meta->capacity) { // `<=` because of the null terminator
+    while(required_size > meta->size) { // `<=` because of the null terminator
         evstring_error_t grow_err = evstring_grow(s);
         if(grow_err != EV_STR_ERR_NONE) {
             return grow_err;
@@ -561,7 +520,7 @@ evstring_getSpace(
 {
     evstr_asserttype(s);
     struct evstr_meta_t *meta = META(s);
-    return meta->capacity - meta->length - 1;
+    return meta->size - meta->length - 1 - sizeof(struct evstr_meta_t);
 }
 
 evstring_error_t
@@ -570,34 +529,33 @@ evstring_addSpace(
     u64 space)
 {
     evstr_asserttype(*s);
-    return evstring_setCapacity(s, META(*s)->capacity + space);
+    return evstring_setSize(s, META(*s)->size + space);
 }
 
 evstring_view
-evstring_findFirst_impl(
+__evstring_findFirst_impl(
     evstring_view text,
     evstring_view query)
 {
+    u64 found_progress = 0;
+
     evstring_view result = {
         .data = text.data,
         .len = 0,
         .offset = ~0ull
     };
 
-    if(query.len == 0 || query.len > text.len)
+    for(u64 i = text.offset; i < text.offset + text.len; i++) {
-      return result;
+        if(text.data[i] == query.data[query.offset + found_progress])
-
+            found_progress++;
-    for(u64 l = text.offset; l <= text.offset + text.len - query.len; l++)
+        else
-    {
+            found_progress = 0;
-      evstring_view curr_view = {
+        if(found_progress == query.len) {
-        .data = text.data,
+            result.offset = (i+1) - query.len;
-        .len = query.len,
+            result.len = query.len;
-        .offset = l
+            break;
-      };
+        }
-      if(EV_EQUAL(evstring_view)(&curr_view, &query))
-        return curr_view;
     }
-
     return result;
 }
 
@@ -608,7 +566,7 @@ evstring_findFirst(
 {
     evstr_asserttype(text);
     evstr_asserttype(query);
-    return evstring_findFirst_impl(evstring_slice(text, 0, -1), evstring_slice(query, 0, -1));
+    return __evstring_findFirst_impl(evstring_slice(text, 0, -1), evstring_slice(query, 0, -1));
 }
 
 evstring
@@ -727,25 +685,18 @@ evstring_findAll(
     if(text_len == 0 || query_len == 0 || query_len > text_len) {
         return 0;
     }
-
+    bool check_run = (results == NULL);
-    evstring_view query_view = evstring_slice(query, 0, -1);
-
     u64 count = 0;
-
+    for(evstring_view v = evstring_findFirst(text, query); 
-    for(u64 l = 0; l <= text_len - query_len; l++)
+            v.len != 0; 
-    {
+            v = __evstring_findFirst_impl(
-        evstring_view curr_view = {
+                evstring_slice(text, v.offset + v.len, -1), 
-            .data = text,
+                evstring_slice(query, 0, -1))) {
-            .len = query_len,
+        if(!check_run) {
-            .offset = l
+            results[count] = v;
-        };
+        }
-        if(EV_EQUAL(evstring_view)(&curr_view, &query_view))
-        {
-            if(results) results[count] = curr_view;
         count++;
     }
-    }
-
     return count;
 }
 

ev_types.h

@@ -80,10 +80,9 @@ typedef struct {
 #define EV_OVERRIDE_VAR(T) EV_CAT(__ev_internal_override_var_,T)
 #define TypeData(T) EV_CAT(EV_TYPEDATA_,T)
 #define TYPEDATA_GEN(T, ...) \
-  EV_WARNING_PUSH() \
+  EV_WARNING_PUSH(); \
-  EV_WARNING_DISABLE_GCC("override-init") \
+  EV_WARNING_DISABLE_GCC("override-init"); \
-  EV_WARNING_DISABLE_CLANG("initializer-overrides") \
+  EV_WARNING_DISABLE_CLANG("initializer-overrides"); \
-  EV_WARNING_DISABLE_CLANG("reserved-identifier") \
   EV_UNUSED static const EvTypeData TypeData(T) = { \
     EV_DEBUG(.name = EV_STRINGIZE(T),) \
     .size = sizeof(T), \
@@ -92,8 +91,8 @@ typedef struct {
     .invalid_val = (void*)&(T){0}, \
     EV_VA_OPT(__VA_ARGS__)(EV_FOREACH_UDATA(__EV_STRUCT_METHOD_DEF, T, __VA_ARGS__)) \
   }; \
-  EV_UNUSED static T EV_OVERRIDE_VAR(T); \
+  EV_WARNING_POP(); \
-  EV_WARNING_POP()
+  EV_UNUSED static T EV_OVERRIDE_VAR(T)
 
 #define __EV_STRUCT_METHOD_DEF(T, ...) EV_CAT(EV_CAT(__EV_,EV_HEAD __VA_ARGS__),_FN)(T, EV_TAIL __VA_ARGS__)
 
@@ -153,6 +152,6 @@ DEFINE_TOSTR_FUNCTION(EvTypeData, EvTypeDataStringize)
 }
 
 TYPEDATA_GEN(EvTypeData,
-    TOSTR(EvTypeDataStringize))
+    TOSTR(EvTypeDataStringize));
 
 #endif // EV_HEADERS_TYPES_H

ev_vec.h

@@ -6,7 +6,7 @@
 #include "ev_types.h"
 #include "ev_numeric.h"
 
-#if !EV_CC_MSVC
+#if !EV_OS_WINDOWS
 #include <string.h>
 #endif
 
@@ -34,14 +34,6 @@
 #define EV_VEC_GROWTH_RATE 3 / 2
 #endif
 
-
-#ifndef EV_VEC_MIN_CAPACITY 
-/*!
- * \brief Minimum capacity used by vector when growing
- */
-#define EV_VEC_MIN_CAPACITY 4
-#endif
-
 #if EV_CC_MSVC
 # define __EV_VEC_EMPTY_ARRAY { 0 }
 #else
@@ -186,8 +178,8 @@ static struct ev_vec_meta_t *__svec_interm_md;
  * *Note* This is possibly replaceable with a variadic function.
  */
 #define ev_vec_push(v, ...) \
-  EV_FOREACH_UDATA(__ev_vec_internal_push, v, __VA_ARGS__)
+  EV_FOREACH_UDATA(__ev_vec_internal_push, v, __VA_ARGS__);
-#define __ev_vec_internal_push(v, var) ev_vec_push_impl((ev_vec_t*)v, var)
+#define __ev_vec_internal_push(v, var) ev_vec_push_impl((ev_vec_t*)v, var);
 
 /*!
  * \param vec_p A pointer to the vector that we want an iterator for
@@ -312,10 +304,6 @@ ev_vec_dup(
  * vector, then this function is used. Otherwise, memcpy is used with a length 
  * of `vec_meta.elemsize`
  *
- * \warning Having a free_fn defined for the elemtype but no copy_fn could have some
- * unwanted side effects as the free function will be called on the popped element
- * after copying it to `out`
- *
  * \param vec_p Reference to the vector object
  * \param out A pointer to the memory block at which the popped element will be
  * copied. If NULL is passed, then the element is destructed. Otherwise, the
@@ -655,18 +643,19 @@ ev_vec_pop(
 
   if(metadata->length == 0) return EV_VEC_ERR_INVALID_OP;
 
-  void *elem = ((char *)*v) + ((metadata->length-1) * metadata->typeData.size);
   if(out != NULL) {
+    void *src = ((char *)*v) + ((metadata->length-1) * metadata->typeData.size);
     if (metadata->typeData.copy_fn) {
-      metadata->typeData.copy_fn(out, elem);
+      metadata->typeData.copy_fn(out, src);
     } else {
-      memcpy(out, elem, metadata->typeData.size);
+      memcpy(out, src, metadata->typeData.size);
     }
-  }
+  } else {
-
+    void *elem = ((char *)*v) + ((metadata->length-1) * metadata->typeData.size);
     if (metadata->typeData.free_fn) {
       metadata->typeData.free_fn(elem);
     }
+  }
 
   metadata->length--;
 
@@ -731,9 +720,6 @@ ev_vec_setlen(
   ev_vec_t* v = (ev_vec_t*)vec_p;
   __ev_vec_getmeta(*v)
 
-  while(metadata->length > len)
-    ev_vec_pop(vec_p, NULL);
-
   while(len > metadata->capacity) {
     ev_vec_error_t grow_err = ev_vec_grow(v);
     if(grow_err) {
@@ -762,10 +748,6 @@ ev_vec_setcapacity(
     return EV_VEC_ERR_NONE;
   }
 
-  if(metadata->length > cap) {
-    ev_vec_setlen(vec_p, cap);
-  }
-
   void *buf = ((char *)(*v) - sizeof(struct ev_vec_meta_t));
   void *tmp = realloc(buf, sizeof(struct ev_vec_meta_t) + (cap * metadata->typeData.size));
 
@@ -789,8 +771,7 @@ ev_vec_grow(
 {
   ev_vec_t* v = (ev_vec_t*)vec_p;
   __ev_vec_getmeta(*v)
-  u64 new_cap = max(EV_VEC_MIN_CAPACITY, metadata->capacity * EV_VEC_GROWTH_RATE);
+  return ev_vec_setcapacity(v, metadata->capacity * EV_VEC_GROWTH_RATE);
-  return ev_vec_setcapacity(v, new_cap);
 }
 
 #endif

meson.build

@@ -1,24 +1,8 @@
 project('evol-headers', 'c',
-  default_options : [ 
+  default_options : [ 'c_std=c23' ])
-    'c_std=c23', 
-    # 'warning_level=everything', 
-    # 'werror=true' 
-  ],
-  meson_version: '>=1.1',
-)
-
 
 headers_include = include_directories('.')
 
-disabled_warnings = {
-  'clang': [
-    'unused-macros',
-    'reserved-macro-identifier',
-    'pre-c11-compat',
-    'pre-c23-compat',
-  ]
-}
-
 evh_c_args = []
 buildtype = get_option('buildtype')
 if buildtype == 'debug'
@@ -36,10 +20,6 @@ elif cc.get_id() == 'clang'
   evh_c_args += '-DEV_CC_CLANG=1'
 endif
 
-foreach w:disabled_warnings[cc.get_id()]
-  evh_c_args += '-Wno-'+w
-endforeach
-
 # All other targets should follow the same template
 str_lib = static_library('ev_str', files('buildfiles/ev_str.c'), c_args: evh_c_args)
 vec_lib = static_library('ev_vec', files('buildfiles/ev_vec.c'), c_args: evh_c_args)
@@ -60,12 +40,18 @@ headers_dep = declare_dependency(
   ]
 )
 
-meson.override_dependency('ev_vec', vec_dep)
+# Tests
-meson.override_dependency('ev_str', str_dep)
+str_test = executable('str_test', 'str_test.c', dependencies: [str_dep], c_args: evh_c_args)
-meson.override_dependency('ev_helpers', helpers_dep)
+test('evstr', str_test)
-meson.override_dependency('ev_log', log_dep)
+vec_test = executable('vec_test', 'vec_test.c', dependencies: [vec_dep], c_args: evh_c_args)
-meson.override_dependency('evol-headers', headers_dep)
+test('evvec', vec_test)
+log_test = executable('log_test', 'log_test.c', dependencies: [log_dep], c_args: evh_c_args)
+test('evlog', log_test)
 
-if get_option('build_tests')
+if meson.version().version_compare('>= 0.54.0')
-  subdir('tests')
+  meson.override_dependency('ev_vec', vec_dep)
+  meson.override_dependency('ev_str', str_dep)
+  meson.override_dependency('ev_helpers', helpers_dep)
+  meson.override_dependency('ev_log', log_dep)
+  meson.override_dependency('evol-headers', headers_dep)
 endif

meson.options

@@ -1 +0,0 @@
-option('build_tests', type: 'boolean', value: true, description: 'Build the tests')

str_test.c

@@ -0,0 +1,106 @@
+#define EV_STR_IMPLEMENTATION
+#include "ev_str.h"
+
+evstring global_str = evstr("Global 'Hello, World!'");
+
+int main()
+{
+  const evstring stack_str = evstr("Stack 'Hello, World!'");
+  printf("Stack String: %s, Length: %llu\n", stack_str, evstring_getLength(stack_str));
+  printf("Global String: %s, Length: %llu\n", global_str, evstring_getLength(global_str));
+
+  evstring heap_str = evstring_new("Heap 'Hello, World!'");
+  printf("Heap String: %s, Length: %llu\n", heap_str, evstring_getLength(heap_str));
+
+  evstring_view view = evstring_slice(stack_str, 0, -1);
+  printf("String View: %.*s\n", (i32)view.len, view.data + view.offset);
+  printf("View length: %llu\n", view.len);
+
+  evstring heap_str2 = evstring_new(view);
+  printf("Heap String 2: %s, Length: %llu\n", heap_str2, evstring_getLength(heap_str2));
+  evstring_free(heap_str2);
+
+
+  evstring_error_t push_str_res = evstring_push(&heap_str, "Hello, Sisyphus! %f", 0.001f);
+  printf("Push char*: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
+  assert(push_str_res == EV_STR_ERR_NONE);
+
+  evstring_error_t push_char_res = evstring_push(&heap_str, (char)'X');
+  printf("Push char: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
+  assert(push_char_res == EV_STR_ERR_NONE);
+
+  evstring_error_t push_view_res = evstring_push(&heap_str, view);
+  printf("Push view: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
+  assert(push_view_res == EV_STR_ERR_NONE);
+
+  evstring str_fmt = evstring_new("%d, %d, %.*s", 1, 0, view.len, view.data + view.offset);
+  printf("Formatted String: %s\n", str_fmt);
+
+  evstring rep_str = evstring_replaceFirst(heap_str, evstr("Hello"), evstr("Bye"));
+  printf("Replaced String: %s\n", rep_str);
+  evstring_free(rep_str);
+
+  evstring_free(str_fmt);
+  evstring_free(heap_str);
+
+  evstring_view search_results[8];
+  evstring search_string = evstr("Hello, this is me saying `Hello` like someone who says 'Hello'");
+  assert(evstring_findAll(search_string, evstr("Hello"), search_results) == 3);
+  assert(search_results[0].data == search_string);
+  assert(search_results[1].data == search_string);
+  assert(search_results[2].data == search_string);
+  assert(search_results[0].len == 5);
+  assert(search_results[1].len == 5);
+  assert(search_results[2].len == 5);
+  assert(search_results[0].offset == 0);
+  assert(search_results[1].offset == 26);
+  assert(search_results[2].offset == 56);
+
+  { // PushFmt Bug
+    printf("PushFmt Bug");
+    evstring heap_str = evstring_new("Heap 'Hello, World!'");
+    printf("Heap String: %s, Length: %llu\n", heap_str, evstring_getLength(heap_str));
+
+    evstring_error_t res = evstring_push(&heap_str, "%.05f", 1.0f);
+    printf("Push Fmt #1: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
+    assert(evstring_getLength(heap_str) == 27);
+    assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000") == 0);
+    assert(res == EV_STR_ERR_NONE);
+
+    /*evstring_push(&heap_str, "%.05f, %.05f, %.05f", 1.0f, 2.0f, 3.0f);*/
+    res = evstring_push(&heap_str, "Something");
+    printf("Push Fmt #2: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
+    assert(evstring_getLength(heap_str) == 36);
+    assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000Something") == 0);
+    assert(res == EV_STR_ERR_NONE);
+
+    evstring_free(heap_str);
+  }
+
+  { // Incorrectly handled mismatches
+    evstring text = evstr("aab");
+    evstring query = evstr("ab");
+    evstring_view match = evstring_findFirst(text, query);
+    assert(match.len == 2);
+    assert(match.offset == 1);
+  }
+
+  { // Underflowing getSpace for stack strings
+    evstring stack_str = evstr("abc");
+    assert(evstring_getSpace(stack_str) == 0);
+  }
+
+  { // Overlapping push
+    evstring s = evstring_newFromStr("abc");
+    assert(s != NULL);
+
+    evstring_error_t err = evstring_pushStr(&s, s);
+    assert(err == EV_STR_ERR_NONE);
+    assert(strcmp(s, "abcabc") == 0);
+
+    evstring_free(s);
+  }
+
+
+  return 0;
+}

tests/ev_hash/meson.build

@@ -1,7 +0,0 @@
-tests = [
-]
-
-foreach t : tests
-  exec = executable(t, t+'.c', include_directories: headers_include, c_args: evh_c_args)
-  test(t, exec, suite: 'hash')
-endforeach

tests/ev_log/meson.build

@@ -1,8 +0,0 @@
-tests = [
-  'basic_log',
-]
-
-foreach t : tests
-  exec = executable(t, t+'.c', dependencies: [log_dep], c_args: evh_c_args)
-  test(t, exec, suite: 'log')
-endforeach

tests/ev_str/find_all.c

@@ -1,23 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring_view search_results[8];
-  evstring search_string = evstr("Hello, this is me saying `Hello` like someone who says 'Hello'");
-
-  assert(evstring_findAll(search_string, evstr("Hello"), search_results) == 3);
-  assert(search_results[0].data == search_string);
-  assert(search_results[1].data == search_string);
-  assert(search_results[2].data == search_string);
-  assert(search_results[0].len == 5);
-  assert(search_results[1].len == 5);
-  assert(search_results[2].len == 5);
-  assert(search_results[0].offset == 0);
-  assert(search_results[1].offset == 26);
-  assert(search_results[2].offset == 56);
-
-  return 0;
-}

tests/ev_str/find_all_count_only.c

@@ -1,15 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("Hello, this is me saying `Hello` like someone who says 'Hello'");
-
-  assert(evstring_findAll(text, evstr("Hello"), NULL) == 3);
-  assert(evstring_findAll(evstr("abc"), evstr("abc"), NULL) == 1);
-  assert(evstring_findAll(evstr("abcx"), evstr("abc"), NULL) == 1);
-
-  return 0;
-}

tests/ev_str/find_all_exact_match.c

@@ -1,18 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring_view search_results[1];
-  evstring text = evstr("abc");
-  evstring query = evstr("abc");
-
-  assert(evstring_findAll(text, query, search_results) == 1);
-  assert(search_results[0].data == text);
-  assert(search_results[0].len == 3);
-  assert(search_results[0].offset == 0);
-
-  return 0;
-}

tests/ev_str/find_all_no_matches.c

@@ -1,16 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring_view search_results[1];
-  evstring text = evstr("Hello, this is me saying `Hello` like someone who says 'Hello'");
-
-  assert(evstring_findAll(text, evstr(""), search_results) == 0);
-  assert(evstring_findAll(text, evstr("Goodbye"), search_results) == 0);
-  assert(evstring_findAll(evstr("ab"), evstr("abc"), search_results) == 0);
-
-  return 0;
-}

tests/ev_str/find_all_overlapping.c

@@ -1,23 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring_view search_results[2];
-  evstring text = evstr("aaa");
-  evstring query = evstr("aa");
-
-  assert(evstring_findAll(text, query, search_results) == 2);
-
-  assert(search_results[0].data == text);
-  assert(search_results[0].len == 2);
-  assert(search_results[0].offset == 0);
-
-  assert(search_results[1].data == text);
-  assert(search_results[1].len == 2);
-  assert(search_results[1].offset == 1);
-
-  return 0;
-}

tests/ev_str/find_all_short_suffix.c

@@ -1,18 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring_view search_results[1];
-  evstring text = evstr("abcx");
-  evstring query = evstr("abc");
-
-  assert(evstring_findAll(text, query, search_results) == 1);
-  assert(search_results[0].data == text);
-  assert(search_results[0].len == 3);
-  assert(search_results[0].offset == 0);
-
-  return 0;
-}

tests/ev_str/find_first_empty_query.c

@@ -1,17 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("abc");
-  evstring query = evstr("");
-
-  evstring_view match = evstring_findFirst(text, query);
-
-  assert(match.len == 0);
-  assert(match.offset == ~0ull);
-
-  return 0;
-}

tests/ev_str/find_first_empty_text.c

@@ -1,17 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("");
-  evstring query = evstr("a");
-
-  evstring_view match = evstring_findFirst(text, query);
-
-  assert(match.len == 0);
-  assert(match.offset == ~0ull);
-
-  return 0;
-}

tests/ev_str/find_first_mismatch.c

@@ -1,16 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("aab");
-  evstring query = evstr("ab");
-  evstring_view match = evstring_findFirst(text, query);
-
-  assert(match.len == 2);
-  assert(match.offset == 1);
-
-  return 0;
-}

tests/ev_str/find_first_overlapping_prefix.c

@@ -1,16 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("aaab");
-  evstring query = evstr("aab");
-  evstring_view match = evstring_findFirst(text, query);
-
-  assert(match.len == 3);
-  assert(match.offset == 1);
-
-  return 0;
-}

tests/ev_str/find_first_query_too_long.c

@@ -1,17 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("ab");
-  evstring query = evstr("abc");
-
-  evstring_view match = evstring_findFirst(text, query);
-
-  assert(match.len == 0);
-  assert(match.offset == ~0ull);
-
-  return 0;
-}

tests/ev_str/meson.build

@@ -1,27 +0,0 @@
-tests = [
-  'stack_global_heap',
-  'slice',
-  'push_variants',
-  'new_format',
-  'replace_first',
-  'find_all',
-  'find_all_exact_match',
-  'find_all_short_suffix',
-  'find_all_count_only',
-  'find_all_no_matches',
-  'find_all_overlapping',
-  'push_fmt_float',
-  'find_first_mismatch',
-  'find_first_overlapping_prefix',
-  'stack_get_space',
-  'overlapping_push',
-  'find_first_empty_query',
-  'find_first_query_too_long',
-  'find_first_empty_text',
-  'replace_first_query_too_long',
-]
-
-foreach t : tests
-  exec = executable(t, t+'.c', dependencies: [str_dep], c_args: evh_c_args)
-  test(t, exec, suite: 'str')
-endforeach

tests/ev_str/new_format.c

@@ -1,19 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  evstring source = evstr("Stack 'Hello, World!'");
-  evstring_view view = evstring_slice(source, 0, -1);
-
-  evstring str_fmt = evstring_new("%d, %d, %.*s", 1, 0, view.len, view.data + view.offset);
-  assert(str_fmt != NULL);
-  assert(strcmp(str_fmt, "1, 0, Stack 'Hello, World!'") == 0);
-
-  evstring_free(str_fmt);
-
-  return 0;
-}

tests/ev_str/overlapping_push.c

@@ -1,19 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  evstring s = evstring_newFromStr("abc");
-  assert(s != NULL);
-
-  evstring_error_t err = evstring_pushStr(&s, s);
-  assert(err == EV_STR_ERR_NONE);
-  assert(strcmp(s, "abcabc") == 0);
-
-  evstring_free(s);
-
-  return 0;
-}

tests/ev_str/push_fmt_float.c

@@ -1,25 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  evstring heap_str = evstring_new("Heap 'Hello, World!'");
-  assert(heap_str != NULL);
-
-  evstring_error_t res = evstring_push(&heap_str, "%.05f", 1.0f);
-  assert(res == EV_STR_ERR_NONE);
-  assert(evstring_getLength(heap_str) == 27);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000") == 0);
-
-  res = evstring_push(&heap_str, "Something");
-  assert(res == EV_STR_ERR_NONE);
-  assert(evstring_getLength(heap_str) == 36);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000Something") == 0);
-
-  evstring_free(heap_str);
-
-  return 0;
-}

tests/ev_str/push_variants.c

@@ -1,29 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  evstring heap_str = evstring_new("Heap 'Hello, World!'");
-  assert(heap_str != NULL);
-
-  evstring_error_t push_str_res = evstring_push(&heap_str, "Hello, Sisyphus! %f", 0.001f);
-  assert(push_str_res == EV_STR_ERR_NONE);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'Hello, Sisyphus! 0.001000") == 0);
-
-  evstring_error_t push_char_res = evstring_push(&heap_str, (char)'X');
-  assert(push_char_res == EV_STR_ERR_NONE);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'Hello, Sisyphus! 0.001000X") == 0);
-
-  evstring source = evstr("Stack 'Hello, World!'");
-  evstring_view view = evstring_slice(source, 0, -1);
-  evstring_error_t push_view_res = evstring_push(&heap_str, view);
-  assert(push_view_res == EV_STR_ERR_NONE);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'Hello, Sisyphus! 0.001000XStack 'Hello, World!'") == 0);
-
-  evstring_free(heap_str);
-
-  return 0;
-}

tests/ev_str/replace_first.c

@@ -1,20 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  evstring text = evstring_new("Hello, Hello!");
-  assert(text != NULL);
-
-  evstring rep_str = evstring_replaceFirst(text, evstr("Hello"), evstr("Bye"));
-  assert(rep_str != NULL);
-  assert(strcmp(rep_str, "Bye, Hello!") == 0);
-
-  evstring_free(rep_str);
-  evstring_free(text);
-
-  return 0;
-}

tests/ev_str/replace_first_query_too_long.c

@@ -1,18 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring text = evstr("ab");
-  evstring replacement = evstr("x");
-  evstring query = evstr("abc");
-
-  evstring result = evstring_replaceFirst(text, query, replacement);
-
-  assert(EV_EQUAL(evstring)(&result, &text));
-
-  evstring_free(result);
-  return 0;
-}

tests/ev_str/slice.c

@@ -1,24 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-int main(void)
-{
-  const evstring stack_str = evstr("Stack 'Hello, World!'");
-
-  evstring_view view = evstring_slice(stack_str, 0, -1);
-  assert(view.data == stack_str);
-  assert(view.offset == 0);
-  assert(view.len == evstring_getLength(stack_str));
-
-  evstring heap_str = evstring_new(view);
-  assert(heap_str != NULL);
-  assert(strcmp(heap_str, stack_str) == 0);
-  assert(evstring_getLength(heap_str) == evstring_getLength(stack_str));
-
-  evstring_free(heap_str);
-
-  return 0;
-}

tests/ev_str/stack_get_space.c

@@ -1,12 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  evstring stack_str = evstr("abc");
-  assert(evstring_getSpace(stack_str) == 0);
-
-  return 0;
-}

tests/ev_str/stack_global_heap.c

@@ -1,26 +0,0 @@
-#define EV_STR_IMPLEMENTATION
-#include "ev_str.h"
-
-#include <assert.h>
-#include <string.h>
-
-static evstring global_str = evstr("Global 'Hello, World!'");
-
-int main(void)
-{
-  const evstring stack_str = evstr("Stack 'Hello, World!'");
-  assert(strcmp(stack_str, "Stack 'Hello, World!'") == 0);
-  assert(evstring_getLength(stack_str) == 21);
-
-  assert(strcmp(global_str, "Global 'Hello, World!'") == 0);
-  assert(evstring_getLength(global_str) == 22);
-
-  evstring heap_str = evstring_new("Heap 'Hello, World!'");
-  assert(heap_str != NULL);
-  assert(strcmp(heap_str, "Heap 'Hello, World!'") == 0);
-  assert(evstring_getLength(heap_str) == 20);
-
-  evstring_free(heap_str);
-
-  return 0;
-}

tests/ev_types/meson.build

@@ -1,8 +0,0 @@
-tests = [
-  'tostr',
-]
-
-foreach t : tests
-  exec = executable(t, t+'.c', include_directories: headers_include, c_args: evh_c_args)
-  test(t, exec, suite: 'types')
-endforeach

tests/ev_vec/meson.build

@@ -1,12 +0,0 @@
-tests = [
-  'zero_cap_grow',
-  'reducecap_updatelen',
-  'reducecap_free_elems',
-  'reducelen_free_elems',
-  'pop_out_frees_vector_owned_elem',
-]
-
-foreach t : tests
-  exec = executable(t, t+'.c', dependencies: [vec_dep], c_args: evh_c_args)
-  test(t, exec, suite: 'vec')
-endforeach

tests/ev_vec/pop_out_frees_vector_owned_elem.c

@@ -1,55 +0,0 @@
-#define EV_VEC_IMPLEMENTATION
-#include "ev_vec.h"
-
-#include <assert.h>
-#include <stdlib.h>
-
-static int free_calls = 0;
-
-typedef struct OwningInt {
-  int *ptr;
-} OwningInt;
-
-DEFINE_COPY_FUNCTION(OwningInt, Default)
-{
-  dst->ptr = malloc(sizeof(*dst->ptr));
-  assert(dst->ptr != NULL);
-  *dst->ptr = *src->ptr;
-}
-
-DEFINE_FREE_FUNCTION(OwningInt, Default)
-{
-  assert(self->ptr != NULL);
-  free(self->ptr);
-  self->ptr = NULL;
-  free_calls++;
-}
-
-TYPEDATA_GEN(OwningInt, COPY(Default), FREE(Default));
-
-int main(void)
-{
-  ev_vec(OwningInt) v = ev_vec_init(OwningInt);
-  assert(v != NULL);
-
-  OwningInt original = { .ptr = malloc(sizeof(*original.ptr)) };
-  assert(original.ptr != NULL);
-  *original.ptr = 42;
-
-  assert(ev_vec_push_impl(&v, &original) == 0);
-  free(original.ptr);
-
-  OwningInt out = {0};
-  assert(ev_vec_pop(&v, &out) == EV_VEC_ERR_NONE);
-  assert(out.ptr != NULL);
-  assert(*out.ptr == 42);
-
-  FREE_FUNCTION(OwningInt, Default)(&out);
-
-  /* Popping with an output copy transfers no pointer from the vector element.
-     The vector's own deep-copied element must still be destroyed. */
-  assert(free_calls == 2);
-
-  ev_vec_fini(&v);
-  return 0;
-}

tests/ev_vec/reducecap_free_elems.c

@@ -1,28 +0,0 @@
-#define EV_VEC_IMPLEMENTATION
-#include "ev_vec.h"
-
-#include <assert.h>
-
-static int free_calls = 0;
-
-static void count_free(void *self)
-{
-  (void)self;
-  free_calls++;
-}
-
-int main(void)
-{
-  ev_vec(i32) v = ev_vec_init(i32, free = count_free);
-  assert(v != NULL);
-
-  for(i32 i = 0; i < 5; i++) {
-    assert(ev_vec_push_impl(&v, &i) >= 0);
-  }
-
-  free_calls = 0;
-  assert(ev_vec_setcapacity(&v, 3) == EV_VEC_ERR_NONE);
-  assert(free_calls == 2);
-
-  ev_vec_fini(&v);
-}

tests/ev_vec/reducecap_updatelen.c

@@ -1,21 +0,0 @@
-#define EV_VEC_IMPLEMENTATION
-#include "ev_vec.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  ev_vec(i32) v = ev_vec_init(i32);
-  assert(v != NULL);
-
-  for(i32 i = 0; i < 5; i++) {
-    assert(ev_vec_push_impl(&v, &i) >= 0);
-  }
-
-  ev_vec_error_t err = ev_vec_setcapacity(&v, 2);
-  assert(err != EV_VEC_ERR_NONE || ev_vec_len(&v) <= ev_vec_capacity(&v));
-
-  ev_vec_fini(&v);
-
-  return 0;
-}

tests/ev_vec/reducelen_free_elems.c

@@ -1,25 +0,0 @@
-#define EV_VEC_IMPLEMENTATION
-#include "ev_vec.h"
-
-#include <assert.h>
-
-static int free_calls = 0;
-
-static void count_free(void *self)
-{
-  (void)self;
-  free_calls++;
-}
-
-int main(void)
-{
-  ev_vec(i32) v = ev_vec_init(i32, free = count_free);
-  assert(v != NULL);
-
-  free_calls = 0;
-  assert(ev_vec_setlen(&v, 3) == EV_VEC_ERR_NONE);
-  assert(ev_vec_setlen(&v, 1) == EV_VEC_ERR_NONE);
-  assert(free_calls == 2);
-
-  ev_vec_fini(&v);
-}

tests/ev_vec/zero_cap_grow.c

@@ -1,19 +0,0 @@
-#define EV_VEC_IMPLEMENTATION
-#include "ev_vec.h"
-
-#include <assert.h>
-
-int main(void)
-{
-  ev_vec(i32) v = ev_vec_init(i32);
-  assert(v != NULL);
-
-  assert(ev_vec_setcapacity(&v, 0) == EV_VEC_ERR_NONE);
-  assert(ev_vec_capacity(&v) == 0);
-  assert(ev_vec_grow(&v) == EV_VEC_ERR_NONE);
-  assert(ev_vec_capacity(&v) > 0);
-
-  ev_vec_fini(&v);
-
-  return 0;
-}

tests/meson.build

@@ -1,5 +0,0 @@
-subdir('ev_hash')
-subdir('ev_log')
-subdir('ev_str')
-subdir('ev_types')
-subdir('ev_vec')

vec_test.c

@@ -0,0 +1,22 @@
+#define EV_VEC_IMPLEMENTATION
+#include "ev_vec.h"
+
+#include <assert.h>
+
+int main(void)
+{
+  {
+    ev_vec(i32) v = ev_vec_init(i32);
+    assert(v != NULL);
+
+    for(i32 i = 0; i < 5; i++) {
+      assert(ev_vec_push_impl(&v, &i) >= 0);
+    }
+
+    ev_vec_error_t err = ev_vec_setcapacity(&v, 2);
+    assert(err != EV_VEC_ERR_NONE || ev_vec_len(&v) <= ev_vec_capacity(&v));
+
+    ev_vec_fini(&v);
+  }
+  return 0;
+}