void

Type
October 8, 2025

Table of Contents

`void`

Description

Type-specific write callback signature

Usage example (Cross-references)

In Sys.c:82:

    static SysAbortCallback g_abort_callback = NULL;
    
    void SysSetAbortCallback(SysAbortCallback callback) {
    g_abort_callback = callback;
    }

In Sys.c:86:

    }
    
    void SysAbort(void) {
    if (g_abort_callback) {
    g_abort_callback();

In Memory.c:11:

    #include <Misra/Std/Log.h>
    
    i32 MemCompare(const void *p1, const void *p2, size n) {
    if (!p1 || !p2) {
    LOG_FATAL("Invalid arguments");

In Memory.c:28:

    }
    
    void *MemCopy(void *dst, const void *src, size n) {
    if (!dst || !src) {
    LOG_FATAL("Invalid arguments");

In Memory.c:41:

    }
    
    void *MemMove(void *dst, const void *src, size n) {
    if (!dst || !src) {
    LOG_FATAL("Invalid arguments");

In Memory.c:62:

    }
    
    void *MemSet(void *dst, i32 val, size n) {
    if (!dst) {
    LOG_FATAL("Invalid arguments");

In Memory.c:152:

    }
    
    void ZstrDeinit(const char **zs) {
    if (!zs) {
    LOG_FATAL("Invalid arguments");

In Io.c:43:

    
    
    static void _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static void _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static void _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);

In Io.c:44:

    
    static void _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static void _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static void _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static void _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.c:45:

    static void _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static void _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static void _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static void _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.c:46:

    static void _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static void _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static void _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);
    
    static const char *_read_r8(const char *i, FmtInfo *fmt_info, u8 *v);

In Io.c:210:

    
    // Helper function to pad string with spaces
    static void PadString(Str *o, size width, Alignment align, size content_len) {
    if (content_len >= width)
    return;

In Io.c:314:

    // deduce the actual field size
    u32 var_width = 0;
    if (write_fn == (void *)_write_u8 || write_fn == (void *)_write_i8) {
    var_width = 1;
    } else if (write_fn == (void *)_write_u16 || write_fn == (void *)_write_i16) {

In Io.c:316:

    if (write_fn == (void *)_write_u8 || write_fn == (void *)_write_i8) {
    var_width = 1;
    } else if (write_fn == (void *)_write_u16 || write_fn == (void *)_write_i16) {
    var_width = 2;
    } else if (write_fn == (void *)_write_u32 || write_fn == (void *)_write_i32 ||

In Io.c:318:

    } else if (write_fn == (void *)_write_u16 || write_fn == (void *)_write_i16) {
    var_width = 2;
    } else if (write_fn == (void *)_write_u32 || write_fn == (void *)_write_i32 ||
    write_fn == (void *)_write_f32) {
    var_width = 4;

In Io.c:319:

    var_width = 2;
    } else if (write_fn == (void *)_write_u32 || write_fn == (void *)_write_i32 ||
    write_fn == (void *)_write_f32) {
    var_width = 4;
    } else if (write_fn == (void *)_write_u64 || write_fn == (void *)_write_i64 ||

In Io.c:321:

    write_fn == (void *)_write_f32) {
    var_width = 4;
    } else if (write_fn == (void *)_write_u64 || write_fn == (void *)_write_i64 ||
    write_fn == (void *)_write_f64) {
    var_width = 8;

In Io.c:322:

    var_width = 4;
    } else if (write_fn == (void *)_write_u64 || write_fn == (void *)_write_i64 ||
    write_fn == (void *)_write_f64) {
    var_width = 8;
    } else {

In Io.c:537:

    // deduce the actual field size
    u32   var_width = 0;
    void *read_fn   = (void *)io->reader;
    if (read_fn == (void *)_read_u8 || read_fn == (void *)_read_i8) {
    var_width = 1;

In Io.c:538:

    u32   var_width = 0;
    void *read_fn   = (void *)io->reader;
    if (read_fn == (void *)_read_u8 || read_fn == (void *)_read_i8) {
    var_width = 1;
    } else if (read_fn == (void *)_read_u16 || read_fn == (void *)_read_i16) {

In Io.c:540:

    if (read_fn == (void *)_read_u8 || read_fn == (void *)_read_i8) {
    var_width = 1;
    } else if (read_fn == (void *)_read_u16 || read_fn == (void *)_read_i16) {
    var_width = 2;
    } else if (read_fn == (void *)_read_u32 || read_fn == (void *)_read_i32 ||

In Io.c:542:

    } else if (read_fn == (void *)_read_u16 || read_fn == (void *)_read_i16) {
    var_width = 2;
    } else if (read_fn == (void *)_read_u32 || read_fn == (void *)_read_i32 ||
    read_fn == (void *)_read_f32) {
    var_width = 4;

In Io.c:543:

    var_width = 2;
    } else if (read_fn == (void *)_read_u32 || read_fn == (void *)_read_i32 ||
    read_fn == (void *)_read_f32) {
    var_width = 4;
    } else if (read_fn == (void *)_read_u64 || read_fn == (void *)_read_i64 ||

In Io.c:545:

    read_fn == (void *)_read_f32) {
    var_width = 4;
    } else if (read_fn == (void *)_read_u64 || read_fn == (void *)_read_i64 ||
    read_fn == (void *)_read_f64) {
    var_width = 8;

In Io.c:546:

    var_width = 4;
    } else if (read_fn == (void *)_read_u64 || read_fn == (void *)_read_i64 ||
    read_fn == (void *)_read_f64) {
    var_width = 8;
    } else {

In Io.c:645:

    }
    
    void FReadFmtInternal(FILE *file, const char *fmtstr, TypeSpecificIO *argv, u64 argc) {
    if (!file || !fmtstr) {
    LOG_FATAL("Invalid arguments");

In Io.c:707:

    // Helper function to write integer values as character sequences in a consistent order
    // regardless of system endianness (big-endian order: most significant byte first)
    static inline void write_int_as_chars(Str *o, FormatFlags flags, u64 value, size num_bytes) {
    if (!o || !num_bytes || num_bytes > 8) {
    LOG_FATAL("Invalid arguments to write_int_as_chars");

In Io.c:742:

    }
    
    static inline void write_char_internal(Str *o, FormatFlags flags, const char *vs, size len) {
    if (!o || !vs || !len) {
    LOG_FATAL("Invalid arguments");

In Io.c:836:

    }
    
    void _write_Str(Str *o, FmtInfo *fmt_info, Str *s) {
    if (!o || !s || !fmt_info) {
    LOG_FATAL("Invalid arguments");

In Io.c:904:

    }
    
    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s) {
    if (!o || !s || !*s || !fmt_info) {
    LOG_FATAL("Invalid arguments");

In Io.c:977:

    }
    
    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1021:

    }
    
    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1037:

    }
    
    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1053:

    }
    
    void _write_u8(Str *o, FmtInfo *fmt_info, u8 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1069:

    }
    
    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1113:

    }
    
    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1129:

    }
    
    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1145:

    }
    
    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1161:

    }
    
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:1224:

    }
    
    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:2264:

    
    const char *_read_Zstr(const char *i, FmtInfo *fmt_info, const char **out) {
    (void)fmt_info; // Unused parameter
    if (!i || !out)
    LOG_FATAL("Invalid arguments");

In Io.c:2295:

    }
    
    void _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv) {
    if (!o || !fmt_info || !bv) {
    LOG_FATAL("Invalid arguments");

In Io.c:2344:

    }
    
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s) {
    (void)o;
    (void)fmt_info;

In Io.c:2345:

    
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s) {
    (void)o;
    (void)fmt_info;
    (void)s;

In Io.c:2346:

    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s) {
    (void)o;
    (void)fmt_info;
    (void)s;
    LOG_FATAL("Attempt to write unsupported type");

In Io.c:2347:

    (void)o;
    (void)fmt_info;
    (void)s;
    LOG_FATAL("Attempt to write unsupported type");
    }

In Io.c:2352:

    
    const char *_read_BitVec(const char *i, FmtInfo *fmt_info, BitVec *bv) {
    (void)fmt_info; // Unused parameter
    if (!i || !bv) {
    LOG_FATAL("Invalid arguments");

In Io.c:2468:

    
    const char *_read_UnsupportedType(const char *i, FmtInfo *fmt_info, const char **s) {
    (void)fmt_info; // Unused parameter
    (void)s;
    LOG_FATAL("Attempt to read unsupported type.");

In Io.c:2469:

    const char *_read_UnsupportedType(const char *i, FmtInfo *fmt_info, const char **s) {
    (void)fmt_info; // Unused parameter
    (void)s;
    LOG_FATAL("Attempt to read unsupported type.");
    return i;

In Io.c:2586:

    }
    
    static void _write_r8(Str *o, FmtInfo *fmt_info, u8 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:2594:

    }
    
    static void _write_r16(Str *o, FmtInfo *fmt_info, u16 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:2623:

    }
    
    static void _write_r32(Str *o, FmtInfo *fmt_info, u32 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Io.c:2658:

    
    
    static void _write_r64(Str *o, FmtInfo *fmt_info, u64 *v) {
    if (!o || !fmt_info || !v) {
    LOG_FATAL("Invalid arguments");

In Log.c:18:

    static SysMutex *log_mutex = NULL;
    
    void close_log_file(void) {
    if (stderror) {
    fclose(stderror);

In Log.c:24:

    }
    
    void LogInit(bool redirect) {
    if (redirect) {
    // Get the current time

In Log.c:97:

    
    
    void LogDeinit(void) {
    if (stderror && stderror != stderr) {
    fclose(stderror);

In Log.c:107:

    }
    
    void free_log_mutex(void) {
    SysMutexDestroy(log_mutex);
    }

In Log.c:111:

    }
    
    void LogWrite(LogMessageType type, const char *tag, int line, const char *msg) {
    if (!msg) {
    return;

In Iter.c:26:

    }
    
    void validate_iter(GenericIter *i) {
    if (((i)->dir != -1 && (i)->dir != 1) || !(i)->alignment || !(i)->length || (i)->pos >= (i)->length) {
    LOG_FATAL("Invalid iter object.");

In Iter.c:30:

    LOG_FATAL("Invalid iter object.");
    }
    (void)(*(char *)(void *)((i)->data));
    }

In Str.c:85:

    }
    
    void StrDeinit(Str *copy) {
    ValidateStr(copy);
    if (copy->data) {

In Str.c:225:

    
    // Helper: replace in-place all `match` → `replacement` up to `count`
    static void
    str_replace(Str *s, const char *match, size match_len, const char *replacement, size replacement_len, size count) {
    ValidateStr(s);

In Str.c:243:

    }
    
    void StrReplaceZstr(Str *s, const char *match, const char *replacement, size count) {
    ValidateStr(s);
    str_replace(s, match, ZstrLen(match), replacement, ZstrLen(replacement), count);

In Str.c:248:

    }
    
    void StrReplaceCstr(
    Str        *s,
    const char *match,

In Str.c:260:

    }
    
    void StrReplace(Str *s, const Str *match, const Str *replacement, size count) {
    ValidateStr(s);
    str_replace(s, match->data, match->length, replacement->data, replacement->length, count);

In Str.c:858:

    }
    
    void ValidateStr(const Str *s) {
    return ValidateVec(s);
    }

In Str.c:862:

    }
    
    void ValidateStrs(const Strs *vs) {
    ValidateVec(vs);
    VecForeachPtr(vs, sp) {

In BitVec.c:38:

    #define BYTES_FOR_BITS(bits) (((bits) + BITS_PER_BYTE - 1) / BITS_PER_BYTE)
    
    void BitVecDeinit(BitVec *bitvec) {
    ValidateBitVec(bitvec);
    if (bitvec->data) {

In BitVec.c:49:

    }
    
    void BitVecClear(BitVec *bitvec) {
    ValidateBitVec(bitvec);
    bitvec->length = 0;

In BitVec.c:57:

    }
    
    void BitVecResize(BitVec *bitvec, u64 new_size) {
    ValidateBitVec(bitvec);
    if (new_size > bitvec->capacity) {

In BitVec.c:86:

    }
    
    void BitVecReserve(BitVec *bitvec, u64 n) {
    ValidateBitVec(bitvec);
    if (n <= bitvec->capacity)

In BitVec.c:108:

    }
    
    void BitVecShrinkToFit(BitVec *bv) {
    ValidateBitVec(bv);
    if (bv->length == 0) {

In BitVec.c:143:

    
    
    void BitVecSwap(BitVec *bv1, BitVec *bv2) {
    ValidateBitVec(bv1);
    ValidateBitVec(bv2);

In BitVec.c:197:

    }
    
    void BitVecSet(BitVec *bitvec, u64 idx, bool value) {
    ValidateBitVec(bitvec);
    if (idx >= bitvec->length) {

In BitVec.c:212:

    }
    
    void BitVecFlip(BitVec *bitvec, u64 idx) {
    ValidateBitVec(bitvec);
    if (idx >= bitvec->length) {

In BitVec.c:223:

    }
    
    void BitVecPush(BitVec *bitvec, bool value) {
    ValidateBitVec(bitvec);
    if (bitvec->length >= bitvec->capacity) {

In BitVec.c:244:

    }
    
    void BitVecInsert(BitVec *bitvec, u64 idx, bool value) {
    ValidateBitVec(bitvec);
    if (idx > bitvec->length) {

In BitVec.c:261:

    }
    
    void BitVecInsertRange(BitVec *bv, u64 idx, u64 count, bool value) {
    ValidateBitVec(bv);
    if (idx > bv->length) {

In BitVec.c:287:

    }
    
    void BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other) {
    ValidateBitVec(bv);
    ValidateBitVec(other);

In BitVec.c:315:

    }
    
    void BitVecInsertPattern(BitVec *bv, u64 idx, u8 pattern, u64 pattern_bits) {
    ValidateBitVec(bv);
    if (idx > bv->length) {

In BitVec.c:361:

    }
    
    void BitVecRemoveRange(BitVec *bv, u64 idx, u64 count) {
    ValidateBitVec(bv);
    if (idx >= bv->length) {

In BitVec.c:454:

    }
    
    void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) {
    ValidateBitVec(result);
    ValidateBitVec(a);

In BitVec.c:469:

    }
    
    void BitVecOr(BitVec *result, BitVec *a, BitVec *b) {
    ValidateBitVec(result);
    ValidateBitVec(a);

In BitVec.c:484:

    }
    
    void BitVecXor(BitVec *result, BitVec *a, BitVec *b) {
    ValidateBitVec(result);
    ValidateBitVec(a);

In BitVec.c:499:

    }
    
    void BitVecNot(BitVec *result, BitVec *bitvec) {
    ValidateBitVec(result);
    ValidateBitVec(bitvec);

In BitVec.c:865:

    
    // Shift operations
    void BitVecShiftLeft(BitVec *bv, u64 positions) {
    ValidateBitVec(bv);
    if (positions == 0 || bv->length == 0) {

In BitVec.c:889:

    }
    
    void BitVecShiftRight(BitVec *bv, u64 positions) {
    ValidateBitVec(bv);
    if (positions == 0 || bv->length == 0) {

In BitVec.c:913:

    }
    
    void BitVecRotateLeft(BitVec *bv, u64 positions) {
    ValidateBitVec(bv);
    if (positions == 0 || bv->length == 0) {

In BitVec.c:937:

    }
    
    void BitVecRotateRight(BitVec *bv, u64 positions) {
    ValidateBitVec(bv);
    if (positions == 0 || bv->length == 0) {

In BitVec.c:961:

    }
    
    void BitVecReverse(BitVec *bv) {
    ValidateBitVec(bv);
    if (bv->length <= 1) {

In BitVec.c:1638:

    }
    
    void ValidateBitVec(const BitVec *bv) {
    if (!(bv)) {
    LOG_FATAL("Invalid bitvec object: NULL.");

In BitVec.c:1655:

    }
    if ((bv)->data) {
    (void)((bv)->data[0]);
    }
    }

In List.c:4:

    #include <Misra/Std/Log.h>
    
    void deinit_list(GenericList *list, u64 item_size) {
    if (!list || !item_size) {
    LOG_ERROR("invalid arguments");

In List.c:22:

    
    
    void insert_into_list(GenericList *list, void *item_data, u64 item_size, u64 idx) {
    if (!list || !item_size || !item_data) {
    LOG_FATAL("invalid arguments.");

In List.c:87:

    }
    
    void remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:154:

    
    
    void qsort_list(GenericList *list, u64 item_size, GenericCompare comp) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:161:

    ValidateList(list);
    
    void *data       = malloc(item_size * list->length);
    u64   item_count = list->length;
    remove_range_list(list, data, item_size, 0, list->length);

In List.c:170:

    
    
    void swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:199:

    
    
    void reverse_list(GenericList *list, u64 item_size) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:213:

    
    
    void push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count) {
    if (!list || !arr || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:266:

    
    
    void merge_list(GenericList *list1, u64 item_size, GenericList *list2) {
    if (!list1 || !item_size || !list2) {
    LOG_FATAL("invalid arguments.");

In List.c:282:

    
    
    void clear_list(GenericList *list, u64 item_size) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:312:

    
    
    void *item_ptr_at_list(GenericList *list, u64 item_size, u64 idx) {
    if (!list || !item_size) {
    LOG_FATAL("invalid arguments.");

In List.c:327:

    }
    
    void validate_list(const GenericList *l) {
    if (!(l)) {
    LOG_FATAL("List pointer is NULL.");

In Vec.c:42:

    }
    
    void deinit_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);

In Vec.c:62:

    
    
    void clear_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);

In Vec.c:82:

    
    // Reserve new space if n > capacity
    void reserve_vec(GenericVec *vec, size item_size, size n) {
    ValidateVec(vec);

In Vec.c:105:

    
    
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n) {
    ValidateVec(vec);

In Vec.c:121:

    
    
    void reduce_space_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);

In Vec.c:143:

    
    
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count) {
    if (!count) {
    return;

In Vec.c:181:

    }
    
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count) {
    if (!count) {
    return;

In Vec.c:221:

    
    
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count) {
    ValidateVec(vec);

In Vec.c:262:

    
    
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count) {
    ValidateVec(vec);

In Vec.c:316:

    
    
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp) {
    ValidateVec(vec);

In Vec.c:330:

    
    
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2) {
    ValidateVec(vec);

In Vec.c:355:

    
    
    void reverse_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);

In Vec.c:364:

    }
    
    void resize_vec(GenericVec *vec, size item_size, size new_size) {
    ValidateVec(vec);

In Vec.c:379:

    }
    
    void validate_vec(const GenericVec *v) {
    if (!(v)) {
    LOG_FATAL("NULL vec object pointer.");

In Vec.c:391:

    // if memory is invalid, system will segfault here
    if ((v)->data) {
    (void)(*(char *)(void *)((v)->data));
    }
    }

In Mutex.c:30:

    };
    
    SysMutex *SysMutexCreate(void) {
    SysMutex *m = NEW(SysMutex);
    #ifdef _WIN32

In Mutex.c:40:

    }
    
    void SysMutexDestroy(SysMutex *m) {
    #ifdef _WIN32
    DeleteCriticalSection(&m->lock);

In Proc.c:228:

    }
    
    void SysProcWait(SysProc *proc) {
    if (!proc) {
    LOG_FATAL("Invalid argument");

In Proc.c:333:

    }
    
    void SysProcTerminate(SysProc *proc) {
    if (!proc) {
    LOG_FATAL("Invalid argument");

In Proc.c:388:

    
    
    void SysProcDestroy(SysProc *proc) {
    if (!proc) {
    LOG_FATAL("Invalid argument");

In Proc.c:570:

    }
    
    SysProcId SysGetCurrentProcessId(void) {
    #ifdef _WIN32
    return (SysProcId)GetCurrentProcessId(); // Windows API

In Vec.Foreach.c:11:

    
    // Function prototypes
    bool test_vec_foreach(void);
    bool test_vec_foreach_idx(void);
    bool test_vec_foreach_ptr(void);

In Vec.Foreach.c:12:

    // Function prototypes
    bool test_vec_foreach(void);
    bool test_vec_foreach_idx(void);
    bool test_vec_foreach_ptr(void);
    bool test_vec_foreach_ptr_idx(void);

In Vec.Foreach.c:13:

    bool test_vec_foreach(void);
    bool test_vec_foreach_idx(void);
    bool test_vec_foreach_ptr(void);
    bool test_vec_foreach_ptr_idx(void);
    bool test_vec_foreach_reverse(void);

In Vec.Foreach.c:14:

    bool test_vec_foreach_idx(void);
    bool test_vec_foreach_ptr(void);
    bool test_vec_foreach_ptr_idx(void);
    bool test_vec_foreach_reverse(void);
    bool test_vec_foreach_reverse_idx(void);

In Vec.Foreach.c:15:

    bool test_vec_foreach_ptr(void);
    bool test_vec_foreach_ptr_idx(void);
    bool test_vec_foreach_reverse(void);
    bool test_vec_foreach_reverse_idx(void);
    bool test_vec_foreach_ptr_reverse(void);

In Vec.Foreach.c:16:

    bool test_vec_foreach_ptr_idx(void);
    bool test_vec_foreach_reverse(void);
    bool test_vec_foreach_reverse_idx(void);
    bool test_vec_foreach_ptr_reverse(void);
    bool test_vec_foreach_ptr_reverse_idx(void);

In Vec.Foreach.c:17:

    bool test_vec_foreach_reverse(void);
    bool test_vec_foreach_reverse_idx(void);
    bool test_vec_foreach_ptr_reverse(void);
    bool test_vec_foreach_ptr_reverse_idx(void);

In Vec.Foreach.c:18:

    bool test_vec_foreach_reverse_idx(void);
    bool test_vec_foreach_ptr_reverse(void);
    bool test_vec_foreach_ptr_reverse_idx(void);
    
    bool test_vec_foreach_out_of_bounds_access(void);

In Vec.Foreach.c:20:

    bool test_vec_foreach_ptr_reverse_idx(void);
    
    bool test_vec_foreach_out_of_bounds_access(void);
    bool test_vec_foreach_idx_out_of_bounds_access(void);
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void);

In Vec.Foreach.c:21:

    
    bool test_vec_foreach_out_of_bounds_access(void);
    bool test_vec_foreach_idx_out_of_bounds_access(void);
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void);
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void);

In Vec.Foreach.c:22:

    bool test_vec_foreach_out_of_bounds_access(void);
    bool test_vec_foreach_idx_out_of_bounds_access(void);
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void);
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void);

In Vec.Foreach.c:23:

    bool test_vec_foreach_idx_out_of_bounds_access(void);
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void);
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void);

In Vec.Foreach.c:24:

    bool test_vec_foreach_idx_basic_out_of_bounds_access(void);
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_in_range_idx_out_of_bounds_access(void);

In Vec.Foreach.c:25:

    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_in_range_idx_out_of_bounds_access(void);

In Vec.Foreach.c:26:

    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void);
    bool test_vec_foreach_ptr_in_range_idx_out_of_bounds_access(void);
    
    // Test VecForeach macro

In Vec.Foreach.c:29:

    
    // Test VecForeach macro
    bool test_vec_foreach(void) {
    WriteFmt("Testing VecForeach\n");

In Vec.Foreach.c:68:

    
    // Test VecForeachIdx macro
    bool test_vec_foreach_idx(void) {
    WriteFmt("Testing VecForeachIdx\n");

In Vec.Foreach.c:104:

    
    // Test VecForeachPtr macro
    bool test_vec_foreach_ptr(void) {
    WriteFmt("Testing VecForeachPtr\n");

In Vec.Foreach.c:145:

    
    // Test VecForeachPtrIdx macro
    bool test_vec_foreach_ptr_idx(void) {
    WriteFmt("Testing VecForeachPtrIdx\n");

In Vec.Foreach.c:176:

    
    // Test VecForeachReverse macro
    bool test_vec_foreach_reverse(void) {
    WriteFmt("Testing VecForeachReverse\n");

In Vec.Foreach.c:209:

    
    // Test VecForeachReverseIdx macro
    bool test_vec_foreach_reverse_idx(void) {
    WriteFmt("Testing VecForeachReverseIdx\n");

In Vec.Foreach.c:236:

    
    // Test VecForeachPtrReverse macro
    bool test_vec_foreach_ptr_reverse(void) {
    WriteFmt("Testing VecForeachPtrReverse\n");

In Vec.Foreach.c:270:

    
    // Test VecForeachPtrReverseIdx macro
    bool test_vec_foreach_ptr_reverse_idx(void) {
    WriteFmt("Testing VecForeachPtrReverseIdx\n");

In Vec.Foreach.c:305:

    
    // Make idx go out of bounds during VecForeach by modifying vector during iteration
    bool test_vec_foreach_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeach where modification causes out of bounds access (should crash)\n");

In Vec.Foreach.c:345:

    
    // Make idx go out of bounds in VecForeachIdx by modifying vector during iteration
    bool test_vec_foreach_idx_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeachIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:383:

    
    // Make idx go out of bounds in VecForeachReverseIdx by modifying vector during iteration
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeachReverseIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:422:

    
    // Make idx go out of bounds in VecForeachPtrIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeachPtrIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:460:

    
    // Make idx go out of bounds in VecForeachPtrReverseIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeachPtrReverseIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:497:

    
    // Make idx go out of bounds in VecForeachPtrInRangeIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_in_range_idx_out_of_bounds_access(void) {
    WriteFmt("Testing VecForeachPtrInRangeIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:535:

    
    // Make idx go out of bounds in basic VecForeachIdx by modifying vector during iteration
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void) {
    WriteFmt("Testing basic VecForeachIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.c:573:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Foreach.Simple tests\n\n");

In Vec.Type.c:16:

    
    // Function prototypes
    bool test_vec_type_basic(void);
    bool test_vec_validate(void);

In Vec.Type.c:17:

    // Function prototypes
    bool test_vec_type_basic(void);
    bool test_vec_validate(void);
    
    // Test basic Vec type functionality

In Vec.Type.c:20:

    
    // Test basic Vec type functionality
    bool test_vec_type_basic(void) {
    WriteFmt("Testing basic Vec type functionality\n");

In Vec.Type.c:50:

    
    // Test ValidateVec macro
    bool test_vec_validate(void) {
    WriteFmt("Testing ValidateVec macro\n");

In Vec.Type.c:70:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Type tests\n\n");

In BitVec.Remove.c:11:

    
    // Function prototypes
    bool test_bitvec_pop(void);
    bool test_bitvec_remove_single(void);
    bool test_bitvec_remove_range(void);

In BitVec.Remove.c:12:

    // Function prototypes
    bool test_bitvec_pop(void);
    bool test_bitvec_remove_single(void);
    bool test_bitvec_remove_range(void);
    bool test_bitvec_remove_first(void);

In BitVec.Remove.c:13:

    bool test_bitvec_pop(void);
    bool test_bitvec_remove_single(void);
    bool test_bitvec_remove_range(void);
    bool test_bitvec_remove_first(void);
    bool test_bitvec_remove_last(void);

In BitVec.Remove.c:14:

    bool test_bitvec_remove_single(void);
    bool test_bitvec_remove_range(void);
    bool test_bitvec_remove_first(void);
    bool test_bitvec_remove_last(void);
    bool test_bitvec_remove_all(void);

In BitVec.Remove.c:15:

    bool test_bitvec_remove_range(void);
    bool test_bitvec_remove_first(void);
    bool test_bitvec_remove_last(void);
    bool test_bitvec_remove_all(void);
    bool test_bitvec_pop_edge_cases(void);

In BitVec.Remove.c:16:

    bool test_bitvec_remove_first(void);
    bool test_bitvec_remove_last(void);
    bool test_bitvec_remove_all(void);
    bool test_bitvec_pop_edge_cases(void);
    bool test_bitvec_remove_single_edge_cases(void);

In BitVec.Remove.c:17:

    bool test_bitvec_remove_last(void);
    bool test_bitvec_remove_all(void);
    bool test_bitvec_pop_edge_cases(void);
    bool test_bitvec_remove_single_edge_cases(void);
    bool test_bitvec_remove_range_edge_cases(void);

In BitVec.Remove.c:18:

    bool test_bitvec_remove_all(void);
    bool test_bitvec_pop_edge_cases(void);
    bool test_bitvec_remove_single_edge_cases(void);
    bool test_bitvec_remove_range_edge_cases(void);
    bool test_bitvec_remove_first_last_edge_cases(void);

In BitVec.Remove.c:19:

    bool test_bitvec_pop_edge_cases(void);
    bool test_bitvec_remove_single_edge_cases(void);
    bool test_bitvec_remove_range_edge_cases(void);
    bool test_bitvec_remove_first_last_edge_cases(void);
    bool test_bitvec_remove_all_edge_cases(void);

In BitVec.Remove.c:20:

    bool test_bitvec_remove_single_edge_cases(void);
    bool test_bitvec_remove_range_edge_cases(void);
    bool test_bitvec_remove_first_last_edge_cases(void);
    bool test_bitvec_remove_all_edge_cases(void);
    bool test_bitvec_remove_null_failures(void);

In BitVec.Remove.c:21:

    bool test_bitvec_remove_range_edge_cases(void);
    bool test_bitvec_remove_first_last_edge_cases(void);
    bool test_bitvec_remove_all_edge_cases(void);
    bool test_bitvec_remove_null_failures(void);
    bool test_bitvec_remove_range_null_failures(void);

In BitVec.Remove.c:22:

    bool test_bitvec_remove_first_last_edge_cases(void);
    bool test_bitvec_remove_all_edge_cases(void);
    bool test_bitvec_remove_null_failures(void);
    bool test_bitvec_remove_range_null_failures(void);
    bool test_bitvec_remove_invalid_range_failures(void);

In BitVec.Remove.c:23:

    bool test_bitvec_remove_all_edge_cases(void);
    bool test_bitvec_remove_null_failures(void);
    bool test_bitvec_remove_range_null_failures(void);
    bool test_bitvec_remove_invalid_range_failures(void);

In BitVec.Remove.c:24:

    bool test_bitvec_remove_null_failures(void);
    bool test_bitvec_remove_range_null_failures(void);
    bool test_bitvec_remove_invalid_range_failures(void);
    
    // Test BitVecPop function

In BitVec.Remove.c:27:

    
    // Test BitVecPop function
    bool test_bitvec_pop(void) {
    WriteFmt("Testing BitVecPop\n");

In BitVec.Remove.c:61:

    
    // Test BitVecRemove single bit function
    bool test_bitvec_remove_single(void) {
    WriteFmt("Testing BitVecRemove (single bit)\n");

In BitVec.Remove.c:97:

    
    // Test BitVecRemoveRange function
    bool test_bitvec_remove_range(void) {
    WriteFmt("Testing BitVecRemoveRange\n");

In BitVec.Remove.c:126:

    
    // Test BitVecRemoveFirst function
    bool test_bitvec_remove_first(void) {
    WriteFmt("Testing BitVecRemoveFirst\n");

In BitVec.Remove.c:163:

    
    // Test BitVecRemoveLast function
    bool test_bitvec_remove_last(void) {
    WriteFmt("Testing BitVecRemoveLast\n");

In BitVec.Remove.c:201:

    
    // Test BitVecRemoveAll function
    bool test_bitvec_remove_all(void) {
    WriteFmt("Testing BitVecRemoveAll\n");

In BitVec.Remove.c:238:

    
    // Edge case tests
    bool test_bitvec_pop_edge_cases(void) {
    WriteFmt("Testing BitVecPop edge cases\n");

In BitVec.Remove.c:263:

    }
    
    bool test_bitvec_remove_single_edge_cases(void) {
    WriteFmt("Testing BitVecRemove edge cases\n");

In BitVec.Remove.c:288:

    }
    
    bool test_bitvec_remove_range_edge_cases(void) {
    WriteFmt("Testing BitVecRemoveRange edge cases\n");

In BitVec.Remove.c:318:

    }
    
    bool test_bitvec_remove_first_last_edge_cases(void) {
    WriteFmt("Testing BitVecRemoveFirst/Last edge cases\n");

In BitVec.Remove.c:354:

    }
    
    bool test_bitvec_remove_all_edge_cases(void) {
    WriteFmt("Testing BitVecRemoveAll edge cases\n");

In BitVec.Remove.c:390:

    
    // Deadend tests
    bool test_bitvec_remove_null_failures(void) {
    WriteFmt("Testing BitVec remove NULL pointer handling\n");

In BitVec.Remove.c:399:

    }
    
    bool test_bitvec_remove_range_null_failures(void) {
    WriteFmt("Testing BitVec remove range NULL handling\n");

In BitVec.Remove.c:408:

    }
    
    bool test_bitvec_remove_invalid_range_failures(void) {
    WriteFmt("Testing BitVec remove invalid range handling\n");

In BitVec.Remove.c:420:

    }
    
    bool test_bitvec_pop_bounds_failures(void) {
    WriteFmt("Testing BitVec pop bounds checking\n");

In BitVec.Remove.c:432:

    }
    
    bool test_bitvec_remove_bounds_failures(void) {
    WriteFmt("Testing BitVec remove bounds checking\n");

In BitVec.Remove.c:444:

    }
    
    bool test_bitvec_remove_range_bounds_failures(void) {
    WriteFmt("Testing BitVec remove range bounds checking\n");

In BitVec.Remove.c:457:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Remove tests\n\n");

In BitVec.Compare.c:10:

    
    // Function prototypes
    bool test_bitvec_equals(void);
    bool test_bitvec_compare(void);
    bool test_bitvec_lex_compare(void);

In BitVec.Compare.c:11:

    // Function prototypes
    bool test_bitvec_equals(void);
    bool test_bitvec_compare(void);
    bool test_bitvec_lex_compare(void);
    bool test_bitvec_numerical_compare(void);

In BitVec.Compare.c:12:

    bool test_bitvec_equals(void);
    bool test_bitvec_compare(void);
    bool test_bitvec_lex_compare(void);
    bool test_bitvec_numerical_compare(void);
    bool test_bitvec_weight_compare(void);

In BitVec.Compare.c:13:

    bool test_bitvec_compare(void);
    bool test_bitvec_lex_compare(void);
    bool test_bitvec_numerical_compare(void);
    bool test_bitvec_weight_compare(void);
    bool test_bitvec_signed_compare(void);

In BitVec.Compare.c:14:

    bool test_bitvec_lex_compare(void);
    bool test_bitvec_numerical_compare(void);
    bool test_bitvec_weight_compare(void);
    bool test_bitvec_signed_compare(void);
    bool test_bitvec_is_subset(void);

In BitVec.Compare.c:15:

    bool test_bitvec_numerical_compare(void);
    bool test_bitvec_weight_compare(void);
    bool test_bitvec_signed_compare(void);
    bool test_bitvec_is_subset(void);
    bool test_bitvec_is_superset(void);

In BitVec.Compare.c:16:

    bool test_bitvec_weight_compare(void);
    bool test_bitvec_signed_compare(void);
    bool test_bitvec_is_subset(void);
    bool test_bitvec_is_superset(void);
    bool test_bitvec_overlaps(void);

In BitVec.Compare.c:17:

    bool test_bitvec_signed_compare(void);
    bool test_bitvec_is_subset(void);
    bool test_bitvec_is_superset(void);
    bool test_bitvec_overlaps(void);
    bool test_bitvec_disjoint_intersects(void);

In BitVec.Compare.c:18:

    bool test_bitvec_is_subset(void);
    bool test_bitvec_is_superset(void);
    bool test_bitvec_overlaps(void);
    bool test_bitvec_disjoint_intersects(void);
    bool test_bitvec_equals_range(void);

In BitVec.Compare.c:19:

    bool test_bitvec_is_superset(void);
    bool test_bitvec_overlaps(void);
    bool test_bitvec_disjoint_intersects(void);
    bool test_bitvec_equals_range(void);
    bool test_bitvec_compare_range(void);

In BitVec.Compare.c:20:

    bool test_bitvec_overlaps(void);
    bool test_bitvec_disjoint_intersects(void);
    bool test_bitvec_equals_range(void);
    bool test_bitvec_compare_range(void);
    bool test_bitvec_less_than_functions(void);

In BitVec.Compare.c:21:

    bool test_bitvec_disjoint_intersects(void);
    bool test_bitvec_equals_range(void);
    bool test_bitvec_compare_range(void);
    bool test_bitvec_less_than_functions(void);
    bool test_bitvec_is_sorted(void);

In BitVec.Compare.c:22:

    bool test_bitvec_equals_range(void);
    bool test_bitvec_compare_range(void);
    bool test_bitvec_less_than_functions(void);
    bool test_bitvec_is_sorted(void);
    bool test_bitvec_compare_edge_cases(void);

In BitVec.Compare.c:23:

    bool test_bitvec_compare_range(void);
    bool test_bitvec_less_than_functions(void);
    bool test_bitvec_is_sorted(void);
    bool test_bitvec_compare_edge_cases(void);
    bool test_bitvec_set_operations_edge_cases(void);

In BitVec.Compare.c:24:

    bool test_bitvec_less_than_functions(void);
    bool test_bitvec_is_sorted(void);
    bool test_bitvec_compare_edge_cases(void);
    bool test_bitvec_set_operations_edge_cases(void);
    bool test_bitvec_comprehensive_comparison(void);

In BitVec.Compare.c:25:

    bool test_bitvec_is_sorted(void);
    bool test_bitvec_compare_edge_cases(void);
    bool test_bitvec_set_operations_edge_cases(void);
    bool test_bitvec_comprehensive_comparison(void);
    bool test_bitvec_large_scale_comparison(void);

In BitVec.Compare.c:26:

    bool test_bitvec_compare_edge_cases(void);
    bool test_bitvec_set_operations_edge_cases(void);
    bool test_bitvec_comprehensive_comparison(void);
    bool test_bitvec_large_scale_comparison(void);
    bool test_bitvec_compare_null_failures(void);

In BitVec.Compare.c:27:

    bool test_bitvec_set_operations_edge_cases(void);
    bool test_bitvec_comprehensive_comparison(void);
    bool test_bitvec_large_scale_comparison(void);
    bool test_bitvec_compare_null_failures(void);
    bool test_bitvec_subset_null_failures(void);

In BitVec.Compare.c:28:

    bool test_bitvec_comprehensive_comparison(void);
    bool test_bitvec_large_scale_comparison(void);
    bool test_bitvec_compare_null_failures(void);
    bool test_bitvec_subset_null_failures(void);
    bool test_bitvec_range_null_failures(void);

In BitVec.Compare.c:29:

    bool test_bitvec_large_scale_comparison(void);
    bool test_bitvec_compare_null_failures(void);
    bool test_bitvec_subset_null_failures(void);
    bool test_bitvec_range_null_failures(void);
    bool test_bitvec_range_bounds_failures(void);

In BitVec.Compare.c:30:

    bool test_bitvec_compare_null_failures(void);
    bool test_bitvec_subset_null_failures(void);
    bool test_bitvec_range_null_failures(void);
    bool test_bitvec_range_bounds_failures(void);
    bool test_bitvec_sorted_null_failures(void);

In BitVec.Compare.c:31:

    bool test_bitvec_subset_null_failures(void);
    bool test_bitvec_range_null_failures(void);
    bool test_bitvec_range_bounds_failures(void);
    bool test_bitvec_sorted_null_failures(void);

In BitVec.Compare.c:32:

    bool test_bitvec_range_null_failures(void);
    bool test_bitvec_range_bounds_failures(void);
    bool test_bitvec_sorted_null_failures(void);
    
    // Test BitVecEquals function

In BitVec.Compare.c:35:

    
    // Test BitVecEquals function
    bool test_bitvec_equals(void) {
    WriteFmt("Testing BitVecEquals\n");

In BitVec.Compare.c:78:

    
    // Test BitVecCompare function
    bool test_bitvec_compare(void) {
    WriteFmt("Testing BitVecCompare\n");

In BitVec.Compare.c:114:

    
    // Test BitVecLexCompare function
    bool test_bitvec_lex_compare(void) {
    WriteFmt("Testing BitVecLexCompare\n");

In BitVec.Compare.c:148:

    
    // Test BitVecNumericalCompare function
    bool test_bitvec_numerical_compare(void) {
    WriteFmt("Testing BitVecNumericalCompare\n");

In BitVec.Compare.c:184:

    
    // Test BitVecWeightCompare function
    bool test_bitvec_weight_compare(void) {
    WriteFmt("Testing BitVecWeightCompare\n");

In BitVec.Compare.c:220:

    
    // Test BitVecIsSubset function
    bool test_bitvec_is_subset(void) {
    WriteFmt("Testing BitVecIsSubset\n");

In BitVec.Compare.c:263:

    
    // Test BitVecSignedCompare function
    bool test_bitvec_signed_compare(void) {
    WriteFmt("Testing BitVecSignedCompare\n");

In BitVec.Compare.c:306:

    
    // Test BitVecIsSuperset function
    bool test_bitvec_is_superset(void) {
    WriteFmt("Testing BitVecIsSuperset\n");

In BitVec.Compare.c:349:

    
    // Test BitVecOverlaps function
    bool test_bitvec_overlaps(void) {
    WriteFmt("Testing BitVecOverlaps\n");

In BitVec.Compare.c:390:

    
    // Test BitVecDisjoint and BitVecIntersects functions
    bool test_bitvec_disjoint_intersects(void) {
    WriteFmt("Testing BitVecDisjoint and BitVecIntersects\n");

In BitVec.Compare.c:434:

    
    // Test BitVecEqualsRange function
    bool test_bitvec_equals_range(void) {
    WriteFmt("Testing BitVecEqualsRange\n");

In BitVec.Compare.c:476:

    
    // Test BitVecCompareRange function
    bool test_bitvec_compare_range(void) {
    WriteFmt("Testing BitVecCompareRange\n");

In BitVec.Compare.c:523:

    
    // Test BitVecIsLexicographicallyLess and BitVecIsNumericallyLess
    bool test_bitvec_less_than_functions(void) {
    WriteFmt("Testing BitVecIsLexicographicallyLess and BitVecIsNumericallyLess\n");

In BitVec.Compare.c:563:

    
    // Test BitVecIsSorted function
    bool test_bitvec_is_sorted(void) {
    WriteFmt("Testing BitVecIsSorted\n");

In BitVec.Compare.c:607:

    
    // Edge case tests
    bool test_bitvec_compare_edge_cases(void) {
    WriteFmt("Testing BitVec compare edge cases\n");

In BitVec.Compare.c:643:

    }
    
    bool test_bitvec_set_operations_edge_cases(void) {
    WriteFmt("Testing BitVec set operations edge cases\n");

In BitVec.Compare.c:675:

    
    // Comprehensive comparison testing with cross-validation
    bool test_bitvec_comprehensive_comparison(void) {
    WriteFmt("Testing BitVec comprehensive comparison operations\n");

In BitVec.Compare.c:746:

    
    // Large-scale testing with stress patterns
    bool test_bitvec_large_scale_comparison(void) {
    WriteFmt("Testing BitVec large-scale comparison operations\n");

In BitVec.Compare.c:809:

    
    // Deadend tests
    bool test_bitvec_compare_null_failures(void) {
    WriteFmt("Testing BitVec compare NULL pointer handling\n");

In BitVec.Compare.c:821:

    }
    
    bool test_bitvec_subset_null_failures(void) {
    WriteFmt("Testing BitVec subset NULL handling\n");

In BitVec.Compare.c:830:

    }
    
    bool test_bitvec_range_null_failures(void) {
    WriteFmt("Testing BitVec range operations NULL handling\n");

In BitVec.Compare.c:842:

    }
    
    bool test_bitvec_range_bounds_failures(void) {
    WriteFmt("Testing BitVec range operations bounds checking\n");

In BitVec.Compare.c:862:

    }
    
    bool test_bitvec_sorted_null_failures(void) {
    WriteFmt("Testing BitVec sorted operations NULL handling\n");

In BitVec.Compare.c:872:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Compare tests\n\n");

In BitVec.Foreach.Simple.c:10:

    
    // Function prototypes
    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);

In BitVec.Foreach.Simple.c:11:

    // Function prototypes
    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);

In BitVec.Foreach.Simple.c:12:

    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);

In BitVec.Foreach.Simple.c:13:

    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);

In BitVec.Foreach.Simple.c:14:

    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);

In BitVec.Foreach.Simple.c:15:

    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);

In BitVec.Foreach.Simple.c:16:

    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);

In BitVec.Foreach.Simple.c:17:

    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);

In BitVec.Foreach.Simple.c:18:

    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);

In BitVec.Foreach.Simple.c:19:

    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);

In BitVec.Foreach.Simple.c:20:

    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);

In BitVec.Foreach.Simple.c:21:

    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);
    
    // BitVecRunLengths test prototypes

In BitVec.Foreach.Simple.c:24:

    
    // BitVecRunLengths test prototypes
    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);

In BitVec.Foreach.Simple.c:25:

    // BitVecRunLengths test prototypes
    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);

In BitVec.Foreach.Simple.c:26:

    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);

In BitVec.Foreach.Simple.c:27:

    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);

In BitVec.Foreach.Simple.c:28:

    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);

In BitVec.Foreach.Simple.c:29:

    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.Simple.c:30:

    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.Simple.c:31:

    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.Simple.c:35:

    
    // Test BitVecForeachIdx macro
    bool test_bitvec_foreach_idx(void) {
    WriteFmt("Testing BitVecForeachIdx macro\n");

In BitVec.Foreach.Simple.c:68:

    
    // Test BitVecForeach macro
    bool test_bitvec_foreach(void) {
    WriteFmt("Testing BitVecForeach macro\n");

In BitVec.Foreach.Simple.c:99:

    
    // Test BitVecForeachReverseIdx macro
    bool test_bitvec_foreach_reverse_idx(void) {
    WriteFmt("Testing BitVecForeachReverseIdx macro\n");

In BitVec.Foreach.Simple.c:130:

    
    // Test BitVecForeachReverse macro
    bool test_bitvec_foreach_reverse(void) {
    WriteFmt("Testing BitVecForeachReverse macro\n");

In BitVec.Foreach.Simple.c:160:

    
    // Test BitVecForeachInRangeIdx macro
    bool test_bitvec_foreach_in_range_idx(void) {
    WriteFmt("Testing BitVecForeachInRangeIdx macro\n");

In BitVec.Foreach.Simple.c:196:

    
    // Test BitVecForeachInRange macro
    bool test_bitvec_foreach_in_range(void) {
    WriteFmt("Testing BitVecForeachInRange macro\n");

In BitVec.Foreach.Simple.c:231:

    
    // Edge case tests
    bool test_bitvec_foreach_edge_cases(void) {
    WriteFmt("Testing BitVec foreach edge cases\n");

In BitVec.Foreach.Simple.c:240:

    // Test foreach on empty bitvec
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++; // Should not execute
    }

In BitVec.Foreach.Simple.c:262:

    count = 0;
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.Simple.c:271:

    }
    
    bool test_bitvec_foreach_idx_edge_cases(void) {
    WriteFmt("Testing BitVec foreach idx edge cases\n");

In BitVec.Foreach.Simple.c:280:

    // Test foreach idx on empty bitvec
    BitVecForeachIdx(&bv, bit, idx) {
    (void)bit;
    result = false; // Should not execute
    }

In BitVec.Foreach.Simple.c:301:

    u64 expected_idx = 0;
    BitVecForeachIdx(&bv, bit, idx) {
    (void)bit;
    result = result && (idx == expected_idx);
    expected_idx++;

In BitVec.Foreach.Simple.c:310:

    }
    
    bool test_bitvec_foreach_reverse_edge_cases(void) {
    WriteFmt("Testing BitVec foreach reverse edge cases\n");

In BitVec.Foreach.Simple.c:318:

    // Test reverse foreach on empty bitvec
    BitVecForeachReverse(&bv, bit) {
    (void)bit;
    result = false; // Should not execute
    }

In BitVec.Foreach.Simple.c:348:

    }
    
    bool test_bitvec_foreach_range_edge_cases(void) {
    WriteFmt("Testing BitVec foreach range edge cases\n");

In BitVec.Foreach.Simple.c:362:

    int count = 0;
    BitVecForeachInRange(&bv, bit, 5, 5) {
    (void)bit;
    count++; // Should not execute
    }

In BitVec.Foreach.Simple.c:378:

    count = 0;
    BitVecForeachInRange(&bv, bit, 0, 2) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.Simple.c:386:

    count = 0;
    BitVecForeachInRange(&bv, bit, 8, 10) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.Simple.c:395:

    }
    
    bool test_bitvec_foreach_stress_test(void) {
    WriteFmt("Testing BitVec foreach stress test\n");

In BitVec.Foreach.Simple.c:412:

    
    BitVecForeach(&bv, bitval) {
    (void)bitval;
    count1++;
    }

In BitVec.Foreach.Simple.c:416:

    }
    BitVecForeachIdx(&bv, bitval, i) {
    (void)bitval;
    count2++;
    }

In BitVec.Foreach.Simple.c:420:

    }
    BitVecForeachReverse(&bv, bitval) {
    (void)bitval;
    count3++;
    }

In BitVec.Foreach.Simple.c:424:

    }
    BitVecForeachReverseIdx(&bv, bitval, i) {
    (void)bitval;
    count4++;
    }

In BitVec.Foreach.Simple.c:441:

    // BitVecRunLengths test implementations
    
    bool test_bitvec_run_lengths_basic(void) {
    WriteFmt("Testing BitVecRunLengths basic functionality\n");

In BitVec.Foreach.Simple.c:477:

    }
    
    bool test_bitvec_run_lengths_edge_cases(void) {
    WriteFmt("Testing BitVecRunLengths edge cases\n");

In BitVec.Foreach.Simple.c:535:

    }
    
    bool test_bitvec_run_lengths_boundary_conditions(void) {
    WriteFmt("Testing BitVecRunLengths boundary conditions\n");

In BitVec.Foreach.Simple.c:572:

    }
    
    bool test_bitvec_run_lengths_stress_test(void) {
    WriteFmt("Testing BitVecRunLengths stress test\n");

In BitVec.Foreach.Simple.c:635:

    
    // Main function that runs all simple tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Foreach.Simple tests\n\n");

In Str.Convert.c:12:

    
    // Function prototypes
    bool test_str_from_u64(void);
    bool test_str_from_i64(void);
    bool test_str_from_f64(void);

In Str.Convert.c:13:

    // Function prototypes
    bool test_str_from_u64(void);
    bool test_str_from_i64(void);
    bool test_str_from_f64(void);
    bool test_str_to_u64(void);

In Str.Convert.c:14:

    bool test_str_from_u64(void);
    bool test_str_from_i64(void);
    bool test_str_from_f64(void);
    bool test_str_to_u64(void);
    bool test_str_to_i64(void);

In Str.Convert.c:15:

    bool test_str_from_i64(void);
    bool test_str_from_f64(void);
    bool test_str_to_u64(void);
    bool test_str_to_i64(void);
    bool test_str_to_f64(void);

In Str.Convert.c:16:

    bool test_str_from_f64(void);
    bool test_str_to_u64(void);
    bool test_str_to_i64(void);
    bool test_str_to_f64(void);
    bool test_str_round_trip_conversions(void);

In Str.Convert.c:17:

    bool test_str_to_u64(void);
    bool test_str_to_i64(void);
    bool test_str_to_f64(void);
    bool test_str_round_trip_conversions(void);
    bool test_str_edge_case_conversions(void);

In Str.Convert.c:18:

    bool test_str_to_i64(void);
    bool test_str_to_f64(void);
    bool test_str_round_trip_conversions(void);
    bool test_str_edge_case_conversions(void);
    bool test_str_precision_limits(void);

In Str.Convert.c:19:

    bool test_str_to_f64(void);
    bool test_str_round_trip_conversions(void);
    bool test_str_edge_case_conversions(void);
    bool test_str_precision_limits(void);
    bool test_str_all_base_support(void);

In Str.Convert.c:20:

    bool test_str_round_trip_conversions(void);
    bool test_str_edge_case_conversions(void);
    bool test_str_precision_limits(void);
    bool test_str_all_base_support(void);
    bool test_str_large_scale_conversions(void);

In Str.Convert.c:21:

    bool test_str_edge_case_conversions(void);
    bool test_str_precision_limits(void);
    bool test_str_all_base_support(void);
    bool test_str_large_scale_conversions(void);
    bool test_str_conversion_null_failures(void);

In Str.Convert.c:22:

    bool test_str_precision_limits(void);
    bool test_str_all_base_support(void);
    bool test_str_large_scale_conversions(void);
    bool test_str_conversion_null_failures(void);
    bool test_str_conversion_bounds_failures(void);

In Str.Convert.c:23:

    bool test_str_all_base_support(void);
    bool test_str_large_scale_conversions(void);
    bool test_str_conversion_null_failures(void);
    bool test_str_conversion_bounds_failures(void);
    bool test_str_conversion_invalid_input_failures(void);

In Str.Convert.c:24:

    bool test_str_large_scale_conversions(void);
    bool test_str_conversion_null_failures(void);
    bool test_str_conversion_bounds_failures(void);
    bool test_str_conversion_invalid_input_failures(void);

In Str.Convert.c:25:

    bool test_str_conversion_null_failures(void);
    bool test_str_conversion_bounds_failures(void);
    bool test_str_conversion_invalid_input_failures(void);
    
    // Test StrFromU64 function

In Str.Convert.c:28:

    
    // Test StrFromU64 function
    bool test_str_from_u64(void) {
    WriteFmt("Testing StrFromU64\n");

In Str.Convert.c:91:

    
    // Test StrFromI64 function
    bool test_str_from_i64(void) {
    WriteFmt("Testing StrFromI64\n");

In Str.Convert.c:147:

    
    // Test StrFromF64 function
    bool test_str_from_f64(void) {
    WriteFmt("Testing StrFromF64\n");

In Str.Convert.c:228:

    
    // Test StrToU64 function
    bool test_str_to_u64(void) {
    WriteFmt("Testing StrToU64\n");

In Str.Convert.c:285:

    
    // Test StrToI64 function
    bool test_str_to_i64(void) {
    WriteFmt("Testing StrToI64\n");

In Str.Convert.c:329:

    
    // Test StrToF64 function
    bool test_str_to_f64(void) {
    WriteFmt("Testing StrToF64\n");

In Str.Convert.c:391:

    
    // Round-trip conversion tests
    bool test_str_round_trip_conversions(void) {
    WriteFmt("Testing Str round-trip conversions\n");

In Str.Convert.c:470:

    
    // Edge case conversion tests
    bool test_str_edge_case_conversions(void) {
    WriteFmt("Testing Str edge case conversions\n");

In Str.Convert.c:555:

    
    // Precision limits testing
    bool test_str_precision_limits(void) {
    WriteFmt("Testing Str precision limits\n");

In Str.Convert.c:622:

    
    // Large-scale conversion tests
    bool test_str_all_base_support(void) {
    WriteFmt("Testing Str all bases 2-36 support\n");

In Str.Convert.c:692:

    }
    
    bool test_str_large_scale_conversions(void) {
    WriteFmt("Testing Str large-scale conversions\n");

In Str.Convert.c:759:

    
    // Deadend tests for NULL pointer handling
    bool test_str_conversion_null_failures(void) {
    WriteFmt("Testing Str conversion NULL pointer handling\n");

In Str.Convert.c:769:

    }
    
    bool test_str_conversion_bounds_failures(void) {
    WriteFmt("Testing Str conversion bounds failures\n");

In Str.Convert.c:779:

    }
    
    bool test_str_conversion_invalid_input_failures(void) {
    WriteFmt("Testing Str conversion invalid input failures\n");

In Str.Convert.c:790:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Convert tests\n\n");

In Io.Read.c:29:

    
    // Function prototypes
    bool test_integer_decimal_reading(void);
    bool test_integer_hex_reading(void);
    bool test_integer_binary_reading(void);

In Io.Read.c:30:

    // Function prototypes
    bool test_integer_decimal_reading(void);
    bool test_integer_hex_reading(void);
    bool test_integer_binary_reading(void);
    bool test_integer_octal_reading(void);

In Io.Read.c:31:

    bool test_integer_decimal_reading(void);
    bool test_integer_hex_reading(void);
    bool test_integer_binary_reading(void);
    bool test_integer_octal_reading(void);
    bool test_float_basic_reading(void);

In Io.Read.c:32:

    bool test_integer_hex_reading(void);
    bool test_integer_binary_reading(void);
    bool test_integer_octal_reading(void);
    bool test_float_basic_reading(void);
    bool test_float_scientific_reading(void);

In Io.Read.c:33:

    bool test_integer_binary_reading(void);
    bool test_integer_octal_reading(void);
    bool test_float_basic_reading(void);
    bool test_float_scientific_reading(void);
    bool test_string_reading(void);

In Io.Read.c:34:

    bool test_integer_octal_reading(void);
    bool test_float_basic_reading(void);
    bool test_float_scientific_reading(void);
    bool test_string_reading(void);
    bool test_multiple_arguments_reading(void);

In Io.Read.c:35:

    bool test_float_basic_reading(void);
    bool test_float_scientific_reading(void);
    bool test_string_reading(void);
    bool test_multiple_arguments_reading(void);
    bool test_error_handling_reading(void);

In Io.Read.c:36:

    bool test_float_scientific_reading(void);
    bool test_string_reading(void);
    bool test_multiple_arguments_reading(void);
    bool test_error_handling_reading(void);
    bool test_character_ordinal_reading(void);

In Io.Read.c:37:

    bool test_string_reading(void);
    bool test_multiple_arguments_reading(void);
    bool test_error_handling_reading(void);
    bool test_character_ordinal_reading(void);
    bool test_string_case_conversion_reading(void);

In Io.Read.c:38:

    bool test_multiple_arguments_reading(void);
    bool test_error_handling_reading(void);
    bool test_character_ordinal_reading(void);
    bool test_string_case_conversion_reading(void);
    bool test_bitvec_reading(void);

In Io.Read.c:39:

    bool test_error_handling_reading(void);
    bool test_character_ordinal_reading(void);
    bool test_string_case_conversion_reading(void);
    bool test_bitvec_reading(void);

In Io.Read.c:40:

    bool test_character_ordinal_reading(void);
    bool test_string_case_conversion_reading(void);
    bool test_bitvec_reading(void);
    
    // Test decimal integer reading

In Io.Read.c:43:

    
    // Test decimal integer reading
    bool test_integer_decimal_reading(void) {
    WriteFmt("Testing integer decimal reading\n");

In Io.Read.c:144:

    
    // Test hexadecimal integer reading
    bool test_integer_hex_reading(void) {
    WriteFmt("Testing integer hexadecimal reading\n");

In Io.Read.c:181:

    
    // Test binary integer reading
    bool test_integer_binary_reading(void) {
    WriteFmt("Testing integer binary reading\n");

In Io.Read.c:208:

    
    // Test octal integer reading
    bool test_integer_octal_reading(void) {
    WriteFmt("Testing integer octal reading\n");

In Io.Read.c:240:

    
    // Test basic float reading
    bool test_float_basic_reading(void) {
    WriteFmt("Testing basic float reading\n");

In Io.Read.c:285:

    
    // Test scientific notation reading
    bool test_float_scientific_reading(void) {
    WriteFmt("Testing scientific notation reading\n");

In Io.Read.c:332:

    
    // Test string reading
    bool test_string_reading(void) {
    WriteFmt("Testing string reading\n");

In Io.Read.c:363:

    
    // Test reading multiple arguments
    bool test_multiple_arguments_reading(void) {
    WriteFmt("Testing multiple arguments reading\n");

In Io.Read.c:399:

    
    // Test error handling
    bool test_error_handling_reading(void) {
    WriteFmt("Testing error handling for reading\n");

In Io.Read.c:431:

    
    // Test character ordinal reading with :c format specifier
    bool test_character_ordinal_reading(void) {
    WriteFmt("Testing character ordinal reading with :c format specifier\n");

In Io.Read.c:611:

    
    // Test string case conversion with :a and :A format specifiers
    bool test_string_case_conversion_reading(void) {
    WriteFmt("Testing string case conversion with :a and :A format specifiers\n");

In Io.Read.c:817:

    
    // Test BitVec reading
    bool test_bitvec_reading(void) {
    WriteFmt("Testing BitVec reading\n");

In Io.Read.c:885:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting format reader tests\n\n");

In Vec.Memory.c:10:

    
    // Function prototypes
    bool test_vec_try_reduce_space(void);
    bool test_vec_resize(void);
    bool test_vec_reserve(void);

In Vec.Memory.c:11:

    // Function prototypes
    bool test_vec_try_reduce_space(void);
    bool test_vec_resize(void);
    bool test_vec_reserve(void);
    bool test_vec_clear(void);

In Vec.Memory.c:12:

    bool test_vec_try_reduce_space(void);
    bool test_vec_resize(void);
    bool test_vec_reserve(void);
    bool test_vec_clear(void);

In Vec.Memory.c:13:

    bool test_vec_resize(void);
    bool test_vec_reserve(void);
    bool test_vec_clear(void);
    
    // Test VecTryReduceSpace function

In Vec.Memory.c:16:

    
    // Test VecTryReduceSpace function
    bool test_vec_try_reduce_space(void) {
    WriteFmt("Testing VecTryReduceSpace\n");

In Vec.Memory.c:53:

    
    // Test VecResize function
    bool test_vec_resize(void) {
    WriteFmt("Testing VecResize\n");

In Vec.Memory.c:98:

    
    // Test VecReserve function
    bool test_vec_reserve(void) {
    WriteFmt("Testing VecReserve\n");

In Vec.Memory.c:142:

    
    // Test VecClear function
    bool test_vec_clear(void) {
    WriteFmt("Testing VecClear\n");

In Vec.Memory.c:180:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Memory tests\n\n");

In BitVec.BitWise.Simple.c:11:

    
    // Function prototypes
    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);

In BitVec.BitWise.Simple.c:12:

    // Function prototypes
    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);

In BitVec.BitWise.Simple.c:13:

    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);

In BitVec.BitWise.Simple.c:14:

    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);

In BitVec.BitWise.Simple.c:15:

    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);

In BitVec.BitWise.Simple.c:16:

    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);

In BitVec.BitWise.Simple.c:17:

    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);

In BitVec.BitWise.Simple.c:18:

    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);

In BitVec.BitWise.Simple.c:19:

    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);

In BitVec.BitWise.Simple.c:20:

    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);

In BitVec.BitWise.Simple.c:21:

    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);

In BitVec.BitWise.Simple.c:22:

    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);

In BitVec.BitWise.Simple.c:23:

    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);

In BitVec.BitWise.Simple.c:24:

    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);

In BitVec.BitWise.Simple.c:25:

    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);

In BitVec.BitWise.Simple.c:26:

    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);

In BitVec.BitWise.Simple.c:27:

    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);

In BitVec.BitWise.Simple.c:28:

    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);

In BitVec.BitWise.Simple.c:29:

    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);
    
    // Test BitVecAnd function

In BitVec.BitWise.Simple.c:32:

    
    // Test BitVecAnd function
    bool test_bitvec_and(void) {
    WriteFmt("Testing BitVecAnd\n");

In BitVec.BitWise.Simple.c:70:

    
    // Test BitVecOr function
    bool test_bitvec_or(void) {
    WriteFmt("Testing BitVecOr\n");

In BitVec.BitWise.Simple.c:108:

    
    // Test BitVecXor function
    bool test_bitvec_xor(void) {
    WriteFmt("Testing BitVecXor\n");

In BitVec.BitWise.Simple.c:146:

    
    // Test BitVecNot function
    bool test_bitvec_not(void) {
    WriteFmt("Testing BitVecNot\n");

In BitVec.BitWise.Simple.c:176:

    
    // Test BitVecShiftLeft function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_left(void) {
    WriteFmt("Testing BitVecShiftLeft\n");

In BitVec.BitWise.Simple.c:217:

    
    // Test BitVecShiftRight function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_right(void) {
    WriteFmt("Testing BitVecShiftRight\n");

In BitVec.BitWise.Simple.c:251:

    
    // Test BitVecRotateLeft function
    bool test_bitvec_rotate_left(void) {
    WriteFmt("Testing BitVecRotateLeft\n");

In BitVec.BitWise.Simple.c:279:

    
    // Test BitVecRotateRight function
    bool test_bitvec_rotate_right(void) {
    WriteFmt("Testing BitVecRotateRight\n");

In BitVec.BitWise.Simple.c:307:

    
    // Test BitVecReverse function
    bool test_bitvec_reverse(void) {
    WriteFmt("Testing BitVecReverse\n");

In BitVec.BitWise.Simple.c:335:

    
    // Edge case tests
    bool test_bitvec_shift_edge_cases(void) {
    WriteFmt("Testing BitVec shift edge cases\n");

In BitVec.BitWise.Simple.c:371:

    }
    
    bool test_bitvec_rotate_edge_cases(void) {
    WriteFmt("Testing BitVec rotate edge cases\n");

In BitVec.BitWise.Simple.c:399:

    }
    
    bool test_bitvec_bitwise_ops_edge_cases(void) {
    WriteFmt("Testing BitVec bitwise operations edge cases\n");

In BitVec.BitWise.Simple.c:438:

    }
    
    bool test_bitvec_reverse_edge_cases(void) {
    WriteFmt("Testing BitVecReverse edge cases\n");

In BitVec.BitWise.Simple.c:472:

    
    // NEW: Comprehensive bitwise operations testing
    bool test_bitvec_bitwise_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive bitwise operations\n");

In BitVec.BitWise.Simple.c:538:

    
    // NEW: Comprehensive shift testing
    bool test_bitvec_shift_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive shift operations\n");

In BitVec.BitWise.Simple.c:604:

    
    // NEW: Comprehensive rotate testing
    bool test_bitvec_rotate_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive rotate operations\n");

In BitVec.BitWise.Simple.c:666:

    
    // NEW: Identity operations testing
    bool test_bitvec_bitwise_identity_operations(void) {
    WriteFmt("Testing BitVec bitwise identity operations\n");

In BitVec.BitWise.Simple.c:760:

    
    // NEW: Commutative properties testing
    bool test_bitvec_bitwise_commutative_properties(void) {
    WriteFmt("Testing BitVec bitwise commutative properties\n");

In BitVec.BitWise.Simple.c:822:

    
    // NEW: Large pattern testing
    bool test_bitvec_bitwise_large_patterns(void) {
    WriteFmt("Testing BitVec bitwise operations with large patterns\n");

In BitVec.BitWise.Simple.c:892:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.BitWise tests\n\n");

In Str.Type.c:11:

    
    // Function prototypes
    bool test_str_type(void);
    bool test_strs_type(void);
    bool test_validate_str(void);

In Str.Type.c:12:

    // Function prototypes
    bool test_str_type(void);
    bool test_strs_type(void);
    bool test_validate_str(void);
    bool test_validate_strs(void);

In Str.Type.c:13:

    bool test_str_type(void);
    bool test_strs_type(void);
    bool test_validate_str(void);
    bool test_validate_strs(void);

In Str.Type.c:14:

    bool test_strs_type(void);
    bool test_validate_str(void);
    bool test_validate_strs(void);
    
    // Deadend test prototypes (tests that should crash/abort)

In Str.Type.c:17:

    
    // Deadend test prototypes (tests that should crash/abort)
    bool test_validate_invalid_str(void);
    bool test_validate_invalid_strs(void);

In Str.Type.c:18:

    // Deadend test prototypes (tests that should crash/abort)
    bool test_validate_invalid_str(void);
    bool test_validate_invalid_strs(void);
    
    // Test Str type definition

In Str.Type.c:21:

    
    // Test Str type definition
    bool test_str_type(void) {
    WriteFmt("Testing Str type definition\n");

In Str.Type.c:41:

    
    // Test Strs type definition
    bool test_strs_type(void) {
    WriteFmt("Testing Strs type definition\n");

In Str.Type.c:71:

    
    // Test ValidateStr macro
    bool test_validate_str(void) {
    WriteFmt("Testing ValidateStr macro\n");

In Str.Type.c:91:

    
    // Test ValidateStrs macro
    bool test_validate_strs(void) {
    WriteFmt("Testing ValidateStrs macro\n");

In Str.Type.c:110:

    
    // Deadend test: Test ValidateStr with invalid string (should crash/abort)
    bool test_validate_invalid_str(void) {
    WriteFmt("Testing ValidateStr with invalid string (should abort)\n");

In Str.Type.c:129:

    
    // Deadend test: Test ValidateStrs with invalid Strs (should crash/abort)
    bool test_validate_invalid_strs(void) {
    WriteFmt("Testing ValidateStrs with invalid Strs (should abort)\n");

In Str.Type.c:148:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Type tests\n\n");

In BitVec.Foreach.c:10:

    
    // Function prototypes
    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);

In BitVec.Foreach.c:11:

    // Function prototypes
    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);

In BitVec.Foreach.c:12:

    bool test_bitvec_foreach_idx(void);
    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);

In BitVec.Foreach.c:13:

    bool test_bitvec_foreach(void);
    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);

In BitVec.Foreach.c:14:

    bool test_bitvec_foreach_reverse_idx(void);
    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);

In BitVec.Foreach.c:15:

    bool test_bitvec_foreach_reverse(void);
    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);

In BitVec.Foreach.c:16:

    bool test_bitvec_foreach_in_range_idx(void);
    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);

In BitVec.Foreach.c:17:

    bool test_bitvec_foreach_in_range(void);
    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);

In BitVec.Foreach.c:18:

    bool test_bitvec_foreach_edge_cases(void);
    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);

In BitVec.Foreach.c:19:

    bool test_bitvec_foreach_idx_edge_cases(void);
    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);

In BitVec.Foreach.c:20:

    bool test_bitvec_foreach_reverse_edge_cases(void);
    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);

In BitVec.Foreach.c:21:

    bool test_bitvec_foreach_range_edge_cases(void);
    bool test_bitvec_foreach_stress_test(void);
    bool test_bitvec_foreach_invalid_usage(void);
    
    // BitVecRunLengths test prototypes

In BitVec.Foreach.c:24:

    
    // BitVecRunLengths test prototypes
    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);

In BitVec.Foreach.c:25:

    // BitVecRunLengths test prototypes
    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);

In BitVec.Foreach.c:26:

    bool test_bitvec_run_lengths_basic(void);
    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);

In BitVec.Foreach.c:27:

    bool test_bitvec_run_lengths_edge_cases(void);
    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);

In BitVec.Foreach.c:28:

    bool test_bitvec_run_lengths_boundary_conditions(void);
    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);

In BitVec.Foreach.c:29:

    bool test_bitvec_run_lengths_stress_test(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.c:30:

    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.c:31:

    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.c:35:

    
    // Test BitVecForeachIdx macro
    bool test_bitvec_foreach_idx(void) {
    WriteFmt("Testing BitVecForeachIdx macro\n");

In BitVec.Foreach.c:68:

    
    // Test BitVecForeach macro
    bool test_bitvec_foreach(void) {
    WriteFmt("Testing BitVecForeach macro\n");

In BitVec.Foreach.c:99:

    
    // Test BitVecForeachReverseIdx macro
    bool test_bitvec_foreach_reverse_idx(void) {
    WriteFmt("Testing BitVecForeachReverseIdx macro\n");

In BitVec.Foreach.c:130:

    
    // Test BitVecForeachReverse macro
    bool test_bitvec_foreach_reverse(void) {
    WriteFmt("Testing BitVecForeachReverse macro\n");

In BitVec.Foreach.c:160:

    
    // Test BitVecForeachInRangeIdx macro
    bool test_bitvec_foreach_in_range_idx(void) {
    WriteFmt("Testing BitVecForeachInRangeIdx macro\n");

In BitVec.Foreach.c:196:

    
    // Test BitVecForeachInRange macro
    bool test_bitvec_foreach_in_range(void) {
    WriteFmt("Testing BitVecForeachInRange macro\n");

In BitVec.Foreach.c:231:

    
    // Edge case tests
    bool test_bitvec_foreach_edge_cases(void) {
    WriteFmt("Testing BitVec foreach edge cases\n");

In BitVec.Foreach.c:240:

    // Test foreach on empty bitvec
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++; // Should not execute
    }

In BitVec.Foreach.c:262:

    count = 0;
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.c:271:

    }
    
    bool test_bitvec_foreach_idx_edge_cases(void) {
    WriteFmt("Testing BitVec foreach idx edge cases\n");

In BitVec.Foreach.c:280:

    // Test foreach idx on empty bitvec
    BitVecForeachIdx(&bv, bit, idx) {
    (void)bit;
    result = false; // Should not execute
    }

In BitVec.Foreach.c:301:

    u64 expected_idx = 0;
    BitVecForeachIdx(&bv, bit, idx) {
    (void)bit;
    result = result && (idx == expected_idx);
    expected_idx++;

In BitVec.Foreach.c:310:

    }
    
    bool test_bitvec_foreach_reverse_edge_cases(void) {
    WriteFmt("Testing BitVec foreach reverse edge cases\n");

In BitVec.Foreach.c:318:

    // Test reverse foreach on empty bitvec
    BitVecForeachReverse(&bv, bit) {
    (void)bit;
    result = false; // Should not execute
    }

In BitVec.Foreach.c:348:

    }
    
    bool test_bitvec_foreach_range_edge_cases(void) {
    WriteFmt("Testing BitVec foreach range edge cases\n");

In BitVec.Foreach.c:362:

    int count = 0;
    BitVecForeachInRange(&bv, bit, 5, 5) {
    (void)bit;
    count++; // Should not execute
    }

In BitVec.Foreach.c:378:

    count = 0;
    BitVecForeachInRange(&bv, bit, 0, 2) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.c:386:

    count = 0;
    BitVecForeachInRange(&bv, bit, 8, 10) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.c:395:

    }
    
    bool test_bitvec_foreach_stress_test(void) {
    WriteFmt("Testing BitVec foreach stress test\n");

In BitVec.Foreach.c:412:

    
    BitVecForeach(&bv, bitval) {
    (void)bitval;
    count1++;
    }

In BitVec.Foreach.c:416:

    }
    BitVecForeachIdx(&bv, bitval, i) {
    (void)bitval;
    count2++;
    }

In BitVec.Foreach.c:420:

    }
    BitVecForeachReverse(&bv, bitval) {
    (void)bitval;
    count3++;
    }

In BitVec.Foreach.c:424:

    }
    BitVecForeachReverseIdx(&bv, bitval, i) {
    (void)bitval;
    count4++;
    }

In BitVec.Foreach.c:441:

    // BitVecRunLengths test implementations
    
    bool test_bitvec_run_lengths_basic(void) {
    WriteFmt("Testing BitVecRunLengths basic functionality\n");

In BitVec.Foreach.c:477:

    }
    
    bool test_bitvec_run_lengths_edge_cases(void) {
    WriteFmt("Testing BitVecRunLengths edge cases\n");

In BitVec.Foreach.c:535:

    }
    
    bool test_bitvec_run_lengths_boundary_conditions(void) {
    WriteFmt("Testing BitVecRunLengths boundary conditions\n");

In BitVec.Foreach.c:572:

    }
    
    bool test_bitvec_run_lengths_stress_test(void) {
    WriteFmt("Testing BitVecRunLengths stress test\n");

In BitVec.Foreach.c:636:

    // Deadend tests for BitVecRunLengths
    
    bool test_bitvec_run_lengths_null_bv(void) {
    WriteFmt("Testing BitVecRunLengths with NULL bitvector\n");

In BitVec.Foreach.c:648:

    }
    
    bool test_bitvec_run_lengths_null_runs(void) {
    WriteFmt("Testing BitVecRunLengths with NULL runs array\n");

In BitVec.Foreach.c:662:

    }
    
    bool test_bitvec_run_lengths_null_values(void) {
    WriteFmt("Testing BitVecRunLengths with NULL values array\n");

In BitVec.Foreach.c:676:

    }
    
    bool test_bitvec_run_lengths_zero_max_runs(void) {
    WriteFmt("Testing BitVecRunLengths with zero max_runs\n");

In BitVec.Foreach.c:695:

    // with invalid macro usage scenarios
    
    bool test_bitvec_foreach_invalid_usage(void) {
    WriteFmt("Testing BitVec foreach with invalid bitvec\n");

In BitVec.Foreach.c:704:

    int count = 0;
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.c:709:

    
    // Should not reach here
    (void)count; // Silence unused variable warning
    return false;
    }

In BitVec.Foreach.c:714:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Foreach tests\n\n");

In BitVec.Access.Deadend.c:11:

    
    // Function prototypes for deadend tests
    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);

In BitVec.Access.Deadend.c:12:

    // Function prototypes for deadend tests
    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);
    bool test_bitvec_access_null_failures(void);

In BitVec.Access.Deadend.c:13:

    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);
    bool test_bitvec_access_null_failures(void);
    bool test_bitvec_set_null_failures(void);

In BitVec.Access.Deadend.c:14:

    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);
    bool test_bitvec_access_null_failures(void);
    bool test_bitvec_set_null_failures(void);
    bool test_bitvec_flip_null_failures(void);

In BitVec.Access.Deadend.c:15:

    bool test_bitvec_longest_run_deadend_tests(void);
    bool test_bitvec_access_null_failures(void);
    bool test_bitvec_set_null_failures(void);
    bool test_bitvec_flip_null_failures(void);
    bool test_bitvec_get_bounds_failures(void);

In BitVec.Access.Deadend.c:16:

    bool test_bitvec_access_null_failures(void);
    bool test_bitvec_set_null_failures(void);
    bool test_bitvec_flip_null_failures(void);
    bool test_bitvec_get_bounds_failures(void);
    bool test_bitvec_set_bounds_failures(void);

In BitVec.Access.Deadend.c:17:

    bool test_bitvec_set_null_failures(void);
    bool test_bitvec_flip_null_failures(void);
    bool test_bitvec_get_bounds_failures(void);
    bool test_bitvec_set_bounds_failures(void);
    bool test_bitvec_flip_bounds_failures(void);

In BitVec.Access.Deadend.c:18:

    bool test_bitvec_flip_null_failures(void);
    bool test_bitvec_get_bounds_failures(void);
    bool test_bitvec_set_bounds_failures(void);
    bool test_bitvec_flip_bounds_failures(void);
    bool test_bitvec_get_large_index_failures(void);

In BitVec.Access.Deadend.c:19:

    bool test_bitvec_get_bounds_failures(void);
    bool test_bitvec_set_bounds_failures(void);
    bool test_bitvec_flip_bounds_failures(void);
    bool test_bitvec_get_large_index_failures(void);
    bool test_bitvec_set_large_index_failures(void);

In BitVec.Access.Deadend.c:20:

    bool test_bitvec_set_bounds_failures(void);
    bool test_bitvec_flip_bounds_failures(void);
    bool test_bitvec_get_large_index_failures(void);
    bool test_bitvec_set_large_index_failures(void);
    bool test_bitvec_flip_edge_index_failures(void);

In BitVec.Access.Deadend.c:21:

    bool test_bitvec_flip_bounds_failures(void);
    bool test_bitvec_get_large_index_failures(void);
    bool test_bitvec_set_large_index_failures(void);
    bool test_bitvec_flip_edge_index_failures(void);
    bool test_bitvec_count_null_failures(void);

In BitVec.Access.Deadend.c:22:

    bool test_bitvec_get_large_index_failures(void);
    bool test_bitvec_set_large_index_failures(void);
    bool test_bitvec_flip_edge_index_failures(void);
    bool test_bitvec_count_null_failures(void);
    bool test_bitvec_get_max_index_failures(void);

In BitVec.Access.Deadend.c:23:

    bool test_bitvec_set_large_index_failures(void);
    bool test_bitvec_flip_edge_index_failures(void);
    bool test_bitvec_count_null_failures(void);
    bool test_bitvec_get_max_index_failures(void);

In BitVec.Access.Deadend.c:24:

    bool test_bitvec_flip_edge_index_failures(void);
    bool test_bitvec_count_null_failures(void);
    bool test_bitvec_get_max_index_failures(void);
    
    // Deadend tests - testing NULL pointers and invalid conditions that should cause fatal errors

In BitVec.Access.Deadend.c:27:

    
    // Deadend tests - testing NULL pointers and invalid conditions that should cause fatal errors
    bool test_bitvec_find_deadend_tests(void) {
    WriteFmt("Testing BitVecFind deadend scenarios\n");

In BitVec.Access.Deadend.c:36:

    }
    
    bool test_bitvec_predicate_deadend_tests(void) {
    WriteFmt("Testing BitVec predicate deadend scenarios\n");

In BitVec.Access.Deadend.c:45:

    }
    
    bool test_bitvec_longest_run_deadend_tests(void) {
    WriteFmt("Testing BitVecLongestRun deadend scenarios\n");

In BitVec.Access.Deadend.c:55:

    
    // Deadend tests
    bool test_bitvec_access_null_failures(void) {
    WriteFmt("Testing BitVec access NULL pointer handling\n");

In BitVec.Access.Deadend.c:64:

    }
    
    bool test_bitvec_set_null_failures(void) {
    WriteFmt("Testing BitVec set NULL pointer handling\n");

In BitVec.Access.Deadend.c:73:

    }
    
    bool test_bitvec_flip_null_failures(void) {
    WriteFmt("Testing BitVec flip NULL pointer handling\n");

In BitVec.Access.Deadend.c:82:

    }
    
    bool test_bitvec_get_bounds_failures(void) {
    WriteFmt("Testing BitVec get bounds checking\n");

In BitVec.Access.Deadend.c:94:

    }
    
    bool test_bitvec_set_bounds_failures(void) {
    WriteFmt("Testing BitVec set bounds checking\n");

In BitVec.Access.Deadend.c:106:

    }
    
    bool test_bitvec_flip_bounds_failures(void) {
    WriteFmt("Testing BitVec flip bounds checking\n");

In BitVec.Access.Deadend.c:119:

    
    // NEW: More specific bounds checking deadend tests
    bool test_bitvec_get_large_index_failures(void) {
    WriteFmt("Testing BitVec get with large out-of-bounds index\n");

In BitVec.Access.Deadend.c:134:

    }
    
    bool test_bitvec_set_large_index_failures(void) {
    WriteFmt("Testing BitVec set with large out-of-bounds index\n");

In BitVec.Access.Deadend.c:148:

    }
    
    bool test_bitvec_flip_edge_index_failures(void) {
    WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");

In BitVec.Access.Deadend.c:163:

    }
    
    bool test_bitvec_count_null_failures(void) {
    WriteFmt("Testing BitVec count operations with NULL pointer\n");

In BitVec.Access.Deadend.c:172:

    }
    
    bool test_bitvec_get_max_index_failures(void) {
    WriteFmt("Testing BitVec get with maximum index value\n");

In BitVec.Access.Deadend.c:186:

    
    // Main function that runs all deadend tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Access.Deadend tests\n\n");

In Io.Write.c:14:

    
    // Function prototypes
    bool test_basic_formatting(void);
    bool test_string_formatting(void);
    bool test_integer_decimal_formatting(void);

In Io.Write.c:15:

    // Function prototypes
    bool test_basic_formatting(void);
    bool test_string_formatting(void);
    bool test_integer_decimal_formatting(void);
    bool test_integer_hex_formatting(void);

In Io.Write.c:16:

    bool test_basic_formatting(void);
    bool test_string_formatting(void);
    bool test_integer_decimal_formatting(void);
    bool test_integer_hex_formatting(void);
    bool test_integer_binary_formatting(void);

In Io.Write.c:17:

    bool test_string_formatting(void);
    bool test_integer_decimal_formatting(void);
    bool test_integer_hex_formatting(void);
    bool test_integer_binary_formatting(void);
    bool test_integer_octal_formatting(void);

In Io.Write.c:18:

    bool test_integer_decimal_formatting(void);
    bool test_integer_hex_formatting(void);
    bool test_integer_binary_formatting(void);
    bool test_integer_octal_formatting(void);
    bool test_float_basic_formatting(void);

In Io.Write.c:19:

    bool test_integer_hex_formatting(void);
    bool test_integer_binary_formatting(void);
    bool test_integer_octal_formatting(void);
    bool test_float_basic_formatting(void);
    bool test_float_precision_formatting(void);

In Io.Write.c:20:

    bool test_integer_binary_formatting(void);
    bool test_integer_octal_formatting(void);
    bool test_float_basic_formatting(void);
    bool test_float_precision_formatting(void);
    bool test_float_special_values(void);

In Io.Write.c:21:

    bool test_integer_octal_formatting(void);
    bool test_float_basic_formatting(void);
    bool test_float_precision_formatting(void);
    bool test_float_special_values(void);
    bool test_width_alignment_formatting(void);

In Io.Write.c:22:

    bool test_float_basic_formatting(void);
    bool test_float_precision_formatting(void);
    bool test_float_special_values(void);
    bool test_width_alignment_formatting(void);
    bool test_multiple_arguments(void);

In Io.Write.c:23:

    bool test_float_precision_formatting(void);
    bool test_float_special_values(void);
    bool test_width_alignment_formatting(void);
    bool test_multiple_arguments(void);
    bool test_error_handling(void);

In Io.Write.c:24:

    bool test_float_special_values(void);
    bool test_width_alignment_formatting(void);
    bool test_multiple_arguments(void);
    bool test_error_handling(void);
    bool test_char_formatting(void);

In Io.Write.c:25:

    bool test_width_alignment_formatting(void);
    bool test_multiple_arguments(void);
    bool test_error_handling(void);
    bool test_char_formatting(void);
    bool test_bitvec_formatting(void);

In Io.Write.c:26:

    bool test_multiple_arguments(void);
    bool test_error_handling(void);
    bool test_char_formatting(void);
    bool test_bitvec_formatting(void);

In Io.Write.c:27:

    bool test_error_handling(void);
    bool test_char_formatting(void);
    bool test_bitvec_formatting(void);
    
    // Test basic formatting features

In Io.Write.c:30:

    
    // Test basic formatting features
    bool test_basic_formatting(void) {
    WriteFmt("Testing basic formatting\n");

In Io.Write.c:60:

    
    // Test string formatting
    bool test_string_formatting(void) {
    WriteFmt("Testing string formatting\n");

In Io.Write.c:102:

    
    // Test decimal integer formatting
    bool test_integer_decimal_formatting(void) {
    WriteFmt("Testing integer decimal formatting\n");

In Io.Write.c:175:

    
    // Test hexadecimal formatting
    bool test_integer_hex_formatting(void) {
    WriteFmt("Testing integer hexadecimal formatting\n");

In Io.Write.c:194:

    
    // Test binary formatting
    bool test_integer_binary_formatting(void) {
    WriteFmt("Testing integer binary formatting\n");

In Io.Write.c:209:

    
    // Test octal formatting
    bool test_integer_octal_formatting(void) {
    WriteFmt("Testing integer octal formatting\n");

In Io.Write.c:224:

    
    // Test basic floating point formatting
    bool test_float_basic_formatting(void) {
    WriteFmt("Testing basic floating point formatting\n");

In Io.Write.c:244:

    
    // Test floating point precision
    bool test_float_precision_formatting(void) {
    WriteFmt("Testing floating point precision formatting\n");

In Io.Write.c:269:

    
    // Test special floating point values
    bool test_float_special_values(void) {
    WriteFmt("Testing special floating point values\n");

In Io.Write.c:296:

    
    // Test width and alignment formatting
    bool test_width_alignment_formatting(void) {
    WriteFmt("Testing width and alignment formatting\n");

In Io.Write.c:334:

    
    // Test multiple arguments
    bool test_multiple_arguments(void) {
    WriteFmt("Testing multiple arguments\n");

In Io.Write.c:357:

    
    // Test character formatting specifiers
    bool test_char_formatting(void) {
    WriteFmt("Testing character formatting specifiers\n");

In Io.Write.c:549:

    
    // Test BitVec formatting
    bool test_bitvec_formatting(void) {
    WriteFmt("Testing BitVec formatting\n");

In Io.Write.c:636:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting format writer tests\n\n");

In BitVec.BitWise.Deadend.c:11:

    
    // Function prototypes for deadend tests
    bool test_bitvec_bitwise_null_failures(void);
    bool test_bitvec_bitwise_ops_null_failures(void);
    bool test_bitvec_reverse_null_failures(void);

In BitVec.BitWise.Deadend.c:12:

    // Function prototypes for deadend tests
    bool test_bitvec_bitwise_null_failures(void);
    bool test_bitvec_bitwise_ops_null_failures(void);
    bool test_bitvec_reverse_null_failures(void);
    bool test_bitvec_shift_ops_null_failures(void);

In BitVec.BitWise.Deadend.c:13:

    bool test_bitvec_bitwise_null_failures(void);
    bool test_bitvec_bitwise_ops_null_failures(void);
    bool test_bitvec_reverse_null_failures(void);
    bool test_bitvec_shift_ops_null_failures(void);
    bool test_bitvec_rotate_ops_null_failures(void);

In BitVec.BitWise.Deadend.c:14:

    bool test_bitvec_bitwise_ops_null_failures(void);
    bool test_bitvec_reverse_null_failures(void);
    bool test_bitvec_shift_ops_null_failures(void);
    bool test_bitvec_rotate_ops_null_failures(void);
    bool test_bitvec_and_result_null_failures(void);

In BitVec.BitWise.Deadend.c:15:

    bool test_bitvec_reverse_null_failures(void);
    bool test_bitvec_shift_ops_null_failures(void);
    bool test_bitvec_rotate_ops_null_failures(void);
    bool test_bitvec_and_result_null_failures(void);
    bool test_bitvec_or_operand_null_failures(void);

In BitVec.BitWise.Deadend.c:16:

    bool test_bitvec_shift_ops_null_failures(void);
    bool test_bitvec_rotate_ops_null_failures(void);
    bool test_bitvec_and_result_null_failures(void);
    bool test_bitvec_or_operand_null_failures(void);
    bool test_bitvec_xor_second_operand_null_failures(void);

In BitVec.BitWise.Deadend.c:17:

    bool test_bitvec_rotate_ops_null_failures(void);
    bool test_bitvec_and_result_null_failures(void);
    bool test_bitvec_or_operand_null_failures(void);
    bool test_bitvec_xor_second_operand_null_failures(void);
    bool test_bitvec_not_null_failures(void);

In BitVec.BitWise.Deadend.c:18:

    bool test_bitvec_and_result_null_failures(void);
    bool test_bitvec_or_operand_null_failures(void);
    bool test_bitvec_xor_second_operand_null_failures(void);
    bool test_bitvec_not_null_failures(void);

In BitVec.BitWise.Deadend.c:19:

    bool test_bitvec_or_operand_null_failures(void);
    bool test_bitvec_xor_second_operand_null_failures(void);
    bool test_bitvec_not_null_failures(void);
    
    // Deadend tests

In BitVec.BitWise.Deadend.c:22:

    
    // Deadend tests
    bool test_bitvec_bitwise_null_failures(void) {
    WriteFmt("Testing BitVec bitwise NULL pointer handling\n");

In BitVec.BitWise.Deadend.c:31:

    }
    
    bool test_bitvec_bitwise_ops_null_failures(void) {
    WriteFmt("Testing BitVec bitwise operations NULL handling\n");

In BitVec.BitWise.Deadend.c:45:

    }
    
    bool test_bitvec_reverse_null_failures(void) {
    WriteFmt("Testing BitVec reverse NULL handling\n");

In BitVec.BitWise.Deadend.c:55:

    
    // NEW: Additional deadend tests
    bool test_bitvec_shift_ops_null_failures(void) {
    WriteFmt("Testing BitVec shift operations NULL handling\n");

In BitVec.BitWise.Deadend.c:64:

    }
    
    bool test_bitvec_rotate_ops_null_failures(void) {
    WriteFmt("Testing BitVec rotate operations NULL handling\n");

In BitVec.BitWise.Deadend.c:73:

    }
    
    bool test_bitvec_and_result_null_failures(void) {
    WriteFmt("Testing BitVec AND with NULL result handling\n");

In BitVec.BitWise.Deadend.c:89:

    }
    
    bool test_bitvec_or_operand_null_failures(void) {
    WriteFmt("Testing BitVec OR with NULL operand handling\n");

In BitVec.BitWise.Deadend.c:103:

    }
    
    bool test_bitvec_xor_second_operand_null_failures(void) {
    WriteFmt("Testing BitVec XOR with NULL second operand handling\n");

In BitVec.BitWise.Deadend.c:117:

    }
    
    bool test_bitvec_not_null_failures(void) {
    WriteFmt("Testing BitVec NOT with NULL handling\n");

In BitVec.BitWise.Deadend.c:130:

    
    // Main function that runs all deadend tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.BitWise.Deadend tests\n\n");

In Str.Access.c:11:

    
    // Function prototypes
    bool test_str_first(void);
    bool test_str_last(void);
    bool test_str_begin(void);

In Str.Access.c:12:

    // Function prototypes
    bool test_str_first(void);
    bool test_str_last(void);
    bool test_str_begin(void);
    bool test_str_end(void);

In Str.Access.c:13:

    bool test_str_first(void);
    bool test_str_last(void);
    bool test_str_begin(void);
    bool test_str_end(void);
    bool test_str_char_at(void);

In Str.Access.c:14:

    bool test_str_last(void);
    bool test_str_begin(void);
    bool test_str_end(void);
    bool test_str_char_at(void);
    bool test_str_char_ptr_at(void);

In Str.Access.c:15:

    bool test_str_begin(void);
    bool test_str_end(void);
    bool test_str_char_at(void);
    bool test_str_char_ptr_at(void);

In Str.Access.c:16:

    bool test_str_end(void);
    bool test_str_char_at(void);
    bool test_str_char_ptr_at(void);
    
    // Test StrFirst function

In Str.Access.c:19:

    
    // Test StrFirst function
    bool test_str_first(void) {
    WriteFmt("Testing StrFirst\n");

In Str.Access.c:35:

    
    // Test StrLast function
    bool test_str_last(void) {
    WriteFmt("Testing StrLast\n");

In Str.Access.c:51:

    
    // Test StrBegin function
    bool test_str_begin(void) {
    WriteFmt("Testing StrBegin\n");

In Str.Access.c:67:

    
    // Test StrEnd function
    bool test_str_end(void) {
    WriteFmt("Testing StrEnd\n");

In Str.Access.c:83:

    
    // Test StrCharAt function
    bool test_str_char_at(void) {
    WriteFmt("Testing StrCharAt\n");

In Str.Access.c:104:

    
    // Test StrCharPtrAt function
    bool test_str_char_ptr_at(void) {
    WriteFmt("Testing StrCharPtrAt\n");

In Str.Access.c:128:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Access tests\n\n");

In BitVec.Pattern.c:11:

    
    // Function prototypes
    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);

In BitVec.Pattern.c:12:

    // Function prototypes
    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);

In BitVec.Pattern.c:13:

    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);

In BitVec.Pattern.c:14:

    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);

In BitVec.Pattern.c:15:

    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);

In BitVec.Pattern.c:16:

    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);

In BitVec.Pattern.c:17:

    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);

In BitVec.Pattern.c:18:

    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);

In BitVec.Pattern.c:19:

    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);

In BitVec.Pattern.c:20:

    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);

In BitVec.Pattern.c:21:

    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);

In BitVec.Pattern.c:22:

    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);

In BitVec.Pattern.c:23:

    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);

In BitVec.Pattern.c:24:

    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);

In BitVec.Pattern.c:25:

    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);

In BitVec.Pattern.c:26:

    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);

In BitVec.Pattern.c:27:

    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);

In BitVec.Pattern.c:28:

    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);

In BitVec.Pattern.c:29:

    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);

In BitVec.Pattern.c:30:

    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);

In BitVec.Pattern.c:31:

    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);

In BitVec.Pattern.c:32:

    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);

In BitVec.Pattern.c:33:

    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);

In BitVec.Pattern.c:34:

    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);

In BitVec.Pattern.c:35:

    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);

In BitVec.Pattern.c:36:

    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);

In BitVec.Pattern.c:37:

    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);

In BitVec.Pattern.c:38:

    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);

In BitVec.Pattern.c:39:

    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);

In BitVec.Pattern.c:40:

    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);

In BitVec.Pattern.c:41:

    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);

In BitVec.Pattern.c:42:

    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);

In BitVec.Pattern.c:43:

    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);

In BitVec.Pattern.c:44:

    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);

In BitVec.Pattern.c:45:

    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);

In BitVec.Pattern.c:46:

    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);

In BitVec.Pattern.c:47:

    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);

In BitVec.Pattern.c:48:

    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);

In BitVec.Pattern.c:49:

    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);

In BitVec.Pattern.c:50:

    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);

In BitVec.Pattern.c:51:

    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);

In BitVec.Pattern.c:52:

    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.c:53:

    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.c:54:

    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);
    
    // Test basic pattern matching functions

In BitVec.Pattern.c:57:

    
    // Test basic pattern matching functions
    bool test_bitvec_basic_pattern_functions(void) {
    WriteFmt("Testing basic BitVec pattern functions\n");

In BitVec.Pattern.c:92:

    
    // Test BitVecFindPattern function comprehensively
    bool test_bitvec_find_pattern(void) {
    WriteFmt("Testing BitVecFindPattern function\n");

In BitVec.Pattern.c:139:

    
    // Test BitVecFindLastPattern function
    bool test_bitvec_find_last_pattern(void) {
    WriteFmt("Testing BitVecFindLastPattern function\n");

In BitVec.Pattern.c:184:

    
    // Test BitVecFindAllPattern function
    bool test_bitvec_find_all_pattern(void) {
    WriteFmt("Testing BitVecFindAllPattern function\n");

In BitVec.Pattern.c:242:

    
    // Test edge cases for pattern functions
    bool test_bitvec_pattern_edge_cases(void) {
    WriteFmt("Testing BitVec pattern edge cases\n");

In BitVec.Pattern.c:311:

    
    // Stress tests with large data
    bool test_bitvec_pattern_stress_tests(void) {
    WriteFmt("Testing BitVec pattern stress tests\n");

In BitVec.Pattern.c:352:

    
    // Deadend test 1: BitVecFindPattern with NULL source
    bool test_bitvec_find_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");

In BitVec.Pattern.c:365:

    
    // Deadend test 2: BitVecFindPattern with NULL pattern
    bool test_bitvec_find_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");

In BitVec.Pattern.c:379:

    
    // Deadend test 3: BitVecFindLastPattern with NULL source
    bool test_bitvec_find_last_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");

In BitVec.Pattern.c:392:

    
    // Deadend test 4: BitVecFindLastPattern with NULL pattern
    bool test_bitvec_find_last_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");

In BitVec.Pattern.c:406:

    
    // Deadend test 5: BitVecFindAllPattern with NULL source
    bool test_bitvec_find_all_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindAllPattern(NULL, pattern, results, 10) - should fatal\n");

In BitVec.Pattern.c:418:

    
    // Deadend test 6: BitVecFindAllPattern with NULL pattern
    bool test_bitvec_find_all_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");

In BitVec.Pattern.c:433:

    
    // Deadend test 7: BitVecFindAllPattern with NULL results
    bool test_bitvec_find_all_pattern_null_results(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");

In BitVec.Pattern.c:450:

    
    // Deadend test 8: BitVecFindAllPattern with zero max_results
    bool test_bitvec_find_all_pattern_zero_max_results(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");

In BitVec.Pattern.c:470:

    
    // BitVecStartsWith tests
    bool test_bitvec_starts_with_basic(void) {
    WriteFmt("Testing BitVecStartsWith basic functionality\n");

In BitVec.Pattern.c:505:

    }
    
    bool test_bitvec_starts_with_edge_cases(void) {
    WriteFmt("Testing BitVecStartsWith edge cases\n");

In BitVec.Pattern.c:537:

    
    // BitVecEndsWith tests
    bool test_bitvec_ends_with_basic(void) {
    WriteFmt("Testing BitVecEndsWith basic functionality\n");

In BitVec.Pattern.c:572:

    }
    
    bool test_bitvec_ends_with_edge_cases(void) {
    WriteFmt("Testing BitVecEndsWith edge cases\n");

In BitVec.Pattern.c:595:

    
    // BitVecContains tests
    bool test_bitvec_contains_basic(void) {
    WriteFmt("Testing BitVecContains basic functionality\n");

In BitVec.Pattern.c:632:

    
    // BitVecContainsAt tests
    bool test_bitvec_contains_at_basic(void) {
    WriteFmt("Testing BitVecContainsAt basic functionality\n");

In BitVec.Pattern.c:662:

    }
    
    bool test_bitvec_contains_at_edge_cases(void) {
    WriteFmt("Testing BitVecContainsAt edge cases\n");

In BitVec.Pattern.c:686:

    
    // BitVecCountPattern tests
    bool test_bitvec_count_pattern_basic(void) {
    WriteFmt("Testing BitVecCountPattern basic functionality\n");

In BitVec.Pattern.c:721:

    
    // BitVecRFindPattern tests
    bool test_bitvec_rfind_pattern_basic(void) {
    WriteFmt("Testing BitVecRFindPattern basic functionality\n");

In BitVec.Pattern.c:758:

    
    // BitVecReplace tests
    bool test_bitvec_replace_basic(void) {
    WriteFmt("Testing BitVecReplace basic functionality\n");

In BitVec.Pattern.c:800:

    
    // BitVecReplaceAll tests
    bool test_bitvec_replace_all_basic(void) {
    WriteFmt("Testing BitVecReplaceAll basic functionality\n");

In BitVec.Pattern.c:837:

    
    // BitVecMatches tests
    bool test_bitvec_matches_basic(void) {
    WriteFmt("Testing BitVecMatches basic functionality\n");

In BitVec.Pattern.c:872:

    
    // BitVecFuzzyMatch tests
    bool test_bitvec_fuzzy_match_basic(void) {
    WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");

In BitVec.Pattern.c:908:

    
    // BitVecRegexMatch tests
    bool test_bitvec_regex_match_basic(void) {
    WriteFmt("Testing BitVecRegexMatch basic functionality\n");

In BitVec.Pattern.c:931:

    
    // BitVecPrefixMatch tests
    bool test_bitvec_prefix_match_basic(void) {
    WriteFmt("Testing BitVecPrefixMatch basic functionality\n");

In BitVec.Pattern.c:977:

    
    // BitVecSuffixMatch tests
    bool test_bitvec_suffix_match_basic(void) {
    WriteFmt("Testing BitVecSuffixMatch basic functionality\n");

In BitVec.Pattern.c:1024:

    // Additional deadend tests for missing Pattern functions
    
    bool test_bitvec_starts_with_null_source(void) {
    WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
    BitVec prefix = BitVecInit();

In BitVec.Pattern.c:1033:

    }
    
    bool test_bitvec_starts_with_null_prefix(void) {
    WriteFmt("Testing BitVecStartsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1042:

    }
    
    bool test_bitvec_ends_with_null_source(void) {
    WriteFmt("Testing BitVecEndsWith(NULL, suffix) - should fatal\n");
    BitVec suffix = BitVecInit();

In BitVec.Pattern.c:1051:

    }
    
    bool test_bitvec_ends_with_null_suffix(void) {
    WriteFmt("Testing BitVecEndsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1060:

    }
    
    bool test_bitvec_contains_at_null_source(void) {
    WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
    BitVec pattern = BitVecInit();

In BitVec.Pattern.c:1069:

    }
    
    bool test_bitvec_contains_at_null_pattern(void) {
    WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1078:

    }
    
    bool test_bitvec_replace_null_source(void) {
    WriteFmt("Testing BitVecReplace(NULL, old, new) - should fatal\n");

In BitVec.Pattern.c:1086:

    }
    
    bool test_bitvec_matches_null_source(void) {
    WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
    BitVec pattern  = BitVecInit();

In BitVec.Pattern.c:1098:

    }
    
    bool test_bitvec_regex_match_null_source(void) {
    WriteFmt("Testing BitVecRegexMatch(NULL, pattern) - should fatal\n");
    BitVecRegexMatch(NULL, "101");

In BitVec.Pattern.c:1104:

    }
    
    bool test_bitvec_regex_match_null_pattern(void) {
    WriteFmt("Testing BitVecRegexMatch(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1113:

    }
    
    bool test_bitvec_prefix_match_null_source(void) {
    WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
    BitVec patterns[1] = {BitVecInit()};

In BitVec.Pattern.c:1122:

    }
    
    bool test_bitvec_prefix_match_null_patterns(void) {
    WriteFmt("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1131:

    }
    
    bool test_bitvec_suffix_match_null_source(void) {
    WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
    BitVec patterns[1] = {BitVecInit()};

In BitVec.Pattern.c:1140:

    }
    
    bool test_bitvec_suffix_match_null_patterns(void) {
    WriteFmt("Testing BitVecSuffixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1150:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Pattern tests\n\n");

In BitVec.Math.c:12:

    
    // Function prototypes for all Math tests
    bool test_bitvec_hamming_distance_basic(void);
    bool test_bitvec_hamming_distance_edge_cases(void);
    bool test_bitvec_jaccard_similarity_basic(void);

In BitVec.Math.c:13:

    // Function prototypes for all Math tests
    bool test_bitvec_hamming_distance_basic(void);
    bool test_bitvec_hamming_distance_edge_cases(void);
    bool test_bitvec_jaccard_similarity_basic(void);
    bool test_bitvec_jaccard_similarity_edge_cases(void);

In BitVec.Math.c:14:

    bool test_bitvec_hamming_distance_basic(void);
    bool test_bitvec_hamming_distance_edge_cases(void);
    bool test_bitvec_jaccard_similarity_basic(void);
    bool test_bitvec_jaccard_similarity_edge_cases(void);
    bool test_bitvec_cosine_similarity_basic(void);

In BitVec.Math.c:15:

    bool test_bitvec_hamming_distance_edge_cases(void);
    bool test_bitvec_jaccard_similarity_basic(void);
    bool test_bitvec_jaccard_similarity_edge_cases(void);
    bool test_bitvec_cosine_similarity_basic(void);
    bool test_bitvec_cosine_similarity_edge_cases(void);

In BitVec.Math.c:16:

    bool test_bitvec_jaccard_similarity_basic(void);
    bool test_bitvec_jaccard_similarity_edge_cases(void);
    bool test_bitvec_cosine_similarity_basic(void);
    bool test_bitvec_cosine_similarity_edge_cases(void);
    bool test_bitvec_dot_product_basic(void);

In BitVec.Math.c:17:

    bool test_bitvec_jaccard_similarity_edge_cases(void);
    bool test_bitvec_cosine_similarity_basic(void);
    bool test_bitvec_cosine_similarity_edge_cases(void);
    bool test_bitvec_dot_product_basic(void);
    bool test_bitvec_dot_product_edge_cases(void);

In BitVec.Math.c:18:

    bool test_bitvec_cosine_similarity_basic(void);
    bool test_bitvec_cosine_similarity_edge_cases(void);
    bool test_bitvec_dot_product_basic(void);
    bool test_bitvec_dot_product_edge_cases(void);
    bool test_bitvec_edit_distance_basic(void);

In BitVec.Math.c:19:

    bool test_bitvec_cosine_similarity_edge_cases(void);
    bool test_bitvec_dot_product_basic(void);
    bool test_bitvec_dot_product_edge_cases(void);
    bool test_bitvec_edit_distance_basic(void);
    bool test_bitvec_edit_distance_edge_cases(void);

In BitVec.Math.c:20:

    bool test_bitvec_dot_product_basic(void);
    bool test_bitvec_dot_product_edge_cases(void);
    bool test_bitvec_edit_distance_basic(void);
    bool test_bitvec_edit_distance_edge_cases(void);
    bool test_bitvec_correlation_basic(void);

In BitVec.Math.c:21:

    bool test_bitvec_dot_product_edge_cases(void);
    bool test_bitvec_edit_distance_basic(void);
    bool test_bitvec_edit_distance_edge_cases(void);
    bool test_bitvec_correlation_basic(void);
    bool test_bitvec_correlation_edge_cases(void);

In BitVec.Math.c:22:

    bool test_bitvec_edit_distance_basic(void);
    bool test_bitvec_edit_distance_edge_cases(void);
    bool test_bitvec_correlation_basic(void);
    bool test_bitvec_correlation_edge_cases(void);
    bool test_bitvec_entropy_basic(void);

In BitVec.Math.c:23:

    bool test_bitvec_edit_distance_edge_cases(void);
    bool test_bitvec_correlation_basic(void);
    bool test_bitvec_correlation_edge_cases(void);
    bool test_bitvec_entropy_basic(void);
    bool test_bitvec_entropy_edge_cases(void);

In BitVec.Math.c:24:

    bool test_bitvec_correlation_basic(void);
    bool test_bitvec_correlation_edge_cases(void);
    bool test_bitvec_entropy_basic(void);
    bool test_bitvec_entropy_edge_cases(void);
    bool test_bitvec_alignment_score_basic(void);

In BitVec.Math.c:25:

    bool test_bitvec_correlation_edge_cases(void);
    bool test_bitvec_entropy_basic(void);
    bool test_bitvec_entropy_edge_cases(void);
    bool test_bitvec_alignment_score_basic(void);
    bool test_bitvec_alignment_score_edge_cases(void);

In BitVec.Math.c:26:

    bool test_bitvec_entropy_basic(void);
    bool test_bitvec_entropy_edge_cases(void);
    bool test_bitvec_alignment_score_basic(void);
    bool test_bitvec_alignment_score_edge_cases(void);
    bool test_bitvec_best_alignment_basic(void);

In BitVec.Math.c:27:

    bool test_bitvec_entropy_edge_cases(void);
    bool test_bitvec_alignment_score_basic(void);
    bool test_bitvec_alignment_score_edge_cases(void);
    bool test_bitvec_best_alignment_basic(void);
    bool test_bitvec_best_alignment_edge_cases(void);

In BitVec.Math.c:28:

    bool test_bitvec_alignment_score_basic(void);
    bool test_bitvec_alignment_score_edge_cases(void);
    bool test_bitvec_best_alignment_basic(void);
    bool test_bitvec_best_alignment_edge_cases(void);
    bool test_bitvec_math_stress_tests(void);

In BitVec.Math.c:29:

    bool test_bitvec_alignment_score_edge_cases(void);
    bool test_bitvec_best_alignment_basic(void);
    bool test_bitvec_best_alignment_edge_cases(void);
    bool test_bitvec_math_stress_tests(void);

In BitVec.Math.c:30:

    bool test_bitvec_best_alignment_basic(void);
    bool test_bitvec_best_alignment_edge_cases(void);
    bool test_bitvec_math_stress_tests(void);
    
    // Deadend tests

In BitVec.Math.c:33:

    
    // Deadend tests
    bool test_bitvec_hamming_distance_null_bv1(void);
    bool test_bitvec_hamming_distance_null_bv2(void);
    bool test_bitvec_jaccard_similarity_null_bv1(void);

In BitVec.Math.c:34:

    // Deadend tests
    bool test_bitvec_hamming_distance_null_bv1(void);
    bool test_bitvec_hamming_distance_null_bv2(void);
    bool test_bitvec_jaccard_similarity_null_bv1(void);
    bool test_bitvec_jaccard_similarity_null_bv2(void);

In BitVec.Math.c:35:

    bool test_bitvec_hamming_distance_null_bv1(void);
    bool test_bitvec_hamming_distance_null_bv2(void);
    bool test_bitvec_jaccard_similarity_null_bv1(void);
    bool test_bitvec_jaccard_similarity_null_bv2(void);
    bool test_bitvec_cosine_similarity_null_bv1(void);

In BitVec.Math.c:36:

    bool test_bitvec_hamming_distance_null_bv2(void);
    bool test_bitvec_jaccard_similarity_null_bv1(void);
    bool test_bitvec_jaccard_similarity_null_bv2(void);
    bool test_bitvec_cosine_similarity_null_bv1(void);
    bool test_bitvec_cosine_similarity_null_bv2(void);

In BitVec.Math.c:37:

    bool test_bitvec_jaccard_similarity_null_bv1(void);
    bool test_bitvec_jaccard_similarity_null_bv2(void);
    bool test_bitvec_cosine_similarity_null_bv1(void);
    bool test_bitvec_cosine_similarity_null_bv2(void);
    bool test_bitvec_dot_product_null_bv1(void);

In BitVec.Math.c:38:

    bool test_bitvec_jaccard_similarity_null_bv2(void);
    bool test_bitvec_cosine_similarity_null_bv1(void);
    bool test_bitvec_cosine_similarity_null_bv2(void);
    bool test_bitvec_dot_product_null_bv1(void);
    bool test_bitvec_dot_product_null_bv2(void);

In BitVec.Math.c:39:

    bool test_bitvec_cosine_similarity_null_bv1(void);
    bool test_bitvec_cosine_similarity_null_bv2(void);
    bool test_bitvec_dot_product_null_bv1(void);
    bool test_bitvec_dot_product_null_bv2(void);
    bool test_bitvec_edit_distance_null_bv1(void);

In BitVec.Math.c:40:

    bool test_bitvec_cosine_similarity_null_bv2(void);
    bool test_bitvec_dot_product_null_bv1(void);
    bool test_bitvec_dot_product_null_bv2(void);
    bool test_bitvec_edit_distance_null_bv1(void);
    bool test_bitvec_edit_distance_null_bv2(void);

In BitVec.Math.c:41:

    bool test_bitvec_dot_product_null_bv1(void);
    bool test_bitvec_dot_product_null_bv2(void);
    bool test_bitvec_edit_distance_null_bv1(void);
    bool test_bitvec_edit_distance_null_bv2(void);
    bool test_bitvec_correlation_null_bv1(void);

In BitVec.Math.c:42:

    bool test_bitvec_dot_product_null_bv2(void);
    bool test_bitvec_edit_distance_null_bv1(void);
    bool test_bitvec_edit_distance_null_bv2(void);
    bool test_bitvec_correlation_null_bv1(void);
    bool test_bitvec_correlation_null_bv2(void);

In BitVec.Math.c:43:

    bool test_bitvec_edit_distance_null_bv1(void);
    bool test_bitvec_edit_distance_null_bv2(void);
    bool test_bitvec_correlation_null_bv1(void);
    bool test_bitvec_correlation_null_bv2(void);
    bool test_bitvec_entropy_null(void);

In BitVec.Math.c:44:

    bool test_bitvec_edit_distance_null_bv2(void);
    bool test_bitvec_correlation_null_bv1(void);
    bool test_bitvec_correlation_null_bv2(void);
    bool test_bitvec_entropy_null(void);
    bool test_bitvec_alignment_score_null_bv1(void);

In BitVec.Math.c:45:

    bool test_bitvec_correlation_null_bv1(void);
    bool test_bitvec_correlation_null_bv2(void);
    bool test_bitvec_entropy_null(void);
    bool test_bitvec_alignment_score_null_bv1(void);
    bool test_bitvec_alignment_score_null_bv2(void);

In BitVec.Math.c:46:

    bool test_bitvec_correlation_null_bv2(void);
    bool test_bitvec_entropy_null(void);
    bool test_bitvec_alignment_score_null_bv1(void);
    bool test_bitvec_alignment_score_null_bv2(void);
    bool test_bitvec_best_alignment_null_bv1(void);

In BitVec.Math.c:47:

    bool test_bitvec_entropy_null(void);
    bool test_bitvec_alignment_score_null_bv1(void);
    bool test_bitvec_alignment_score_null_bv2(void);
    bool test_bitvec_best_alignment_null_bv1(void);
    bool test_bitvec_best_alignment_null_bv2(void);

In BitVec.Math.c:48:

    bool test_bitvec_alignment_score_null_bv1(void);
    bool test_bitvec_alignment_score_null_bv2(void);
    bool test_bitvec_best_alignment_null_bv1(void);
    bool test_bitvec_best_alignment_null_bv2(void);

In BitVec.Math.c:49:

    bool test_bitvec_alignment_score_null_bv2(void);
    bool test_bitvec_best_alignment_null_bv1(void);
    bool test_bitvec_best_alignment_null_bv2(void);
    
    // Test BitVecHammingDistance basic functionality

In BitVec.Math.c:52:

    
    // Test BitVecHammingDistance basic functionality
    bool test_bitvec_hamming_distance_basic(void) {
    WriteFmt("Testing BitVecHammingDistance basic functionality\n");

In BitVec.Math.c:94:

    
    // Test BitVecHammingDistance edge cases
    bool test_bitvec_hamming_distance_edge_cases(void) {
    WriteFmt("Testing BitVecHammingDistance edge cases\n");

In BitVec.Math.c:124:

    
    // Test BitVecJaccardSimilarity basic functionality
    bool test_bitvec_jaccard_similarity_basic(void) {
    WriteFmt("Testing BitVecJaccardSimilarity basic functionality\n");

In BitVec.Math.c:173:

    
    // Test BitVecJaccardSimilarity edge cases
    bool test_bitvec_jaccard_similarity_edge_cases(void) {
    WriteFmt("Testing BitVecJaccardSimilarity edge cases\n");

In BitVec.Math.c:199:

    
    // Test BitVecCosineSimilarity basic functionality
    bool test_bitvec_cosine_similarity_basic(void) {
    WriteFmt("Testing BitVecCosineSimilarity basic functionality\n");

In BitVec.Math.c:234:

    
    // Test BitVecCosineSimilarity edge cases
    bool test_bitvec_cosine_similarity_edge_cases(void) {
    WriteFmt("Testing BitVecCosineSimilarity edge cases\n");

In BitVec.Math.c:264:

    
    // Test BitVecDotProduct basic functionality
    bool test_bitvec_dot_product_basic(void) {
    WriteFmt("Testing BitVecDotProduct basic functionality\n");

In BitVec.Math.c:301:

    
    // Test BitVecDotProduct edge cases
    bool test_bitvec_dot_product_edge_cases(void) {
    WriteFmt("Testing BitVecDotProduct edge cases\n");

In BitVec.Math.c:328:

    
    // Test BitVecEditDistance basic functionality
    bool test_bitvec_edit_distance_basic(void) {
    WriteFmt("Testing BitVecEditDistance basic functionality\n");

In BitVec.Math.c:371:

    
    // Test BitVecEditDistance edge cases
    bool test_bitvec_edit_distance_edge_cases(void) {
    WriteFmt("Testing BitVecEditDistance edge cases\n");

In BitVec.Math.c:399:

    
    // Test BitVecCorrelation basic functionality
    bool test_bitvec_correlation_basic(void) {
    WriteFmt("Testing BitVecCorrelation basic functionality\n");

In BitVec.Math.c:435:

    
    // Test BitVecCorrelation edge cases
    bool test_bitvec_correlation_edge_cases(void) {
    WriteFmt("Testing BitVecCorrelation edge cases\n");

In BitVec.Math.c:463:

    
    // Test BitVecEntropy basic functionality
    bool test_bitvec_entropy_basic(void) {
    WriteFmt("Testing BitVecEntropy basic functionality\n");

In BitVec.Math.c:492:

    
    // Test BitVecEntropy edge cases
    bool test_bitvec_entropy_edge_cases(void) {
    WriteFmt("Testing BitVecEntropy edge cases\n");

In BitVec.Math.c:512:

    
    // Test BitVecAlignmentScore basic functionality
    bool test_bitvec_alignment_score_basic(void) {
    WriteFmt("Testing BitVecAlignmentScore basic functionality\n");

In BitVec.Math.c:545:

    
    // Test BitVecAlignmentScore edge cases
    bool test_bitvec_alignment_score_edge_cases(void) {
    WriteFmt("Testing BitVecAlignmentScore edge cases\n");

In BitVec.Math.c:572:

    
    // Test BitVecBestAlignment basic functionality
    bool test_bitvec_best_alignment_basic(void) {
    WriteFmt("Testing BitVecBestAlignment basic functionality\n");

In BitVec.Math.c:602:

    
    // Test BitVecBestAlignment edge cases
    bool test_bitvec_best_alignment_edge_cases(void) {
    WriteFmt("Testing BitVecBestAlignment edge cases\n");

In BitVec.Math.c:627:

    
    // Stress test for Math functions
    bool test_bitvec_math_stress_tests(void) {
    WriteFmt("Testing BitVec Math stress tests\n");

In BitVec.Math.c:679:

    // Deadend tests - each function with NULL parameters
    
    bool test_bitvec_hamming_distance_null_bv1(void) {
    WriteFmt("Testing BitVecHammingDistance(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:688:

    }
    
    bool test_bitvec_hamming_distance_null_bv2(void) {
    WriteFmt("Testing BitVecHammingDistance(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:697:

    }
    
    bool test_bitvec_jaccard_similarity_null_bv1(void) {
    WriteFmt("Testing BitVecJaccardSimilarity(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:706:

    }
    
    bool test_bitvec_jaccard_similarity_null_bv2(void) {
    WriteFmt("Testing BitVecJaccardSimilarity(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:715:

    }
    
    bool test_bitvec_cosine_similarity_null_bv1(void) {
    WriteFmt("Testing BitVecCosineSimilarity(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:724:

    }
    
    bool test_bitvec_cosine_similarity_null_bv2(void) {
    WriteFmt("Testing BitVecCosineSimilarity(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:733:

    }
    
    bool test_bitvec_dot_product_null_bv1(void) {
    WriteFmt("Testing BitVecDotProduct(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:742:

    }
    
    bool test_bitvec_dot_product_null_bv2(void) {
    WriteFmt("Testing BitVecDotProduct(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:751:

    }
    
    bool test_bitvec_edit_distance_null_bv1(void) {
    WriteFmt("Testing BitVecEditDistance(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:760:

    }
    
    bool test_bitvec_edit_distance_null_bv2(void) {
    WriteFmt("Testing BitVecEditDistance(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:769:

    }
    
    bool test_bitvec_correlation_null_bv1(void) {
    WriteFmt("Testing BitVecCorrelation(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:778:

    }
    
    bool test_bitvec_correlation_null_bv2(void) {
    WriteFmt("Testing BitVecCorrelation(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:787:

    }
    
    bool test_bitvec_entropy_null(void) {
    WriteFmt("Testing BitVecEntropy(NULL) - should fatal\n");
    BitVecEntropy(NULL);

In BitVec.Math.c:793:

    }
    
    bool test_bitvec_alignment_score_null_bv1(void) {
    WriteFmt("Testing BitVecAlignmentScore(NULL, bv2, 1, -1) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:802:

    }
    
    bool test_bitvec_alignment_score_null_bv2(void) {
    WriteFmt("Testing BitVecAlignmentScore(bv1, NULL, 1, -1) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:811:

    }
    
    bool test_bitvec_best_alignment_null_bv1(void) {
    WriteFmt("Testing BitVecBestAlignment(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:820:

    }
    
    bool test_bitvec_best_alignment_null_bv2(void) {
    WriteFmt("Testing BitVecBestAlignment(bv1, NULL) - should fatal\n");
    BitVec bv1 = BitVecInit();

In BitVec.Math.c:830:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Math tests\n\n");

In BitVec.Insert.c:10:

    
    // Function prototypes
    bool test_bitvec_push(void);
    bool test_bitvec_insert_single(void);
    bool test_bitvec_insert_range(void);

In BitVec.Insert.c:11:

    // Function prototypes
    bool test_bitvec_push(void);
    bool test_bitvec_insert_single(void);
    bool test_bitvec_insert_range(void);
    bool test_bitvec_insert_multiple(void);

In BitVec.Insert.c:12:

    bool test_bitvec_push(void);
    bool test_bitvec_insert_single(void);
    bool test_bitvec_insert_range(void);
    bool test_bitvec_insert_multiple(void);
    bool test_bitvec_insert_pattern(void);

In BitVec.Insert.c:13:

    bool test_bitvec_insert_single(void);
    bool test_bitvec_insert_range(void);
    bool test_bitvec_insert_multiple(void);
    bool test_bitvec_insert_pattern(void);
    bool test_bitvec_insert_range_edge_cases(void);

In BitVec.Insert.c:14:

    bool test_bitvec_insert_range(void);
    bool test_bitvec_insert_multiple(void);
    bool test_bitvec_insert_pattern(void);
    bool test_bitvec_insert_range_edge_cases(void);
    bool test_bitvec_insert_multiple_edge_cases(void);

In BitVec.Insert.c:15:

    bool test_bitvec_insert_multiple(void);
    bool test_bitvec_insert_pattern(void);
    bool test_bitvec_insert_range_edge_cases(void);
    bool test_bitvec_insert_multiple_edge_cases(void);
    bool test_bitvec_insert_pattern_edge_cases(void);

In BitVec.Insert.c:16:

    bool test_bitvec_insert_pattern(void);
    bool test_bitvec_insert_range_edge_cases(void);
    bool test_bitvec_insert_multiple_edge_cases(void);
    bool test_bitvec_insert_pattern_edge_cases(void);
    bool test_bitvec_insert_null_failures(void);

In BitVec.Insert.c:17:

    bool test_bitvec_insert_range_edge_cases(void);
    bool test_bitvec_insert_multiple_edge_cases(void);
    bool test_bitvec_insert_pattern_edge_cases(void);
    bool test_bitvec_insert_null_failures(void);
    bool test_bitvec_insert_invalid_range_failures(void);

In BitVec.Insert.c:18:

    bool test_bitvec_insert_multiple_edge_cases(void);
    bool test_bitvec_insert_pattern_edge_cases(void);
    bool test_bitvec_insert_null_failures(void);
    bool test_bitvec_insert_invalid_range_failures(void);
    bool test_bitvec_insert_pattern_null_failures(void);

In BitVec.Insert.c:19:

    bool test_bitvec_insert_pattern_edge_cases(void);
    bool test_bitvec_insert_null_failures(void);
    bool test_bitvec_insert_invalid_range_failures(void);
    bool test_bitvec_insert_pattern_null_failures(void);

In BitVec.Insert.c:20:

    bool test_bitvec_insert_null_failures(void);
    bool test_bitvec_insert_invalid_range_failures(void);
    bool test_bitvec_insert_pattern_null_failures(void);
    
    // Test BitVecPush function

In BitVec.Insert.c:23:

    
    // Test BitVecPush function
    bool test_bitvec_push(void) {
    WriteFmt("Testing BitVecPush\n");

In BitVec.Insert.c:52:

    
    // Test BitVecInsert single bit function
    bool test_bitvec_insert_single(void) {
    WriteFmt("Testing BitVecInsert (single bit)\n");

In BitVec.Insert.c:87:

    
    // Test BitVecInsertRange function
    bool test_bitvec_insert_range(void) {
    WriteFmt("Testing BitVecInsertRange\n");

In BitVec.Insert.c:114:

    
    // Test BitVecInsertMultiple function
    bool test_bitvec_insert_multiple(void) {
    WriteFmt("Testing BitVecInsertMultiple\n");

In BitVec.Insert.c:148:

    
    // Test BitVecInsertPattern function
    bool test_bitvec_insert_pattern(void) {
    WriteFmt("Testing BitVecInsertPattern\n");

In BitVec.Insert.c:193:

    
    // Edge case tests
    bool test_bitvec_insert_range_edge_cases(void) {
    WriteFmt("Testing BitVecInsertRange edge cases\n");

In BitVec.Insert.c:221:

    }
    
    bool test_bitvec_insert_multiple_edge_cases(void) {
    WriteFmt("Testing BitVecInsertMultiple edge cases\n");

In BitVec.Insert.c:254:

    }
    
    bool test_bitvec_insert_pattern_edge_cases(void) {
    WriteFmt("Testing BitVecInsertPattern edge cases\n");

In BitVec.Insert.c:280:

    
    // Deadend tests
    bool test_bitvec_insert_null_failures(void) {
    WriteFmt("Testing BitVec insert NULL pointer handling\n");

In BitVec.Insert.c:289:

    }
    
    bool test_bitvec_insert_invalid_range_failures(void) {
    WriteFmt("Testing BitVec insert invalid range handling\n");

In BitVec.Insert.c:301:

    }
    
    bool test_bitvec_insert_pattern_null_failures(void) {
    WriteFmt("Testing BitVec insert pattern NULL handling\n");

In BitVec.Insert.c:311:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Insert tests\n\n");

In Vec.Complex.c:52:

    
    // Deinit function for ComplexItem
    void ComplexItemDeinit(ComplexItem *item) {
    if (!item)
    return;

In Vec.Complex.c:121:

    
    // Function prototypes
    bool test_complex_vec_init(void);
    bool test_complex_vec_push(void);
    bool test_complex_vec_insert(void);

In Vec.Complex.c:122:

    // Function prototypes
    bool test_complex_vec_init(void);
    bool test_complex_vec_push(void);
    bool test_complex_vec_insert(void);
    bool test_complex_vec_merge(void);

In Vec.Complex.c:123:

    bool test_complex_vec_init(void);
    bool test_complex_vec_push(void);
    bool test_complex_vec_insert(void);
    bool test_complex_vec_merge(void);
    bool test_lvalue_operations(void);

In Vec.Complex.c:124:

    bool test_complex_vec_push(void);
    bool test_complex_vec_insert(void);
    bool test_complex_vec_merge(void);
    bool test_lvalue_operations(void);
    bool test_fast_operations(void);

In Vec.Complex.c:125:

    bool test_complex_vec_insert(void);
    bool test_complex_vec_merge(void);
    bool test_lvalue_operations(void);
    bool test_fast_operations(void);
    bool test_delete_operations(void);

In Vec.Complex.c:126:

    bool test_complex_vec_merge(void);
    bool test_lvalue_operations(void);
    bool test_fast_operations(void);
    bool test_delete_operations(void);
    bool test_edge_cases(void);

In Vec.Complex.c:127:

    bool test_lvalue_operations(void);
    bool test_fast_operations(void);
    bool test_delete_operations(void);
    bool test_edge_cases(void);
    bool test_lvalue_memset_pushback(void);

In Vec.Complex.c:128:

    bool test_fast_operations(void);
    bool test_delete_operations(void);
    bool test_edge_cases(void);
    bool test_lvalue_memset_pushback(void);
    bool test_lvalue_memset_insert(void);

In Vec.Complex.c:129:

    bool test_delete_operations(void);
    bool test_edge_cases(void);
    bool test_lvalue_memset_pushback(void);
    bool test_lvalue_memset_insert(void);
    bool test_lvalue_memset_fast_insert(void);

In Vec.Complex.c:130:

    bool test_edge_cases(void);
    bool test_lvalue_memset_pushback(void);
    bool test_lvalue_memset_insert(void);
    bool test_lvalue_memset_fast_insert(void);
    bool test_lvalue_memset_pushfront(void);

In Vec.Complex.c:131:

    bool test_lvalue_memset_pushback(void);
    bool test_lvalue_memset_insert(void);
    bool test_lvalue_memset_fast_insert(void);
    bool test_lvalue_memset_pushfront(void);
    bool test_lvalue_memset_merge(void);

In Vec.Complex.c:132:

    bool test_lvalue_memset_insert(void);
    bool test_lvalue_memset_fast_insert(void);
    bool test_lvalue_memset_pushfront(void);
    bool test_lvalue_memset_merge(void);
    bool test_lvalue_memset_array_ops(void);

In Vec.Complex.c:133:

    bool test_lvalue_memset_fast_insert(void);
    bool test_lvalue_memset_pushfront(void);
    bool test_lvalue_memset_merge(void);
    bool test_lvalue_memset_array_ops(void);

In Vec.Complex.c:134:

    bool test_lvalue_memset_pushfront(void);
    bool test_lvalue_memset_merge(void);
    bool test_lvalue_memset_array_ops(void);
    
    // Test initialization with complex structure

In Vec.Complex.c:137:

    
    // Test initialization with complex structure
    bool test_complex_vec_init(void) {
    WriteFmt("Testing vector initialization with complex structure\n");

In Vec.Complex.c:180:

    
    // Test push operations with complex structure
    bool test_complex_vec_push(void) {
    WriteFmt("Testing push operations with complex structure\n");

In Vec.Complex.c:224:

    
    // Test insert operations with complex structure
    bool test_complex_vec_insert(void) {
    WriteFmt("Testing insert operations with complex structure\n");

In Vec.Complex.c:267:

    
    // Test merge operations with complex structure
    bool test_complex_vec_merge(void) {
    WriteFmt("Testing merge operations with complex structure\n");

In Vec.Complex.c:345:

    
    // Test L-value operations
    bool test_lvalue_operations(void) {
    WriteFmt("Testing L-value operations\n");

In Vec.Complex.c:393:

    
    // Test fast operations
    bool test_fast_operations(void) {
    WriteFmt("Testing fast operations\n");

In Vec.Complex.c:470:

    
    // Test delete operations
    bool test_delete_operations(void) {
    WriteFmt("Testing delete operations\n");

In Vec.Complex.c:561:

    
    // Test edge cases
    bool test_edge_cases(void) {
    WriteFmt("Testing edge cases\n");

In Vec.Complex.c:623:

    
    // Test VecPushBackL memset behavior with complex structures
    bool test_lvalue_memset_pushback(void) {
    WriteFmt("Testing VecPushBackL memset with complex structures\n");

In Vec.Complex.c:649:

    
    // Test VecInsertL memset behavior with complex structures
    bool test_lvalue_memset_insert(void) {
    WriteFmt("Testing VecInsertL memset with complex structures\n");

In Vec.Complex.c:684:

    
    // Test VecInsertFastL memset behavior with complex structures
    bool test_lvalue_memset_fast_insert(void) {
    WriteFmt("Testing VecInsertFastL memset with complex structures\n");
    bool result = true;

In Vec.Complex.c:750:

    
    // Test VecPushFrontL memset behavior with complex structures
    bool test_lvalue_memset_pushfront(void) {
    WriteFmt("Testing VecPushFrontL memset with complex structures\n");

In Vec.Complex.c:781:

    
    // Test VecMergeL memset behavior with complex structures
    bool test_lvalue_memset_merge(void) {
    WriteFmt("Testing VecMergeL memset with complex structures\n");

In Vec.Complex.c:819:

    
    // Test array operations with L-value semantics
    bool test_lvalue_memset_array_ops(void) {
    WriteFmt("Testing array operations with L-value semantics\n");

In Vec.Complex.c:856:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Complex tests\n\n");

In Str.Remove.c:11:

    
    // Function prototypes
    bool test_str_pop_back(void);
    bool test_str_pop_front(void);
    bool test_str_remove(void);

In Str.Remove.c:12:

    // Function prototypes
    bool test_str_pop_back(void);
    bool test_str_pop_front(void);
    bool test_str_remove(void);
    bool test_str_remove_range(void);

In Str.Remove.c:13:

    bool test_str_pop_back(void);
    bool test_str_pop_front(void);
    bool test_str_remove(void);
    bool test_str_remove_range(void);
    bool test_str_delete_last_char(void);

In Str.Remove.c:14:

    bool test_str_pop_front(void);
    bool test_str_remove(void);
    bool test_str_remove_range(void);
    bool test_str_delete_last_char(void);
    bool test_str_delete(void);

In Str.Remove.c:15:

    bool test_str_remove(void);
    bool test_str_remove_range(void);
    bool test_str_delete_last_char(void);
    bool test_str_delete(void);
    bool test_str_delete_range(void);

In Str.Remove.c:16:

    bool test_str_remove_range(void);
    bool test_str_delete_last_char(void);
    bool test_str_delete(void);
    bool test_str_delete_range(void);

In Str.Remove.c:17:

    bool test_str_delete_last_char(void);
    bool test_str_delete(void);
    bool test_str_delete_range(void);
    
    // Test StrPopBack function

In Str.Remove.c:20:

    
    // Test StrPopBack function
    bool test_str_pop_back(void) {
    WriteFmt("Testing StrPopBack\n");

In Str.Remove.c:44:

    
    // Test StrPopFront function
    bool test_str_pop_front(void) {
    WriteFmt("Testing StrPopFront\n");

In Str.Remove.c:68:

    
    // Test StrRemove function
    bool test_str_remove(void) {
    WriteFmt("Testing StrRemove\n");

In Str.Remove.c:92:

    
    // Test StrRemoveRange function
    bool test_str_remove_range(void) {
    WriteFmt("Testing StrRemoveRange\n");

In Str.Remove.c:119:

    
    // Test StrDeleteLastChar function
    bool test_str_delete_last_char(void) {
    WriteFmt("Testing StrDeleteLastChar\n");

In Str.Remove.c:141:

    
    // Test StrDelete function
    bool test_str_delete(void) {
    WriteFmt("Testing StrDelete\n");

In Str.Remove.c:163:

    
    // Test StrDeleteRange function
    bool test_str_delete_range(void) {
    WriteFmt("Testing StrDeleteRange\n");

In Str.Remove.c:185:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Remove tests\n\n");

In Str.Foreach.c:11:

    
    // Function prototypes
    bool test_str_foreach_idx(void);
    bool test_str_foreach_reverse_idx(void);
    bool test_str_foreach_ptr_idx(void);

In Str.Foreach.c:12:

    // Function prototypes
    bool test_str_foreach_idx(void);
    bool test_str_foreach_reverse_idx(void);
    bool test_str_foreach_ptr_idx(void);
    bool test_str_foreach_reverse_ptr_idx(void);

In Str.Foreach.c:13:

    bool test_str_foreach_idx(void);
    bool test_str_foreach_reverse_idx(void);
    bool test_str_foreach_ptr_idx(void);
    bool test_str_foreach_reverse_ptr_idx(void);
    bool test_str_foreach(void);

In Str.Foreach.c:14:

    bool test_str_foreach_reverse_idx(void);
    bool test_str_foreach_ptr_idx(void);
    bool test_str_foreach_reverse_ptr_idx(void);
    bool test_str_foreach(void);
    bool test_str_foreach_reverse(void);

In Str.Foreach.c:15:

    bool test_str_foreach_ptr_idx(void);
    bool test_str_foreach_reverse_ptr_idx(void);
    bool test_str_foreach(void);
    bool test_str_foreach_reverse(void);
    bool test_str_foreach_ptr(void);

In Str.Foreach.c:16:

    bool test_str_foreach_reverse_ptr_idx(void);
    bool test_str_foreach(void);
    bool test_str_foreach_reverse(void);
    bool test_str_foreach_ptr(void);
    bool test_str_foreach_ptr_reverse(void);

In Str.Foreach.c:17:

    bool test_str_foreach(void);
    bool test_str_foreach_reverse(void);
    bool test_str_foreach_ptr(void);
    bool test_str_foreach_ptr_reverse(void);
    bool test_str_foreach_in_range_idx(void);

In Str.Foreach.c:18:

    bool test_str_foreach_reverse(void);
    bool test_str_foreach_ptr(void);
    bool test_str_foreach_ptr_reverse(void);
    bool test_str_foreach_in_range_idx(void);
    bool test_str_foreach_in_range(void);

In Str.Foreach.c:19:

    bool test_str_foreach_ptr(void);
    bool test_str_foreach_ptr_reverse(void);
    bool test_str_foreach_in_range_idx(void);
    bool test_str_foreach_in_range(void);
    bool test_str_foreach_ptr_in_range_idx(void);

In Str.Foreach.c:20:

    bool test_str_foreach_ptr_reverse(void);
    bool test_str_foreach_in_range_idx(void);
    bool test_str_foreach_in_range(void);
    bool test_str_foreach_ptr_in_range_idx(void);
    bool test_str_foreach_ptr_in_range(void);

In Str.Foreach.c:21:

    bool test_str_foreach_in_range_idx(void);
    bool test_str_foreach_in_range(void);
    bool test_str_foreach_ptr_in_range_idx(void);
    bool test_str_foreach_ptr_in_range(void);

In Str.Foreach.c:22:

    bool test_str_foreach_in_range(void);
    bool test_str_foreach_ptr_in_range_idx(void);
    bool test_str_foreach_ptr_in_range(void);
    
    bool test_str_foreach_out_of_bounds_access(void);

In Str.Foreach.c:24:

    bool test_str_foreach_ptr_in_range(void);
    
    bool test_str_foreach_out_of_bounds_access(void);
    bool test_str_foreach_idx_out_of_bounds_access(void);
    bool test_str_foreach_idx_basic_out_of_bounds_access(void);

In Str.Foreach.c:25:

    
    bool test_str_foreach_out_of_bounds_access(void);
    bool test_str_foreach_idx_out_of_bounds_access(void);
    bool test_str_foreach_idx_basic_out_of_bounds_access(void);
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void);

In Str.Foreach.c:26:

    bool test_str_foreach_out_of_bounds_access(void);
    bool test_str_foreach_idx_out_of_bounds_access(void);
    bool test_str_foreach_idx_basic_out_of_bounds_access(void);
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void);

In Str.Foreach.c:27:

    bool test_str_foreach_idx_out_of_bounds_access(void);
    bool test_str_foreach_idx_basic_out_of_bounds_access(void);
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void);

In Str.Foreach.c:28:

    bool test_str_foreach_idx_basic_out_of_bounds_access(void);
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_in_range_idx_out_of_bounds_access(void);

In Str.Foreach.c:29:

    bool test_str_foreach_reverse_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_in_range_idx_out_of_bounds_access(void);

In Str.Foreach.c:30:

    bool test_str_foreach_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void);
    bool test_str_foreach_ptr_in_range_idx_out_of_bounds_access(void);
    
    // Test StrForeachIdx macro

In Str.Foreach.c:33:

    
    // Test StrForeachIdx macro
    bool test_str_foreach_idx(void) {
    WriteFmt("Testing StrForeachIdx\n");

In Str.Foreach.c:53:

    
    // Test StrForeachReverseIdx macro
    bool test_str_foreach_reverse_idx(void) {
    WriteFmt("Testing StrForeachReverseIdx\n");

In Str.Foreach.c:75:

    
    // Test StrForeachPtrIdx macro
    bool test_str_foreach_ptr_idx(void) {
    WriteFmt("Testing StrForeachPtrIdx\n");

In Str.Foreach.c:104:

    
    // Test StrForeachReversePtrIdx macro
    bool test_str_foreach_reverse_ptr_idx(void) {
    WriteFmt("Testing StrForeachReversePtrIdx\n");

In Str.Foreach.c:133:

    
    // Test StrForeach macro
    bool test_str_foreach(void) {
    WriteFmt("Testing StrForeach\n");

In Str.Foreach.c:154:

    
    // Test StrForeachReverse macro
    bool test_str_foreach_reverse(void) {
    WriteFmt("Testing StrForeachReverse\n");

In Str.Foreach.c:185:

    
    // Test StrForeachPtr macro
    bool test_str_foreach_ptr(void) {
    WriteFmt("Testing StrForeachPtr\n");

In Str.Foreach.c:214:

    
    // Test StrForeachPtrReverse macro
    bool test_str_foreach_ptr_reverse(void) {
    WriteFmt("Testing StrForeachPtrReverse\n");

In Str.Foreach.c:253:

    
    // Test StrForeachInRangeIdx macro
    bool test_str_foreach_in_range_idx(void) {
    WriteFmt("Testing StrForeachInRangeIdx\n");

In Str.Foreach.c:285:

    
    // Test StrForeachInRange macro
    bool test_str_foreach_in_range(void) {
    WriteFmt("Testing StrForeachInRange\n");

In Str.Foreach.c:317:

    
    // Test StrForeachPtrInRangeIdx macro
    bool test_str_foreach_ptr_in_range_idx(void) {
    WriteFmt("Testing StrForeachPtrInRangeIdx\n");

In Str.Foreach.c:346:

    
    // Test StrForeachPtrInRange macro
    bool test_str_foreach_ptr_in_range(void) {
    WriteFmt("Testing StrForeachPtrInRange\n");

In Str.Foreach.c:375:

    
    // Make idx go out of bounds in StrForeachInRangeIdx by shrinking string during iteration
    bool test_str_foreach_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachInRangeIdx where idx goes out of bounds\n");

In Str.Foreach.c:408:

    
    // Make idx go out of bounds in StrForeachInRangeIdx by deleting characters
    bool test_str_foreach_idx_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachInRangeIdx with character deletion where idx goes out of bounds\n");

In Str.Foreach.c:441:

    
    // Make idx go out of bounds in StrForeachReverseIdx by modifying string during iteration
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachReverseIdx where idx goes out of bounds\n");

In Str.Foreach.c:472:

    
    // Make idx go out of bounds in StrForeachPtrIdx by modifying string during iteration
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachPtrIdx where idx goes out of bounds\n");

In Str.Foreach.c:503:

    
    // Make idx go out of bounds in StrForeachReversePtrIdx by modifying string during iteration
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachReversePtrIdx where idx goes out of bounds\n");

In Str.Foreach.c:533:

    
    // Make idx go out of bounds in StrForeachPtrInRangeIdx by modifying string during iteration
    bool test_str_foreach_ptr_in_range_idx_out_of_bounds_access(void) {
    WriteFmt("Testing StrForeachPtrInRangeIdx where idx goes out of bounds\n");

In Str.Foreach.c:564:

    
    // Make idx go out of bounds in basic StrForeachIdx by modifying string during iteration
    bool test_str_foreach_idx_basic_out_of_bounds_access(void) {
    WriteFmt("Testing basic StrForeachIdx where idx goes out of bounds\n");

In Str.Foreach.c:595:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Foreach.Simple tests\n\n");

In Vec.Access.c:10:

    
    // Function prototypes
    bool test_vec_at(void);
    bool test_vec_ptr_at(void);
    bool test_vec_first_last(void);

In Vec.Access.c:11:

    // Function prototypes
    bool test_vec_at(void);
    bool test_vec_ptr_at(void);
    bool test_vec_first_last(void);
    bool test_vec_begin_end(void);

In Vec.Access.c:12:

    bool test_vec_at(void);
    bool test_vec_ptr_at(void);
    bool test_vec_first_last(void);
    bool test_vec_begin_end(void);
    bool test_vec_size_len(void);

In Vec.Access.c:13:

    bool test_vec_ptr_at(void);
    bool test_vec_first_last(void);
    bool test_vec_begin_end(void);
    bool test_vec_size_len(void);
    bool test_vec_aligned_offset_at(void);

In Vec.Access.c:14:

    bool test_vec_first_last(void);
    bool test_vec_begin_end(void);
    bool test_vec_size_len(void);
    bool test_vec_aligned_offset_at(void);

In Vec.Access.c:15:

    bool test_vec_begin_end(void);
    bool test_vec_size_len(void);
    bool test_vec_aligned_offset_at(void);
    
    // Test VecAt function

In Vec.Access.c:18:

    
    // Test VecAt function
    bool test_vec_at(void) {
    WriteFmt("Testing VecAt\n");

In Vec.Access.c:50:

    
    // Test VecPtrAt function
    bool test_vec_ptr_at(void) {
    WriteFmt("Testing VecPtrAt\n");

In Vec.Access.c:87:

    
    // Test VecFirst and VecLast functions
    bool test_vec_first_last(void) {
    WriteFmt("Testing VecFirst and VecLast\n");

In Vec.Access.c:118:

    
    // Test VecBegin and VecEnd functions
    bool test_vec_begin_end(void) {
    WriteFmt("Testing VecBegin and VecEnd\n");

In Vec.Access.c:148:

    
    // Test VecSize and VecLen functions
    bool test_vec_size_len(void) {
    WriteFmt("Testing VecSize and VecLen\n");

In Vec.Access.c:198:

    
    // Test VecAlignedOffsetAt function
    bool test_vec_aligned_offset_at(void) {
    WriteFmt("Testing VecAlignedOffsetAt\n");

In Vec.Access.c:232:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Access tests\n\n");

In Vec.Remove.c:11:

    
    // Function prototypes
    bool test_vec_pop_back(void);
    bool test_vec_pop_front(void);
    bool test_vec_delete(void);

In Vec.Remove.c:12:

    // Function prototypes
    bool test_vec_pop_back(void);
    bool test_vec_pop_front(void);
    bool test_vec_delete(void);
    bool test_vec_delete_fast(void);

In Vec.Remove.c:13:

    bool test_vec_pop_back(void);
    bool test_vec_pop_front(void);
    bool test_vec_delete(void);
    bool test_vec_delete_fast(void);
    bool test_vec_delete_range(void);

In Vec.Remove.c:14:

    bool test_vec_pop_front(void);
    bool test_vec_delete(void);
    bool test_vec_delete_fast(void);
    bool test_vec_delete_range(void);
    bool test_vec_delete_range_fast(void);

In Vec.Remove.c:15:

    bool test_vec_delete(void);
    bool test_vec_delete_fast(void);
    bool test_vec_delete_range(void);
    bool test_vec_delete_range_fast(void);
    bool test_vec_delete_last(void);

In Vec.Remove.c:16:

    bool test_vec_delete_fast(void);
    bool test_vec_delete_range(void);
    bool test_vec_delete_range_fast(void);
    bool test_vec_delete_last(void);
    bool test_lvalue_delete_operations(void);

In Vec.Remove.c:17:

    bool test_vec_delete_range(void);
    bool test_vec_delete_range_fast(void);
    bool test_vec_delete_last(void);
    bool test_lvalue_delete_operations(void);
    bool test_rvalue_delete_operations(void);

In Vec.Remove.c:18:

    bool test_vec_delete_range_fast(void);
    bool test_vec_delete_last(void);
    bool test_lvalue_delete_operations(void);
    bool test_rvalue_delete_operations(void);
    bool test_lvalue_fast_delete_operations(void);

In Vec.Remove.c:19:

    bool test_vec_delete_last(void);
    bool test_lvalue_delete_operations(void);
    bool test_rvalue_delete_operations(void);
    bool test_lvalue_fast_delete_operations(void);
    bool test_rvalue_fast_delete_operations(void);

In Vec.Remove.c:20:

    bool test_lvalue_delete_operations(void);
    bool test_rvalue_delete_operations(void);
    bool test_lvalue_fast_delete_operations(void);
    bool test_rvalue_fast_delete_operations(void);
    bool test_lvalue_delete_range_operations(void);

In Vec.Remove.c:21:

    bool test_rvalue_delete_operations(void);
    bool test_lvalue_fast_delete_operations(void);
    bool test_rvalue_fast_delete_operations(void);
    bool test_lvalue_delete_range_operations(void);
    bool test_rvalue_delete_range_operations(void);

In Vec.Remove.c:22:

    bool test_lvalue_fast_delete_operations(void);
    bool test_rvalue_fast_delete_operations(void);
    bool test_lvalue_delete_range_operations(void);
    bool test_rvalue_delete_range_operations(void);
    bool test_lvalue_fast_delete_range_operations(void);

In Vec.Remove.c:23:

    bool test_rvalue_fast_delete_operations(void);
    bool test_lvalue_delete_range_operations(void);
    bool test_rvalue_delete_range_operations(void);
    bool test_lvalue_fast_delete_range_operations(void);
    bool test_rvalue_fast_delete_range_operations(void);

In Vec.Remove.c:24:

    bool test_lvalue_delete_range_operations(void);
    bool test_rvalue_delete_range_operations(void);
    bool test_lvalue_fast_delete_range_operations(void);
    bool test_rvalue_fast_delete_range_operations(void);

In Vec.Remove.c:25:

    bool test_rvalue_delete_range_operations(void);
    bool test_lvalue_fast_delete_range_operations(void);
    bool test_rvalue_fast_delete_range_operations(void);
    
    // Test VecPopBack function

In Vec.Remove.c:28:

    
    // Test VecPopBack function
    bool test_vec_pop_back(void) {
    WriteFmtLn("Testing VecPopBack");

In Vec.Remove.c:76:

    
    // Test VecPopFront function
    bool test_vec_pop_front(void) {
    WriteFmtLn("Testing VecPopFront");

In Vec.Remove.c:124:

    
    // Test VecDelete function
    bool test_vec_delete(void) {
    WriteFmtLn("Testing VecDelete");

In Vec.Remove.c:172:

    
    // Test VecDeleteFast function
    bool test_vec_delete_fast(void) {
    WriteFmtLn("Testing VecDeleteFast");

In Vec.Remove.c:209:

    
    // Test VecDeleteRange function
    bool test_vec_delete_range(void) {
    WriteFmtLn("Testing VecDeleteRange");

In Vec.Remove.c:245:

    
    // Test VecDeleteRangeFast
    bool test_vec_delete_range_fast(void) {
    WriteFmtLn("Testing VecDeleteRangeFast");

In Vec.Remove.c:321:

    
    // Test VecDeleteLast function
    bool test_vec_delete_last(void) {
    WriteFmtLn("Testing VecDeleteLast");

In Vec.Remove.c:367:

    
    // Test L-value standard delete operations
    bool test_lvalue_delete_operations(void) {
    WriteFmtLn("Testing L-value standard delete operations");

In Vec.Remove.c:403:

    
    // Test R-value standard delete operations
    bool test_rvalue_delete_operations(void) {
    WriteFmtLn("Testing R-value standard delete operations");

In Vec.Remove.c:438:

    
    // Test L-value fast delete operations
    bool test_lvalue_fast_delete_operations(void) {
    WriteFmtLn("Testing L-value fast delete operations");

In Vec.Remove.c:519:

    
    // Test R-value fast delete operations
    bool test_rvalue_fast_delete_operations(void) {
    WriteFmtLn("Testing R-value fast delete operations");

In Vec.Remove.c:596:

    
    // Test L-value delete range operations
    bool test_lvalue_delete_range_operations(void) {
    WriteFmtLn("Testing L-value delete range operations");

In Vec.Remove.c:633:

    
    // Test R-value delete range operations
    bool test_rvalue_delete_range_operations(void) {
    WriteFmtLn("Testing R-value delete range operations");

In Vec.Remove.c:668:

    
    // Test L-value fast delete range operations
    bool test_lvalue_fast_delete_range_operations(void) {
    WriteFmtLn("Testing L-value fast delete range operations");

In Vec.Remove.c:747:

    
    // Test R-value fast delete range operations
    bool test_rvalue_fast_delete_range_operations(void) {
    WriteFmtLn("Testing R-value fast delete range operations");

In BitVec.Foreach.Deadend.c:11:

    
    // Function prototypes for deadend tests
    bool test_bitvec_foreach_invalid_usage(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);

In BitVec.Foreach.Deadend.c:12:

    // Function prototypes for deadend tests
    bool test_bitvec_foreach_invalid_usage(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);

In BitVec.Foreach.Deadend.c:13:

    bool test_bitvec_foreach_invalid_usage(void);
    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.Deadend.c:14:

    bool test_bitvec_run_lengths_null_bv(void);
    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);

In BitVec.Foreach.Deadend.c:15:

    bool test_bitvec_run_lengths_null_runs(void);
    bool test_bitvec_run_lengths_null_values(void);
    bool test_bitvec_run_lengths_zero_max_runs(void);
    
    // Deadend tests for BitVecRunLengths

In BitVec.Foreach.Deadend.c:19:

    // Deadend tests for BitVecRunLengths
    
    bool test_bitvec_run_lengths_null_bv(void) {
    WriteFmt("Testing BitVecRunLengths with NULL bitvector\n");

In BitVec.Foreach.Deadend.c:31:

    }
    
    bool test_bitvec_run_lengths_null_runs(void) {
    WriteFmt("Testing BitVecRunLengths with NULL runs array\n");

In BitVec.Foreach.Deadend.c:45:

    }
    
    bool test_bitvec_run_lengths_null_values(void) {
    WriteFmt("Testing BitVecRunLengths with NULL values array\n");

In BitVec.Foreach.Deadend.c:59:

    }
    
    bool test_bitvec_run_lengths_zero_max_runs(void) {
    WriteFmt("Testing BitVecRunLengths with zero max_runs\n");

In BitVec.Foreach.Deadend.c:78:

    // with invalid macro usage scenarios
    
    bool test_bitvec_foreach_invalid_usage(void) {
    WriteFmt("Testing BitVec foreach with invalid bitvec\n");

In BitVec.Foreach.Deadend.c:89:

    int count = 0;
    BitVecForeach(&bv, bit) {
    (void)bit;
    count++;
    }

In BitVec.Foreach.Deadend.c:94:

    
    // Should not reach here
    (void)count; // Silence unused variable warning
    return false;
    }

In BitVec.Foreach.Deadend.c:99:

    
    // Main function that runs all deadend tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Foreach.Deadend tests\n\n");

In BitVec.Foreach.Deadend.c:116:

    LI li = ListInit();
    ListForeach(&li, i) {
    (void)i;
    }

In BitVec.Type.c:11:

    
    // Function prototypes
    bool test_bitvec_type_basic(void);
    bool test_bitvec_validate(void);

In BitVec.Type.c:12:

    // Function prototypes
    bool test_bitvec_type_basic(void);
    bool test_bitvec_validate(void);
    
    // Test basic BitVec type functionality

In BitVec.Type.c:15:

    
    // Test basic BitVec type functionality
    bool test_bitvec_type_basic(void) {
    WriteFmt("Testing basic BitVec type functionality\n");

In BitVec.Type.c:31:

    
    // Test ValidateBitVec macro
    bool test_bitvec_validate(void) {
    WriteFmt("Testing ValidateBitVec macro\n");

In BitVec.Type.c:50:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Type tests\n\n");

In BitVec.Pattern.Deadend.c:11:

    
    // Function prototypes for deadend tests
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);

In BitVec.Pattern.Deadend.c:12:

    // Function prototypes for deadend tests
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);

In BitVec.Pattern.Deadend.c:13:

    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);

In BitVec.Pattern.Deadend.c:14:

    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);

In BitVec.Pattern.Deadend.c:15:

    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);

In BitVec.Pattern.Deadend.c:16:

    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);

In BitVec.Pattern.Deadend.c:17:

    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_null_source(void);

In BitVec.Pattern.Deadend.c:18:

    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);

In BitVec.Pattern.Deadend.c:19:

    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);

In BitVec.Pattern.Deadend.c:20:

    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);

In BitVec.Pattern.Deadend.c:21:

    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);

In BitVec.Pattern.Deadend.c:22:

    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);

In BitVec.Pattern.Deadend.c:23:

    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);

In BitVec.Pattern.Deadend.c:24:

    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);

In BitVec.Pattern.Deadend.c:25:

    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);

In BitVec.Pattern.Deadend.c:26:

    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);

In BitVec.Pattern.Deadend.c:27:

    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);

In BitVec.Pattern.Deadend.c:28:

    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);

In BitVec.Pattern.Deadend.c:29:

    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);

In BitVec.Pattern.Deadend.c:30:

    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.Deadend.c:31:

    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.Deadend.c:32:

    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);
    
    // Deadend test 1: BitVecFindPattern with NULL source

In BitVec.Pattern.Deadend.c:35:

    
    // Deadend test 1: BitVecFindPattern with NULL source
    bool test_bitvec_find_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");

In BitVec.Pattern.Deadend.c:48:

    
    // Deadend test 2: BitVecFindPattern with NULL pattern
    bool test_bitvec_find_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");

In BitVec.Pattern.Deadend.c:62:

    
    // Deadend test 3: BitVecFindLastPattern with NULL source
    bool test_bitvec_find_last_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");

In BitVec.Pattern.Deadend.c:75:

    
    // Deadend test 4: BitVecFindLastPattern with NULL pattern
    bool test_bitvec_find_last_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");

In BitVec.Pattern.Deadend.c:89:

    
    // Deadend test 5: BitVecFindAllPattern with NULL source
    bool test_bitvec_find_all_pattern_null_source(void) {
    WriteFmt("Testing BitVecFindAllPattern(NULL, pattern, results, 10) - should fatal\n");

In BitVec.Pattern.Deadend.c:101:

    
    // Deadend test 6: BitVecFindAllPattern with NULL pattern
    bool test_bitvec_find_all_pattern_null_pattern(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");

In BitVec.Pattern.Deadend.c:116:

    
    // Deadend test 7: BitVecFindAllPattern with NULL results
    bool test_bitvec_find_all_pattern_null_results(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");

In BitVec.Pattern.Deadend.c:133:

    
    // Deadend test 8: BitVecFindAllPattern with zero max_results
    bool test_bitvec_find_all_pattern_zero_max_results(void) {
    WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");

In BitVec.Pattern.Deadend.c:152:

    // Additional deadend tests for missing Pattern functions
    
    bool test_bitvec_starts_with_null_source(void) {
    WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
    BitVec prefix = BitVecInit();

In BitVec.Pattern.Deadend.c:161:

    }
    
    bool test_bitvec_starts_with_null_prefix(void) {
    WriteFmt("Testing BitVecStartsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:170:

    }
    
    bool test_bitvec_ends_with_null_source(void) {
    WriteFmt("Testing BitVecEndsWith(NULL, suffix) - should fatal\n");
    BitVec suffix = BitVecInit();

In BitVec.Pattern.Deadend.c:179:

    }
    
    bool test_bitvec_ends_with_null_suffix(void) {
    WriteFmt("Testing BitVecEndsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:188:

    }
    
    bool test_bitvec_contains_at_null_source(void) {
    WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
    BitVec pattern = BitVecInit();

In BitVec.Pattern.Deadend.c:197:

    }
    
    bool test_bitvec_contains_at_null_pattern(void) {
    WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:206:

    }
    
    bool test_bitvec_replace_null_source(void) {
    WriteFmt("Testing BitVecReplace(NULL, old, new) - should fatal\n");

In BitVec.Pattern.Deadend.c:214:

    }
    
    bool test_bitvec_matches_null_source(void) {
    WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
    BitVec pattern  = BitVecInit();

In BitVec.Pattern.Deadend.c:226:

    }
    
    bool test_bitvec_regex_match_null_source(void) {
    WriteFmt("Testing BitVecRegexMatch(NULL, pattern) - should fatal\n");
    BitVecRegexMatch(NULL, "101");

In BitVec.Pattern.Deadend.c:232:

    }
    
    bool test_bitvec_regex_match_null_pattern(void) {
    WriteFmt("Testing BitVecRegexMatch(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:241:

    }
    
    bool test_bitvec_prefix_match_null_source(void) {
    WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
    BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);

In BitVec.Pattern.Deadend.c:250:

    }
    
    bool test_bitvec_prefix_match_null_patterns(void) {
    WriteFmt("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:259:

    }
    
    bool test_bitvec_suffix_match_null_source(void) {
    WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
    BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);

In BitVec.Pattern.Deadend.c:268:

    }
    
    bool test_bitvec_suffix_match_null_patterns(void) {
    WriteFmt("Testing BitVecSuffixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:278:

    
    // Main function that runs all deadend tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Pattern.Deadend tests\n\n");

In Str.Init.c:11:

    
    // Function prototypes
    bool test_str_init(void);
    bool test_str_init_from_cstr(void);
    bool test_str_init_from_zstr(void);

In Str.Init.c:12:

    // Function prototypes
    bool test_str_init(void);
    bool test_str_init_from_cstr(void);
    bool test_str_init_from_zstr(void);
    bool test_str_init_from_str(void);

In Str.Init.c:13:

    bool test_str_init(void);
    bool test_str_init_from_cstr(void);
    bool test_str_init_from_zstr(void);
    bool test_str_init_from_str(void);
    bool test_str_dup(void);

In Str.Init.c:14:

    bool test_str_init_from_cstr(void);
    bool test_str_init_from_zstr(void);
    bool test_str_init_from_str(void);
    bool test_str_dup(void);
    bool test_str_printf(void);

In Str.Init.c:15:

    bool test_str_init_from_zstr(void);
    bool test_str_init_from_str(void);
    bool test_str_dup(void);
    bool test_str_printf(void);
    bool test_str_init_stack(void);

In Str.Init.c:16:

    bool test_str_init_from_str(void);
    bool test_str_dup(void);
    bool test_str_printf(void);
    bool test_str_init_stack(void);
    bool test_str_init_copy(void);

In Str.Init.c:17:

    bool test_str_dup(void);
    bool test_str_printf(void);
    bool test_str_init_stack(void);
    bool test_str_init_copy(void);
    bool test_str_deinit(void);

In Str.Init.c:18:

    bool test_str_printf(void);
    bool test_str_init_stack(void);
    bool test_str_init_copy(void);
    bool test_str_deinit(void);

In Str.Init.c:19:

    bool test_str_init_stack(void);
    bool test_str_init_copy(void);
    bool test_str_deinit(void);
    
    // Test StrInit function

In Str.Init.c:22:

    
    // Test StrInit function
    bool test_str_init(void) {
    WriteFmt("Testing StrInit\n");

In Str.Init.c:39:

    
    // Test StrInitFromCstr function
    bool test_str_init_from_cstr(void) {
    WriteFmt("Testing StrInitFromCstr\n");

In Str.Init.c:57:

    
    // Test StrInitFromZstr function
    bool test_str_init_from_zstr(void) {
    WriteFmt("Testing StrInitFromZstr\n");

In Str.Init.c:74:

    
    // Test StrInitFromStr function
    bool test_str_init_from_str(void) {
    WriteFmt("Testing StrInitFromStr\n");

In Str.Init.c:93:

    
    // Test StrDup function (alias for StrInitFromStr)
    bool test_str_dup(void) {
    WriteFmt("Testing StrDup\n");

In Str.Init.c:112:

    
    // Test StrWriteFmt function
    bool test_str_WriteFmt(void) {
    WriteFmt("Testing StrWriteFmt\n");

In Str.Init.c:129:

    
    // Test StrInitStack macro
    bool test_str_init_stack(void) {
    WriteFmt("Testing StrInitStack\n");

In Str.Init.c:163:

    
    // Test StrInitCopy function
    bool test_str_init_copy(void) {
    WriteFmt("Testing StrInitCopy\n");

In Str.Init.c:185:

    
    // Test StrDeinit function
    bool test_str_deinit(void) {
    WriteFmt("Testing StrDeinit\n");

In Str.Init.c:204:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Init tests\n\n");

In Str.Ops.c:12:

    
    // Function prototypes
    bool test_str_cmp(void);
    bool test_str_find(void);
    bool test_str_starts_ends_with(void);

In Str.Ops.c:13:

    // Function prototypes
    bool test_str_cmp(void);
    bool test_str_find(void);
    bool test_str_starts_ends_with(void);
    bool test_str_replace(void);

In Str.Ops.c:14:

    bool test_str_cmp(void);
    bool test_str_find(void);
    bool test_str_starts_ends_with(void);
    bool test_str_replace(void);
    bool test_str_split(void);

In Str.Ops.c:15:

    bool test_str_find(void);
    bool test_str_starts_ends_with(void);
    bool test_str_replace(void);
    bool test_str_split(void);
    bool test_str_strip(void);

In Str.Ops.c:16:

    bool test_str_starts_ends_with(void);
    bool test_str_replace(void);
    bool test_str_split(void);
    bool test_str_strip(void);

In Str.Ops.c:17:

    bool test_str_replace(void);
    bool test_str_split(void);
    bool test_str_strip(void);
    
    // Test string comparison functions

In Str.Ops.c:20:

    
    // Test string comparison functions
    bool test_str_cmp(void) {
    WriteFmt("Testing StrCmp and StrCmpCstr\n");

In Str.Ops.c:55:

    
    // Test string find functions
    bool test_str_find(void) {
    WriteFmt("Testing StrFindStr, StrFindZstr, and StrFindCstr\n");

In Str.Ops.c:91:

    
    // Test string starts/ends with functions
    bool test_str_starts_ends_with(void) {
    WriteFmt("Testing StrStartsWith and StrEndsWith variants\n");

In Str.Ops.c:127:

    
    // Test string replace functions
    bool test_str_replace(void) {
    WriteFmt("Testing StrReplace variants\n");

In Str.Ops.c:162:

    
    // Test string split functions
    bool test_str_split(void) {
    WriteFmt("Testing StrSplit and StrSplitToIters\n");

In Str.Ops.c:208:

    
    // Test string strip functions
    bool test_str_strip(void) {
    WriteFmt("Testing StrStrip variants\n");

In Str.Ops.c:248:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Ops tests\n\n");

In BitVec.BitWise.c:11:

    
    // Function prototypes
    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);

In BitVec.BitWise.c:12:

    // Function prototypes
    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);

In BitVec.BitWise.c:13:

    bool test_bitvec_and(void);
    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);

In BitVec.BitWise.c:14:

    bool test_bitvec_or(void);
    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);

In BitVec.BitWise.c:15:

    bool test_bitvec_xor(void);
    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);

In BitVec.BitWise.c:16:

    bool test_bitvec_not(void);
    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);

In BitVec.BitWise.c:17:

    bool test_bitvec_shift_left(void);
    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);

In BitVec.BitWise.c:18:

    bool test_bitvec_shift_right(void);
    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);

In BitVec.BitWise.c:19:

    bool test_bitvec_rotate_left(void);
    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);

In BitVec.BitWise.c:20:

    bool test_bitvec_rotate_right(void);
    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);

In BitVec.BitWise.c:21:

    bool test_bitvec_reverse(void);
    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);

In BitVec.BitWise.c:22:

    bool test_bitvec_shift_edge_cases(void);
    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);

In BitVec.BitWise.c:23:

    bool test_bitvec_rotate_edge_cases(void);
    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);

In BitVec.BitWise.c:24:

    bool test_bitvec_bitwise_ops_edge_cases(void);
    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);

In BitVec.BitWise.c:25:

    bool test_bitvec_reverse_edge_cases(void);
    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);

In BitVec.BitWise.c:26:

    bool test_bitvec_bitwise_comprehensive(void);
    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);

In BitVec.BitWise.c:27:

    bool test_bitvec_shift_comprehensive(void);
    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);

In BitVec.BitWise.c:28:

    bool test_bitvec_rotate_comprehensive(void);
    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);

In BitVec.BitWise.c:29:

    bool test_bitvec_bitwise_identity_operations(void);
    bool test_bitvec_bitwise_commutative_properties(void);
    bool test_bitvec_bitwise_large_patterns(void);
    
    // Test BitVecAnd function

In BitVec.BitWise.c:32:

    
    // Test BitVecAnd function
    bool test_bitvec_and(void) {
    WriteFmtLn("Testing BitVecAnd");

In BitVec.BitWise.c:70:

    
    // Test BitVecOr function
    bool test_bitvec_or(void) {
    WriteFmtLn("Testing BitVecOr");

In BitVec.BitWise.c:108:

    
    // Test BitVecXor function
    bool test_bitvec_xor(void) {
    WriteFmtLn("Testing BitVecXor");

In BitVec.BitWise.c:146:

    
    // Test BitVecNot function
    bool test_bitvec_not(void) {
    WriteFmtLn("Testing BitVecNot");

In BitVec.BitWise.c:176:

    
    // Test BitVecShiftLeft function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_left(void) {
    WriteFmtLn("Testing BitVecShiftLeft");

In BitVec.BitWise.c:217:

    
    // Test BitVecShiftRight function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_right(void) {
    WriteFmtLn("Testing BitVecShiftRight");

In BitVec.BitWise.c:251:

    
    // Test BitVecRotateLeft function
    bool test_bitvec_rotate_left(void) {
    WriteFmtLn("Testing BitVecRotateLeft");

In BitVec.BitWise.c:279:

    
    // Test BitVecRotateRight function
    bool test_bitvec_rotate_right(void) {
    WriteFmtLn("Testing BitVecRotateRight");

In BitVec.BitWise.c:307:

    
    // Test BitVecReverse function
    bool test_bitvec_reverse(void) {
    WriteFmtLn("Testing BitVecReverse");

In BitVec.BitWise.c:335:

    
    // Edge case tests
    bool test_bitvec_shift_edge_cases(void) {
    WriteFmtLn("Testing BitVec shift edge cases");

In BitVec.BitWise.c:371:

    }
    
    bool test_bitvec_rotate_edge_cases(void) {
    WriteFmtLn("Testing BitVec rotate edge cases");

In BitVec.BitWise.c:399:

    }
    
    bool test_bitvec_bitwise_ops_edge_cases(void) {
    WriteFmtLn("Testing BitVec bitwise operations edge cases");

In BitVec.BitWise.c:438:

    }
    
    bool test_bitvec_reverse_edge_cases(void) {
    WriteFmtLn("Testing BitVecReverse edge cases");

In BitVec.BitWise.c:472:

    
    // NEW: Comprehensive bitwise operations testing
    bool test_bitvec_bitwise_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive bitwise operations");

In BitVec.BitWise.c:538:

    
    // NEW: Comprehensive shift testing
    bool test_bitvec_shift_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive shift operations");

In BitVec.BitWise.c:604:

    
    // NEW: Comprehensive rotate testing
    bool test_bitvec_rotate_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive rotate operations");

In BitVec.BitWise.c:666:

    
    // NEW: Identity operations testing
    bool test_bitvec_bitwise_identity_operations(void) {
    WriteFmtLn("Testing BitVec bitwise identity operations");

In BitVec.BitWise.c:760:

    
    // NEW: Commutative properties testing
    bool test_bitvec_bitwise_commutative_properties(void) {
    WriteFmtLn("Testing BitVec bitwise commutative properties");

In BitVec.BitWise.c:822:

    
    // NEW: Large pattern testing
    bool test_bitvec_bitwise_large_patterns(void) {
    WriteFmtLn("Testing BitVec bitwise operations with large patterns");

In BitVec.BitWise.c:883:

    
    // Deadend tests
    bool test_bitvec_bitwise_null_failures(void) {
    WriteFmtLn("Testing BitVec bitwise NULL pointer handling");

In BitVec.BitWise.c:892:

    }
    
    bool test_bitvec_bitwise_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec bitwise operations NULL handling");

In BitVec.BitWise.c:906:

    }
    
    bool test_bitvec_reverse_null_failures(void) {
    WriteFmtLn("Testing BitVec reverse NULL handling");

In BitVec.BitWise.c:916:

    
    // NEW: Additional deadend tests
    bool test_bitvec_shift_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec shift operations NULL handling");

In BitVec.BitWise.c:925:

    }
    
    bool test_bitvec_rotate_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec rotate operations NULL handling");

In BitVec.BitWise.c:934:

    }
    
    bool test_bitvec_and_result_null_failures(void) {
    WriteFmtLn("Testing BitVec AND with NULL result handling");

In BitVec.BitWise.c:950:

    }
    
    bool test_bitvec_or_operand_null_failures(void) {
    WriteFmtLn("Testing BitVec OR with NULL operand handling");

In BitVec.BitWise.c:964:

    }
    
    bool test_bitvec_xor_second_operand_null_failures(void) {
    WriteFmtLn("Testing BitVec XOR with NULL second operand handling");

In BitVec.BitWise.c:978:

    }
    
    bool test_bitvec_not_null_failures(void) {
    WriteFmtLn("Testing BitVec NOT with NULL handling");

In BitVec.BitWise.c:991:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmtLn("[INFO] Starting BitVec.BitWise tests");

In BitVec.Pattern.Simple.c:11:

    
    // Function prototypes
    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);

In BitVec.Pattern.Simple.c:12:

    // Function prototypes
    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);

In BitVec.Pattern.Simple.c:13:

    bool test_bitvec_basic_pattern_functions(void);
    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);

In BitVec.Pattern.Simple.c:14:

    bool test_bitvec_find_pattern(void);
    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);

In BitVec.Pattern.Simple.c:15:

    bool test_bitvec_find_last_pattern(void);
    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);

In BitVec.Pattern.Simple.c:16:

    bool test_bitvec_find_all_pattern(void);
    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);

In BitVec.Pattern.Simple.c:17:

    bool test_bitvec_pattern_edge_cases(void);
    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);

In BitVec.Pattern.Simple.c:18:

    bool test_bitvec_pattern_stress_tests(void);
    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);

In BitVec.Pattern.Simple.c:19:

    bool test_bitvec_find_pattern_null_source(void);
    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);

In BitVec.Pattern.Simple.c:20:

    bool test_bitvec_find_pattern_null_pattern(void);
    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);

In BitVec.Pattern.Simple.c:21:

    bool test_bitvec_find_last_pattern_null_source(void);
    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);

In BitVec.Pattern.Simple.c:22:

    bool test_bitvec_find_last_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);

In BitVec.Pattern.Simple.c:23:

    bool test_bitvec_find_all_pattern_null_source(void);
    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);

In BitVec.Pattern.Simple.c:24:

    bool test_bitvec_find_all_pattern_null_pattern(void);
    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);

In BitVec.Pattern.Simple.c:25:

    bool test_bitvec_find_all_pattern_null_results(void);
    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);

In BitVec.Pattern.Simple.c:26:

    bool test_bitvec_find_all_pattern_zero_max_results(void);
    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);

In BitVec.Pattern.Simple.c:27:

    bool test_bitvec_starts_with_basic(void);
    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);

In BitVec.Pattern.Simple.c:28:

    bool test_bitvec_starts_with_edge_cases(void);
    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);

In BitVec.Pattern.Simple.c:29:

    bool test_bitvec_ends_with_basic(void);
    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);

In BitVec.Pattern.Simple.c:30:

    bool test_bitvec_ends_with_edge_cases(void);
    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);

In BitVec.Pattern.Simple.c:31:

    bool test_bitvec_contains_basic(void);
    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);

In BitVec.Pattern.Simple.c:32:

    bool test_bitvec_contains_at_basic(void);
    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);

In BitVec.Pattern.Simple.c:33:

    bool test_bitvec_contains_at_edge_cases(void);
    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);

In BitVec.Pattern.Simple.c:34:

    bool test_bitvec_count_pattern_basic(void);
    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);

In BitVec.Pattern.Simple.c:35:

    bool test_bitvec_rfind_pattern_basic(void);
    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);

In BitVec.Pattern.Simple.c:36:

    bool test_bitvec_replace_basic(void);
    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);

In BitVec.Pattern.Simple.c:37:

    bool test_bitvec_replace_all_basic(void);
    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);

In BitVec.Pattern.Simple.c:38:

    bool test_bitvec_matches_basic(void);
    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);

In BitVec.Pattern.Simple.c:39:

    bool test_bitvec_fuzzy_match_basic(void);
    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);

In BitVec.Pattern.Simple.c:40:

    bool test_bitvec_regex_match_basic(void);
    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);

In BitVec.Pattern.Simple.c:41:

    bool test_bitvec_prefix_match_basic(void);
    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);

In BitVec.Pattern.Simple.c:42:

    bool test_bitvec_suffix_match_basic(void);
    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);

In BitVec.Pattern.Simple.c:43:

    bool test_bitvec_starts_with_null_source(void);
    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);

In BitVec.Pattern.Simple.c:44:

    bool test_bitvec_starts_with_null_prefix(void);
    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);

In BitVec.Pattern.Simple.c:45:

    bool test_bitvec_ends_with_null_source(void);
    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);

In BitVec.Pattern.Simple.c:46:

    bool test_bitvec_ends_with_null_suffix(void);
    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);

In BitVec.Pattern.Simple.c:47:

    bool test_bitvec_contains_at_null_source(void);
    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);

In BitVec.Pattern.Simple.c:48:

    bool test_bitvec_contains_at_null_pattern(void);
    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);

In BitVec.Pattern.Simple.c:49:

    bool test_bitvec_replace_null_source(void);
    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);

In BitVec.Pattern.Simple.c:50:

    bool test_bitvec_matches_null_source(void);
    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);

In BitVec.Pattern.Simple.c:51:

    bool test_bitvec_regex_match_null_source(void);
    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);

In BitVec.Pattern.Simple.c:52:

    bool test_bitvec_regex_match_null_pattern(void);
    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.Simple.c:53:

    bool test_bitvec_prefix_match_null_source(void);
    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);

In BitVec.Pattern.Simple.c:54:

    bool test_bitvec_prefix_match_null_patterns(void);
    bool test_bitvec_suffix_match_null_source(void);
    bool test_bitvec_suffix_match_null_patterns(void);
    
    // Test basic pattern matching functions

In BitVec.Pattern.Simple.c:57:

    
    // Test basic pattern matching functions
    bool test_bitvec_basic_pattern_functions(void) {
    WriteFmt("Testing basic BitVec pattern functions\n");

In BitVec.Pattern.Simple.c:92:

    
    // Test BitVecFindPattern function comprehensively
    bool test_bitvec_find_pattern(void) {
    WriteFmt("Testing BitVecFindPattern function\n");

In BitVec.Pattern.Simple.c:139:

    
    // Test BitVecFindLastPattern function
    bool test_bitvec_find_last_pattern(void) {
    WriteFmt("Testing BitVecFindLastPattern function\n");

In BitVec.Pattern.Simple.c:184:

    
    // Test BitVecFindAllPattern function
    bool test_bitvec_find_all_pattern(void) {
    WriteFmt("Testing BitVecFindAllPattern function\n");

In BitVec.Pattern.Simple.c:242:

    
    // Test edge cases for pattern functions
    bool test_bitvec_pattern_edge_cases(void) {
    WriteFmt("Testing BitVec pattern edge cases\n");

In BitVec.Pattern.Simple.c:311:

    
    // Stress tests with large data
    bool test_bitvec_pattern_stress_tests(void) {
    WriteFmt("Testing BitVec pattern stress tests\n");

In BitVec.Pattern.Simple.c:354:

    
    // BitVecStartsWith tests
    bool test_bitvec_starts_with_basic(void) {
    WriteFmt("Testing BitVecStartsWith basic functionality\n");

In BitVec.Pattern.Simple.c:389:

    }
    
    bool test_bitvec_starts_with_edge_cases(void) {
    WriteFmt("Testing BitVecStartsWith edge cases\n");

In BitVec.Pattern.Simple.c:421:

    
    // BitVecEndsWith tests
    bool test_bitvec_ends_with_basic(void) {
    WriteFmt("Testing BitVecEndsWith basic functionality\n");

In BitVec.Pattern.Simple.c:456:

    }
    
    bool test_bitvec_ends_with_edge_cases(void) {
    WriteFmt("Testing BitVecEndsWith edge cases\n");

In BitVec.Pattern.Simple.c:479:

    
    // BitVecFindPattern tests (replacing BitVecContains)
    bool test_bitvec_contains_basic(void) {
    WriteFmt("Testing BitVecFindPattern basic functionality\n");

In BitVec.Pattern.Simple.c:516:

    
    // BitVecContainsAt tests
    bool test_bitvec_contains_at_basic(void) {
    WriteFmt("Testing BitVecContainsAt basic functionality\n");

In BitVec.Pattern.Simple.c:546:

    }
    
    bool test_bitvec_contains_at_edge_cases(void) {
    WriteFmt("Testing BitVecContainsAt edge cases\n");

In BitVec.Pattern.Simple.c:570:

    
    // BitVecCountPattern tests
    bool test_bitvec_count_pattern_basic(void) {
    WriteFmt("Testing BitVecCountPattern basic functionality\n");

In BitVec.Pattern.Simple.c:605:

    
    // BitVecRFindPattern tests
    bool test_bitvec_rfind_pattern_basic(void) {
    WriteFmt("Testing BitVecRFindPattern basic functionality\n");

In BitVec.Pattern.Simple.c:642:

    
    // BitVecReplace tests
    bool test_bitvec_replace_basic(void) {
    WriteFmt("Testing BitVecReplace basic functionality\n");

In BitVec.Pattern.Simple.c:684:

    
    // BitVecReplaceAll tests
    bool test_bitvec_replace_all_basic(void) {
    WriteFmt("Testing BitVecReplaceAll basic functionality\n");

In BitVec.Pattern.Simple.c:721:

    
    // BitVecMatches tests
    bool test_bitvec_matches_basic(void) {
    WriteFmt("Testing BitVecMatches basic functionality\n");

In BitVec.Pattern.Simple.c:756:

    
    // BitVecFuzzyMatch tests
    bool test_bitvec_fuzzy_match_basic(void) {
    WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");

In BitVec.Pattern.Simple.c:792:

    
    // BitVecRegexMatch tests
    bool test_bitvec_regex_match_basic(void) {
    WriteFmt("Testing BitVecRegexMatch basic functionality\n");

In BitVec.Pattern.Simple.c:815:

    
    // BitVecPrefixMatch tests
    bool test_bitvec_prefix_match_basic(void) {
    WriteFmt("Testing BitVecPrefixMatch basic functionality\n");

In BitVec.Pattern.Simple.c:864:

    
    // BitVecSuffixMatch tests
    bool test_bitvec_suffix_match_basic(void) {
    WriteFmt("Testing BitVecSuffixMatch basic functionality\n");

In BitVec.Pattern.Simple.c:913:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Pattern.Simple tests\n\n");

In BitVec.Access.Simple.c:11:

    
    // Function prototypes
    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);

In BitVec.Access.Simple.c:12:

    // Function prototypes
    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);

In BitVec.Access.Simple.c:13:

    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);

In BitVec.Access.Simple.c:14:

    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);

In BitVec.Access.Simple.c:15:

    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);

In BitVec.Access.Simple.c:16:

    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);

In BitVec.Access.Simple.c:17:

    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);

In BitVec.Access.Simple.c:18:

    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);

In BitVec.Access.Simple.c:19:

    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);

In BitVec.Access.Simple.c:20:

    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);

In BitVec.Access.Simple.c:21:

    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);

In BitVec.Access.Simple.c:22:

    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);

In BitVec.Access.Simple.c:23:

    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);

In BitVec.Access.Simple.c:24:

    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);

In BitVec.Access.Simple.c:25:

    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);

In BitVec.Access.Simple.c:26:

    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);

In BitVec.Access.Simple.c:27:

    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);

In BitVec.Access.Simple.c:28:

    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);

In BitVec.Access.Simple.c:29:

    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);

In BitVec.Access.Simple.c:30:

    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);
    
    // Test BitVecGet function

In BitVec.Access.Simple.c:33:

    
    // Test BitVecGet function
    bool test_bitvec_get(void) {
    WriteFmt("Testing BitVecGet\n");

In BitVec.Access.Simple.c:53:

    
    // Test BitVecSet function
    bool test_bitvec_set(void) {
    WriteFmt("Testing BitVecSet\n");

In BitVec.Access.Simple.c:74:

    
    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
    WriteFmt("Testing BitVecFlip\n");

In BitVec.Access.Simple.c:100:

    
    // Test BitVecLength and BitVecCapacity functions
    bool test_bitvec_length_capacity(void) {
    WriteFmt("Testing BitVecLength and BitVecCapacity\n");

In BitVec.Access.Simple.c:126:

    
    // Test BitVecCount functions
    bool test_bitvec_count_operations(void) {
    WriteFmt("Testing BitVecCount operations\n");

In BitVec.Access.Simple.c:146:

    
    // Edge case tests for BitVecGet
    bool test_bitvec_get_edge_cases(void) {
    WriteFmt("Testing BitVecGet edge cases\n");

In BitVec.Access.Simple.c:168:

    
    // Edge case tests for BitVecSet
    bool test_bitvec_set_edge_cases(void) {
    WriteFmt("Testing BitVecSet edge cases\n");

In BitVec.Access.Simple.c:187:

    
    // Edge case tests for BitVecFlip
    bool test_bitvec_flip_edge_cases(void) {
    WriteFmt("Testing BitVecFlip edge cases\n");

In BitVec.Access.Simple.c:206:

    
    // Edge case tests for BitVecCount
    bool test_bitvec_count_edge_cases(void) {
    WriteFmt("Testing BitVecCount edge cases\n");

In BitVec.Access.Simple.c:234:

    
    // Test multiple operations together
    bool test_bitvec_access_multiple_operations(void) {
    WriteFmt("Testing BitVec multiple access operations\n");

In BitVec.Access.Simple.c:271:

    
    // Test with large patterns
    bool test_bitvec_access_large_patterns(void) {
    WriteFmt("Testing BitVec access with large patterns\n");

In BitVec.Access.Simple.c:306:

    
    // Test macro functions
    bool test_bitvec_macro_functions(void) {
    WriteFmt("Testing BitVec macro functions\n");

In BitVec.Access.Simple.c:336:

    
    // Stress test for access operations
    bool test_bitvec_access_stress_test(void) {
    WriteFmt("Testing BitVec access stress test\n");

In BitVec.Access.Simple.c:386:

    
    // Comprehensive bit pattern testing
    bool test_bitvec_bit_patterns_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive bit patterns\n");

In BitVec.Access.Simple.c:440:

    
    // Test BitVecFind functions (Find, FindLast)
    bool test_bitvec_find_functions(void) {
    WriteFmt("Testing BitVecFind functions\n");

In BitVec.Access.Simple.c:474:

    
    // Test BitVec predicate functions (All, Any, None)
    bool test_bitvec_predicate_functions(void) {
    WriteFmt("Testing BitVec predicate functions\n");

In BitVec.Access.Simple.c:521:

    
    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
    WriteFmt("Testing BitVecLongestRun\n");

In BitVec.Access.Simple.c:558:

    
    // Edge case tests for Find functions
    bool test_bitvec_find_edge_cases(void) {
    WriteFmt("Testing BitVecFind edge cases\n");

In BitVec.Access.Simple.c:590:

    
    // Edge case tests for predicate functions
    bool test_bitvec_predicate_edge_cases(void) {
    WriteFmt("Testing BitVec predicate edge cases\n");

In BitVec.Access.Simple.c:630:

    
    // Edge case tests for LongestRun function
    bool test_bitvec_longest_run_edge_cases(void) {
    WriteFmt("Testing BitVecLongestRun edge cases\n");

In BitVec.Access.Simple.c:663:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Access.Simple tests\n\n");

In Str.Insert.c:11:

    
    // Function prototypes
    bool test_str_insert_char_at(void);
    bool test_str_insert_cstr(void);
    bool test_str_insert_zstr(void);

In Str.Insert.c:12:

    // Function prototypes
    bool test_str_insert_char_at(void);
    bool test_str_insert_cstr(void);
    bool test_str_insert_zstr(void);
    bool test_str_insert(void);

In Str.Insert.c:13:

    bool test_str_insert_char_at(void);
    bool test_str_insert_cstr(void);
    bool test_str_insert_zstr(void);
    bool test_str_insert(void);
    bool test_str_push_cstr(void);

In Str.Insert.c:14:

    bool test_str_insert_cstr(void);
    bool test_str_insert_zstr(void);
    bool test_str_insert(void);
    bool test_str_push_cstr(void);
    bool test_str_push_zstr(void);

In Str.Insert.c:15:

    bool test_str_insert_zstr(void);
    bool test_str_insert(void);
    bool test_str_push_cstr(void);
    bool test_str_push_zstr(void);
    bool test_str_push_back_cstr(void);

In Str.Insert.c:16:

    bool test_str_insert(void);
    bool test_str_push_cstr(void);
    bool test_str_push_zstr(void);
    bool test_str_push_back_cstr(void);
    bool test_str_push_back_zstr(void);

In Str.Insert.c:17:

    bool test_str_push_cstr(void);
    bool test_str_push_zstr(void);
    bool test_str_push_back_cstr(void);
    bool test_str_push_back_zstr(void);
    bool test_str_push_front_cstr(void);

In Str.Insert.c:18:

    bool test_str_push_zstr(void);
    bool test_str_push_back_cstr(void);
    bool test_str_push_back_zstr(void);
    bool test_str_push_front_cstr(void);
    bool test_str_push_front_zstr(void);

In Str.Insert.c:19:

    bool test_str_push_back_cstr(void);
    bool test_str_push_back_zstr(void);
    bool test_str_push_front_cstr(void);
    bool test_str_push_front_zstr(void);
    bool test_str_push_back(void);

In Str.Insert.c:20:

    bool test_str_push_back_zstr(void);
    bool test_str_push_front_cstr(void);
    bool test_str_push_front_zstr(void);
    bool test_str_push_back(void);
    bool test_str_push_front(void);

In Str.Insert.c:21:

    bool test_str_push_front_cstr(void);
    bool test_str_push_front_zstr(void);
    bool test_str_push_back(void);
    bool test_str_push_front(void);
    bool test_str_merge_l(void);

In Str.Insert.c:22:

    bool test_str_push_front_zstr(void);
    bool test_str_push_back(void);
    bool test_str_push_front(void);
    bool test_str_merge_l(void);
    bool test_str_merge_r(void);

In Str.Insert.c:23:

    bool test_str_push_back(void);
    bool test_str_push_front(void);
    bool test_str_merge_l(void);
    bool test_str_merge_r(void);
    bool test_str_merge(void);

In Str.Insert.c:24:

    bool test_str_push_front(void);
    bool test_str_merge_l(void);
    bool test_str_merge_r(void);
    bool test_str_merge(void);
    bool test_str_appendf(void);

In Str.Insert.c:25:

    bool test_str_merge_l(void);
    bool test_str_merge_r(void);
    bool test_str_merge(void);
    bool test_str_appendf(void);

In Str.Insert.c:26:

    bool test_str_merge_r(void);
    bool test_str_merge(void);
    bool test_str_appendf(void);
    
    // Test StrInsertCharAt function

In Str.Insert.c:29:

    
    // Test StrInsertCharAt function
    bool test_str_insert_char_at(void) {
    WriteFmt("Testing StrInsertCharAt\n");

In Str.Insert.c:57:

    
    // Test StrInsertCstr function
    bool test_str_insert_cstr(void) {
    WriteFmt("Testing StrInsertCstr\n");

In Str.Insert.c:73:

    
    // Test StrInsertZstr function
    bool test_str_insert_zstr(void) {
    WriteFmt("Testing StrInsertZstr\n");

In Str.Insert.c:89:

    
    // Test StrInsert function
    bool test_str_insert(void) {
    WriteFmt("Testing StrInsert\n");

In Str.Insert.c:107:

    
    // Test StrPushCstr function
    bool test_str_push_cstr(void) {
    WriteFmt("Testing StrPushCstr\n");

In Str.Insert.c:123:

    
    // Test StrPushZstr function
    bool test_str_push_zstr(void) {
    WriteFmt("Testing StrPushZstr\n");

In Str.Insert.c:139:

    
    // Test StrPushBackCstr function
    bool test_str_push_back_cstr(void) {
    WriteFmt("Testing StrPushBackCstr\n");

In Str.Insert.c:155:

    
    // Test StrPushBackZstr function
    bool test_str_push_back_zstr(void) {
    WriteFmt("Testing StrPushBackZstr\n");

In Str.Insert.c:171:

    
    // Test StrPushFrontCstr function
    bool test_str_push_front_cstr(void) {
    WriteFmt("Testing StrPushFrontCstr\n");

In Str.Insert.c:187:

    
    // Test StrPushFrontZstr function
    bool test_str_push_front_zstr(void) {
    WriteFmt("Testing StrPushFrontZstr\n");

In Str.Insert.c:203:

    
    // Test StrPushBack function
    bool test_str_push_back(void) {
    WriteFmt("Testing StrPushBack\n");

In Str.Insert.c:224:

    
    // Test StrPushFront function
    bool test_str_push_front(void) {
    WriteFmt("Testing StrPushFront\n");

In Str.Insert.c:245:

    
    // Test StrMergeL function
    bool test_str_merge_l(void) {
    WriteFmt("Testing StrMergeL\n");

In Str.Insert.c:270:

    
    // Test StrMergeR function
    bool test_str_merge_r(void) {
    WriteFmt("Testing StrMergeR\n");

In Str.Insert.c:291:

    
    // Test StrMerge function (alias for StrMergeR)
    bool test_str_merge(void) {
    WriteFmt("Testing StrMerge\n");

In Str.Insert.c:312:

    
    // Test StrAppendf function
    bool test_str_appendf(void) {
    WriteFmt("Testing StrAppendf\n");

In Str.Insert.c:328:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Insert tests\n\n");

In Str.Memory.c:10:

    
    // Function prototypes
    bool test_str_try_reduce_space(void);
    bool test_str_swap_char_at(void);
    bool test_str_resize(void);

In Str.Memory.c:11:

    // Function prototypes
    bool test_str_try_reduce_space(void);
    bool test_str_swap_char_at(void);
    bool test_str_resize(void);
    bool test_str_reserve(void);

In Str.Memory.c:12:

    bool test_str_try_reduce_space(void);
    bool test_str_swap_char_at(void);
    bool test_str_resize(void);
    bool test_str_reserve(void);
    bool test_str_clear(void);

In Str.Memory.c:13:

    bool test_str_swap_char_at(void);
    bool test_str_resize(void);
    bool test_str_reserve(void);
    bool test_str_clear(void);
    bool test_str_reverse(void);

In Str.Memory.c:14:

    bool test_str_resize(void);
    bool test_str_reserve(void);
    bool test_str_clear(void);
    bool test_str_reverse(void);

In Str.Memory.c:15:

    bool test_str_reserve(void);
    bool test_str_clear(void);
    bool test_str_reverse(void);
    
    // Test StrTryReduceSpace function

In Str.Memory.c:18:

    
    // Test StrTryReduceSpace function
    bool test_str_try_reduce_space(void) {
    WriteFmt("Testing StrTryReduceSpace\n");

In Str.Memory.c:43:

    
    // Test StrSwapCharAt function
    bool test_str_swap_char_at(void) {
    WriteFmt("Testing StrSwapCharAt\n");

In Str.Memory.c:65:

    
    // Test StrResize function
    bool test_str_resize(void) {
    WriteFmt("Testing StrResize\n");

In Str.Memory.c:91:

    
    // Test StrReserve function
    bool test_str_reserve(void) {
    WriteFmt("Testing StrReserve\n");

In Str.Memory.c:116:

    
    // Test StrClear function
    bool test_str_clear(void) {
    WriteFmt("Testing StrClear\n");

In Str.Memory.c:138:

    
    // Test StrReverse function
    bool test_str_reverse(void) {
    WriteFmt("Testing StrReverse\n");

In Str.Memory.c:184:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Str.Memory tests\n\n");

In BitVec.Init.c:10:

    
    // Function prototypes
    bool test_bitvec_init(void);
    bool test_bitvec_deinit(void);
    bool test_bitvec_reserve(void);

In BitVec.Init.c:11:

    // Function prototypes
    bool test_bitvec_init(void);
    bool test_bitvec_deinit(void);
    bool test_bitvec_reserve(void);
    bool test_bitvec_clear(void);

In BitVec.Init.c:12:

    bool test_bitvec_init(void);
    bool test_bitvec_deinit(void);
    bool test_bitvec_reserve(void);
    bool test_bitvec_clear(void);
    bool test_bitvec_resize(void);

In BitVec.Init.c:13:

    bool test_bitvec_deinit(void);
    bool test_bitvec_reserve(void);
    bool test_bitvec_clear(void);
    bool test_bitvec_resize(void);
    bool test_bitvec_init_edge_cases(void);

In BitVec.Init.c:14:

    bool test_bitvec_reserve(void);
    bool test_bitvec_clear(void);
    bool test_bitvec_resize(void);
    bool test_bitvec_init_edge_cases(void);
    bool test_bitvec_deinit_edge_cases(void);

In BitVec.Init.c:15:

    bool test_bitvec_clear(void);
    bool test_bitvec_resize(void);
    bool test_bitvec_init_edge_cases(void);
    bool test_bitvec_deinit_edge_cases(void);
    bool test_bitvec_reserve_edge_cases(void);

In BitVec.Init.c:16:

    bool test_bitvec_resize(void);
    bool test_bitvec_init_edge_cases(void);
    bool test_bitvec_deinit_edge_cases(void);
    bool test_bitvec_reserve_edge_cases(void);
    bool test_bitvec_clear_edge_cases(void);

In BitVec.Init.c:17:

    bool test_bitvec_init_edge_cases(void);
    bool test_bitvec_deinit_edge_cases(void);
    bool test_bitvec_reserve_edge_cases(void);
    bool test_bitvec_clear_edge_cases(void);
    bool test_bitvec_resize_edge_cases(void);

In BitVec.Init.c:18:

    bool test_bitvec_deinit_edge_cases(void);
    bool test_bitvec_reserve_edge_cases(void);
    bool test_bitvec_clear_edge_cases(void);
    bool test_bitvec_resize_edge_cases(void);
    bool test_bitvec_multiple_cycles(void);

In BitVec.Init.c:19:

    bool test_bitvec_reserve_edge_cases(void);
    bool test_bitvec_clear_edge_cases(void);
    bool test_bitvec_resize_edge_cases(void);
    bool test_bitvec_multiple_cycles(void);

In BitVec.Init.c:20:

    bool test_bitvec_clear_edge_cases(void);
    bool test_bitvec_resize_edge_cases(void);
    bool test_bitvec_multiple_cycles(void);
    
    // Test BitVecInit function

In BitVec.Init.c:23:

    
    // Test BitVecInit function
    bool test_bitvec_init(void) {
    WriteFmt("Testing BitVecInit\n");

In BitVec.Init.c:42:

    
    // Test BitVecDeinit function
    bool test_bitvec_deinit(void) {
    WriteFmt("Testing BitVecDeinit\n");

In BitVec.Init.c:70:

    
    // Test BitVecReserve function
    bool test_bitvec_reserve(void) {
    WriteFmt("Testing BitVecReserve\n");

In BitVec.Init.c:103:

    
    // Test BitVecClear function
    bool test_bitvec_clear(void) {
    WriteFmt("Testing BitVecClear\n");

In BitVec.Init.c:138:

    
    // Test BitVecReu64 function
    bool test_bitvec_resize(void) {
    WriteFmt("Testing BitVecResize\n");

In BitVec.Init.c:179:

    
    // Edge case tests - boundary conditions and unusual but valid inputs
    bool test_bitvec_init_edge_cases(void) {
    WriteFmt("Testing BitVecInit edge cases\n");

In BitVec.Init.c:198:

    }
    
    bool test_bitvec_reserve_edge_cases(void) {
    WriteFmt("Testing BitVecReserve edge cases\n");

In BitVec.Init.c:226:

    }
    
    bool test_bitvec_resize_edge_cases(void) {
    WriteFmt("Testing BitVecReu64 edge cases\n");

In BitVec.Init.c:262:

    }
    
    bool test_bitvec_clear_edge_cases(void) {
    WriteFmt("Testing BitVecClear edge cases\n");

In BitVec.Init.c:293:

    }
    
    bool test_bitvec_multiple_cycles(void) {
    WriteFmt("Testing BitVec multiple init/deinit cycles\n");

In BitVec.Init.c:315:

    
    // Deadend tests - verify expected failures occur gracefully
    bool test_bitvec_null_pointer_failures(void) {
    WriteFmt("Testing BitVec NULL pointer handling\n");

In BitVec.Init.c:328:

    }
    
    bool test_bitvec_invalid_operations(void) {
    WriteFmt("Testing BitVec invalid operations\n");

In BitVec.Init.c:343:

    }
    
    bool test_bitvec_set_operations_failures(void) {
    WriteFmt("Testing BitVec set operations on invalid indices\n");

In BitVec.Init.c:359:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Init tests\n\n");

In BitVec.Memory.c:10:

    
    // Function prototypes
    bool test_bitvec_shrink_to_fit(void);
    bool test_bitvec_set_capacity(void);
    bool test_bitvec_swap(void);

In BitVec.Memory.c:11:

    // Function prototypes
    bool test_bitvec_shrink_to_fit(void);
    bool test_bitvec_set_capacity(void);
    bool test_bitvec_swap(void);
    bool test_bitvec_clone(void);

In BitVec.Memory.c:12:

    bool test_bitvec_shrink_to_fit(void);
    bool test_bitvec_set_capacity(void);
    bool test_bitvec_swap(void);
    bool test_bitvec_clone(void);
    bool test_bitvec_shrink_to_fit_edge_cases(void);

In BitVec.Memory.c:13:

    bool test_bitvec_set_capacity(void);
    bool test_bitvec_swap(void);
    bool test_bitvec_clone(void);
    bool test_bitvec_shrink_to_fit_edge_cases(void);
    bool test_bitvec_set_capacity_edge_cases(void);

In BitVec.Memory.c:14:

    bool test_bitvec_swap(void);
    bool test_bitvec_clone(void);
    bool test_bitvec_shrink_to_fit_edge_cases(void);
    bool test_bitvec_set_capacity_edge_cases(void);
    bool test_bitvec_swap_edge_cases(void);

In BitVec.Memory.c:15:

    bool test_bitvec_clone(void);
    bool test_bitvec_shrink_to_fit_edge_cases(void);
    bool test_bitvec_set_capacity_edge_cases(void);
    bool test_bitvec_swap_edge_cases(void);
    bool test_bitvec_clone_edge_cases(void);

In BitVec.Memory.c:16:

    bool test_bitvec_shrink_to_fit_edge_cases(void);
    bool test_bitvec_set_capacity_edge_cases(void);
    bool test_bitvec_swap_edge_cases(void);
    bool test_bitvec_clone_edge_cases(void);
    bool test_bitvec_memory_stress_test(void);

In BitVec.Memory.c:17:

    bool test_bitvec_set_capacity_edge_cases(void);
    bool test_bitvec_swap_edge_cases(void);
    bool test_bitvec_clone_edge_cases(void);
    bool test_bitvec_memory_stress_test(void);
    bool test_bitvec_memory_null_failures(void);

In BitVec.Memory.c:18:

    bool test_bitvec_swap_edge_cases(void);
    bool test_bitvec_clone_edge_cases(void);
    bool test_bitvec_memory_stress_test(void);
    bool test_bitvec_memory_null_failures(void);
    bool test_bitvec_swap_null_failures(void);

In BitVec.Memory.c:19:

    bool test_bitvec_clone_edge_cases(void);
    bool test_bitvec_memory_stress_test(void);
    bool test_bitvec_memory_null_failures(void);
    bool test_bitvec_swap_null_failures(void);
    bool test_bitvec_clone_null_failures(void);

In BitVec.Memory.c:20:

    bool test_bitvec_memory_stress_test(void);
    bool test_bitvec_memory_null_failures(void);
    bool test_bitvec_swap_null_failures(void);
    bool test_bitvec_clone_null_failures(void);

In BitVec.Memory.c:21:

    bool test_bitvec_memory_null_failures(void);
    bool test_bitvec_swap_null_failures(void);
    bool test_bitvec_clone_null_failures(void);
    
    // Test BitVecShrinkToFit function

In BitVec.Memory.c:24:

    
    // Test BitVecShrinkToFit function
    bool test_bitvec_shrink_to_fit(void) {
    WriteFmt("Testing BitVecShrinkToFit\n");

In BitVec.Memory.c:61:

    
    // Test BitVecReserve function (replacing BitVecSetCapacity)
    bool test_bitvec_set_capacity(void) {
    WriteFmt("Testing BitVecReserve\n");

In BitVec.Memory.c:98:

    
    // Test BitVecSwap function
    bool test_bitvec_swap(void) {
    WriteFmt("Testing BitVecSwap\n");

In BitVec.Memory.c:142:

    
    // Test BitVecClone function
    bool test_bitvec_clone(void) {
    WriteFmt("Testing BitVecClone\n");

In BitVec.Memory.c:188:

    
    // Edge case tests
    bool test_bitvec_shrink_to_fit_edge_cases(void) {
    WriteFmt("Testing BitVecShrinkToFit edge cases\n");

In BitVec.Memory.c:219:

    }
    
    bool test_bitvec_set_capacity_edge_cases(void) {
    WriteFmt("Testing BitVecReserve edge cases\n");

In BitVec.Memory.c:256:

    }
    
    bool test_bitvec_swap_edge_cases(void) {
    WriteFmt("Testing BitVecSwap edge cases\n");

In BitVec.Memory.c:297:

    }
    
    bool test_bitvec_clone_edge_cases(void) {
    WriteFmt("Testing BitVecClone edge cases\n");

In BitVec.Memory.c:338:

    }
    
    bool test_bitvec_memory_stress_test(void) {
    WriteFmt("Testing BitVec memory stress test\n");

In BitVec.Memory.c:377:

    
    // Deadend tests
    bool test_bitvec_memory_null_failures(void) {
    WriteFmt("Testing BitVec memory NULL pointer handling\n");

In BitVec.Memory.c:386:

    }
    
    bool test_bitvec_swap_null_failures(void) {
    WriteFmt("Testing BitVec swap NULL handling\n");

In BitVec.Memory.c:398:

    }
    
    bool test_bitvec_clone_null_failures(void) {
    WriteFmt("Testing BitVec clone NULL handling\n");

In BitVec.Memory.c:408:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Memory tests\n\n");

In Vec.Init.c:26:

    }
    
    void TestItemDeinit(TestItem *item) {
    if (!item)
    return;

In Vec.Init.c:34:

    
    // Function prototypes
    bool test_vec_init_basic(void);
    bool test_vec_init_aligned(void);
    bool test_vec_init_with_deep_copy(void);

In Vec.Init.c:35:

    // Function prototypes
    bool test_vec_init_basic(void);
    bool test_vec_init_aligned(void);
    bool test_vec_init_with_deep_copy(void);
    bool test_vec_init_aligned_with_deep_copy(void);

In Vec.Init.c:36:

    bool test_vec_init_basic(void);
    bool test_vec_init_aligned(void);
    bool test_vec_init_with_deep_copy(void);
    bool test_vec_init_aligned_with_deep_copy(void);
    bool test_vec_init_stack(void);

In Vec.Init.c:37:

    bool test_vec_init_aligned(void);
    bool test_vec_init_with_deep_copy(void);
    bool test_vec_init_aligned_with_deep_copy(void);
    bool test_vec_init_stack(void);
    bool test_vec_init_clone(void);

In Vec.Init.c:38:

    bool test_vec_init_with_deep_copy(void);
    bool test_vec_init_aligned_with_deep_copy(void);
    bool test_vec_init_stack(void);
    bool test_vec_init_clone(void);

In Vec.Init.c:39:

    bool test_vec_init_aligned_with_deep_copy(void);
    bool test_vec_init_stack(void);
    bool test_vec_init_clone(void);
    
    // Test basic vector initialization

In Vec.Init.c:42:

    
    // Test basic vector initialization
    bool test_vec_init_basic(void) {
    WriteFmt("Testing VecInit\n");

In Vec.Init.c:72:

    
    // Test aligned vector initialization
    bool test_vec_init_aligned(void) {
    WriteFmt("Testing VecInitAligned\n");

In Vec.Init.c:102:

    
    // Test vector initialization with deep copy functions
    bool test_vec_init_with_deep_copy(void) {
    WriteFmt("Testing VecInitWithDeepCopy\n");

In Vec.Init.c:121:

    
    // Test vector initialization with alignment and deep copy functions
    bool test_vec_init_aligned_with_deep_copy(void) {
    WriteFmt("Testing VecInitAlignedWithDeepCopy\n");

In Vec.Init.c:140:

    
    // Test vector stack initialization
    bool test_vec_init_stack(void) {
    WriteFmt("Testing VecInitStack\n");

In Vec.Init.c:212:

    
    // Test vector clone initialization
    bool test_vec_init_clone(void) {
    WriteFmt("Testing vector cloning\n");

In Vec.Init.c:253:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Init tests\n\n");

In Vec.Ops.c:10:

    
    // Function prototypes
    bool test_vec_swap_items(void);
    bool test_vec_reverse(void);
    bool test_vec_sort(void);

In Vec.Ops.c:11:

    // Function prototypes
    bool test_vec_swap_items(void);
    bool test_vec_reverse(void);
    bool test_vec_sort(void);

In Vec.Ops.c:12:

    bool test_vec_swap_items(void);
    bool test_vec_reverse(void);
    bool test_vec_sort(void);
    
    // Comparison function for sorting integers in ascending order

In Vec.Ops.c:15:

    
    // Comparison function for sorting integers in ascending order
    int compare_ints_asc(const void *a, const void *b) {
    int val_a = *(const int *)a;
    int val_b = *(const int *)b;

In Vec.Ops.c:22:

    
    // Comparison function for sorting integers in descending order
    int compare_ints_desc(const void *a, const void *b) {
    int val_a = *(const int *)a;
    int val_b = *(const int *)b;

In Vec.Ops.c:29:

    
    // Test VecSwapItems function
    bool test_vec_swap_items(void) {
    WriteFmt("Testing VecSwapItems\n");

In Vec.Ops.c:64:

    
    // Test VecReverse function
    bool test_vec_reverse(void) {
    WriteFmt("Testing VecReverse\n");

In Vec.Ops.c:116:

    
    // Test VecSort function
    bool test_vec_sort(void) {
    WriteFmt("Testing VecSort\n");

In Vec.Ops.c:155:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Ops tests\n\n");

In Vec.Insert.c:11:

    
    // Function prototypes
    bool test_vec_push_back(void);
    bool test_vec_push_front(void);
    bool test_vec_insert(void);

In Vec.Insert.c:12:

    // Function prototypes
    bool test_vec_push_back(void);
    bool test_vec_push_front(void);
    bool test_vec_insert(void);
    bool test_vec_push_back_arr(void);

In Vec.Insert.c:13:

    bool test_vec_push_back(void);
    bool test_vec_push_front(void);
    bool test_vec_insert(void);
    bool test_vec_push_back_arr(void);
    bool test_vec_push_front_arr(void);

In Vec.Insert.c:14:

    bool test_vec_push_front(void);
    bool test_vec_insert(void);
    bool test_vec_push_back_arr(void);
    bool test_vec_push_front_arr(void);
    bool test_vec_push_arr(void);

In Vec.Insert.c:15:

    bool test_vec_insert(void);
    bool test_vec_push_back_arr(void);
    bool test_vec_push_front_arr(void);
    bool test_vec_push_arr(void);
    bool test_vec_insert_range(void);

In Vec.Insert.c:16:

    bool test_vec_push_back_arr(void);
    bool test_vec_push_front_arr(void);
    bool test_vec_push_arr(void);
    bool test_vec_insert_range(void);
    bool test_vec_merge(void);

In Vec.Insert.c:17:

    bool test_vec_push_front_arr(void);
    bool test_vec_push_arr(void);
    bool test_vec_insert_range(void);
    bool test_vec_merge(void);
    bool test_lvalue_rvalue_operations(void);

In Vec.Insert.c:18:

    bool test_vec_push_arr(void);
    bool test_vec_insert_range(void);
    bool test_vec_merge(void);
    bool test_lvalue_rvalue_operations(void);
    bool test_lvalue_memset_after_insertion(void);

In Vec.Insert.c:19:

    bool test_vec_insert_range(void);
    bool test_vec_merge(void);
    bool test_lvalue_rvalue_operations(void);
    bool test_lvalue_memset_after_insertion(void);

In Vec.Insert.c:20:

    bool test_vec_merge(void);
    bool test_lvalue_rvalue_operations(void);
    bool test_lvalue_memset_after_insertion(void);
    
    // Test VecPushBack function

In Vec.Insert.c:23:

    
    // Test VecPushBack function
    bool test_vec_push_back(void) {
    WriteFmt("Testing VecPushBack\n");

In Vec.Insert.c:51:

    
    // Test VecPushFront function
    bool test_vec_push_front(void) {
    WriteFmt("Testing VecPushFront\n");

In Vec.Insert.c:79:

    
    // Test VecInsert function
    bool test_vec_insert(void) {
    WriteFmt("Testing VecInsert\n");

In Vec.Insert.c:114:

    
    // Test VecPushBackArr function
    bool test_vec_push_back_arr(void) {
    WriteFmt("Testing VecPushBackArr\n");

In Vec.Insert.c:155:

    
    // Test VecPushFrontArr function
    bool test_vec_push_front_arr(void) {
    WriteFmt("Testing VecPushFrontArr\n");

In Vec.Insert.c:196:

    
    // Test VecInsertRange function for inserting at a specific index
    bool test_vec_push_arr(void) {
    WriteFmt("Testing VecInsertRange at specific index\n");

In Vec.Insert.c:229:

    
    // Test VecInsertRange function for inserting from another vector
    bool test_vec_insert_range(void) {
    WriteFmt("Testing VecInsertRange from another vector\n");

In Vec.Insert.c:267:

    
    // Test VecMerge function
    bool test_vec_merge(void) {
    WriteFmt("Testing VecMerge\n");

In Vec.Insert.c:308:

    
    // Test L-value and R-value operations
    bool test_lvalue_rvalue_operations(void) {
    WriteFmt("Testing L-value and R-value operations\n");

In Vec.Insert.c:391:

    
    // Test that L-value insertions properly memset values to 0 after insertion
    bool test_lvalue_memset_after_insertion(void) {
    WriteFmt("Testing L-value memset after insertion\n");

In Vec.Insert.c:467:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting Vec.Insert tests\n\n");

In BitVec.Access.c:10:

    
    // Function prototypes
    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);

In BitVec.Access.c:11:

    // Function prototypes
    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);

In BitVec.Access.c:12:

    bool test_bitvec_get(void);
    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);

In BitVec.Access.c:13:

    bool test_bitvec_set(void);
    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);

In BitVec.Access.c:14:

    bool test_bitvec_flip(void);
    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);

In BitVec.Access.c:15:

    bool test_bitvec_length_capacity(void);
    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);

In BitVec.Access.c:16:

    bool test_bitvec_count_operations(void);
    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);

In BitVec.Access.c:17:

    bool test_bitvec_get_edge_cases(void);
    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);

In BitVec.Access.c:18:

    bool test_bitvec_set_edge_cases(void);
    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);

In BitVec.Access.c:19:

    bool test_bitvec_flip_edge_cases(void);
    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);

In BitVec.Access.c:20:

    bool test_bitvec_count_edge_cases(void);
    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);

In BitVec.Access.c:21:

    bool test_bitvec_access_multiple_operations(void);
    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);

In BitVec.Access.c:22:

    bool test_bitvec_access_large_patterns(void);
    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);

In BitVec.Access.c:23:

    bool test_bitvec_macro_functions(void);
    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);

In BitVec.Access.c:24:

    bool test_bitvec_access_stress_test(void);
    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);

In BitVec.Access.c:25:

    bool test_bitvec_bit_patterns_comprehensive(void);
    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);

In BitVec.Access.c:26:

    bool test_bitvec_find_functions(void);
    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);

In BitVec.Access.c:27:

    bool test_bitvec_predicate_functions(void);
    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);

In BitVec.Access.c:28:

    bool test_bitvec_longest_run(void);
    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);
    bool test_bitvec_find_deadend_tests(void);

In BitVec.Access.c:29:

    bool test_bitvec_find_edge_cases(void);
    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);
    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);

In BitVec.Access.c:30:

    bool test_bitvec_predicate_edge_cases(void);
    bool test_bitvec_longest_run_edge_cases(void);
    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);

In BitVec.Access.c:31:

    bool test_bitvec_longest_run_edge_cases(void);
    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);

In BitVec.Access.c:32:

    bool test_bitvec_find_deadend_tests(void);
    bool test_bitvec_predicate_deadend_tests(void);
    bool test_bitvec_longest_run_deadend_tests(void);
    
    // Test BitVecGet function

In BitVec.Access.c:35:

    
    // Test BitVecGet function
    bool test_bitvec_get(void) {
    WriteFmt("Testing BitVecGet\n");

In BitVec.Access.c:59:

    
    // Test BitVecSet function
    bool test_bitvec_set(void) {
    WriteFmt("Testing BitVecSet\n");

In BitVec.Access.c:89:

    
    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
    WriteFmt("Testing BitVecFlip\n");

In BitVec.Access.c:126:

    
    // Test length and capacity operations
    bool test_bitvec_length_capacity(void) {
    WriteFmt("Testing BitVec length and capacity operations\n");

In BitVec.Access.c:157:

    
    // Test count operations
    bool test_bitvec_count_operations(void) {
    WriteFmt("Testing BitVec count operations\n");

In BitVec.Access.c:191:

    
    // Edge case tests
    bool test_bitvec_get_edge_cases(void) {
    WriteFmt("Testing BitVecGet edge cases\n");

In BitVec.Access.c:214:

    }
    
    bool test_bitvec_set_edge_cases(void) {
    WriteFmt("Testing BitVecSet edge cases\n");

In BitVec.Access.c:234:

    }
    
    bool test_bitvec_flip_edge_cases(void) {
    WriteFmt("Testing BitVecFlip edge cases\n");

In BitVec.Access.c:252:

    }
    
    bool test_bitvec_count_edge_cases(void) {
    WriteFmt("Testing BitVec count edge cases\n");

In BitVec.Access.c:284:

    }
    
    bool test_bitvec_access_multiple_operations(void) {
    WriteFmt("Testing BitVec multiple access operations\n");

In BitVec.Access.c:310:

    
    // NEW: Test large bit patterns and complex access patterns
    bool test_bitvec_access_large_patterns(void) {
    WriteFmt("Testing BitVec large pattern access\n");

In BitVec.Access.c:347:

    
    // NEW: Test macro functions comprehensively
    bool test_bitvec_macro_functions(void) {
    WriteFmt("Testing BitVec macro functions\n");

In BitVec.Access.c:383:

    
    // NEW: Stress test for access operations
    bool test_bitvec_access_stress_test(void) {
    WriteFmt("Testing BitVec access stress test\n");

In BitVec.Access.c:423:

    
    // NEW: Comprehensive bit pattern testing
    bool test_bitvec_bit_patterns_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive bit patterns\n");

In BitVec.Access.c:487:

    
    // Deadend tests
    bool test_bitvec_access_null_failures(void) {
    WriteFmt("Testing BitVec access NULL pointer handling\n");

In BitVec.Access.c:496:

    }
    
    bool test_bitvec_set_null_failures(void) {
    WriteFmt("Testing BitVec set NULL pointer handling\n");

In BitVec.Access.c:505:

    }
    
    bool test_bitvec_flip_null_failures(void) {
    WriteFmt("Testing BitVec flip NULL pointer handling\n");

In BitVec.Access.c:514:

    }
    
    bool test_bitvec_get_bounds_failures(void) {
    WriteFmt("Testing BitVec get bounds checking\n");

In BitVec.Access.c:526:

    }
    
    bool test_bitvec_set_bounds_failures(void) {
    WriteFmt("Testing BitVec set bounds checking\n");

In BitVec.Access.c:538:

    }
    
    bool test_bitvec_flip_bounds_failures(void) {
    WriteFmt("Testing BitVec flip bounds checking\n");

In BitVec.Access.c:551:

    
    // NEW: More specific bounds checking deadend tests
    bool test_bitvec_get_large_index_failures(void) {
    WriteFmt("Testing BitVec get with large out-of-bounds index\n");

In BitVec.Access.c:566:

    }
    
    bool test_bitvec_set_large_index_failures(void) {
    WriteFmt("Testing BitVec set with large out-of-bounds index\n");

In BitVec.Access.c:580:

    }
    
    bool test_bitvec_flip_edge_index_failures(void) {
    WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");

In BitVec.Access.c:595:

    }
    
    bool test_bitvec_count_null_failures(void) {
    WriteFmt("Testing BitVec count operations with NULL pointer\n");

In BitVec.Access.c:604:

    }
    
    bool test_bitvec_get_max_index_failures(void) {
    WriteFmt("Testing BitVec get with maximum index value\n");

In BitVec.Access.c:618:

    
    // Test BitVecFind and BitVecFindLast functions
    bool test_bitvec_find_functions(void) {
    WriteFmt("Testing BitVecFind and BitVecFindLast functions\n");

In BitVec.Access.c:662:

    
    // Test BitVecAll, BitVecAny, BitVecNone functions
    bool test_bitvec_predicate_functions(void) {
    WriteFmt("Testing BitVecAll, BitVecAny, BitVecNone functions\n");

In BitVec.Access.c:711:

    
    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
    WriteFmt("Testing BitVecLongestRun function\n");

In BitVec.Access.c:760:

    
    // Edge case tests for Find functions
    bool test_bitvec_find_edge_cases(void) {
    WriteFmt("Testing BitVecFind edge cases\n");

In BitVec.Access.c:792:

    
    // Edge case tests for predicate functions
    bool test_bitvec_predicate_edge_cases(void) {
    WriteFmt("Testing BitVec predicate edge cases\n");

In BitVec.Access.c:832:

    
    // Edge case tests for LongestRun function
    bool test_bitvec_longest_run_edge_cases(void) {
    WriteFmt("Testing BitVecLongestRun edge cases\n");

In BitVec.Access.c:865:

    
    // Deadend tests - testing NULL pointers and invalid conditions that should cause fatal errors
    bool test_bitvec_find_deadend_tests(void) {
    WriteFmt("Testing BitVecFind deadend scenarios\n");

In BitVec.Access.c:874:

    }
    
    bool test_bitvec_predicate_deadend_tests(void) {
    WriteFmt("Testing BitVec predicate deadend scenarios\n");

In BitVec.Access.c:883:

    }
    
    bool test_bitvec_longest_run_deadend_tests(void) {
    WriteFmt("Testing BitVecLongestRun deadend scenarios\n");

In BitVec.Access.c:893:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Access tests\n\n");

In BitVec.Convert.c:13:

    
    // Function prototypes
    bool test_bitvec_to_string(void);
    bool test_bitvec_from_string(void);
    bool test_bitvec_to_bytes(void);

In BitVec.Convert.c:14:

    // Function prototypes
    bool test_bitvec_to_string(void);
    bool test_bitvec_from_string(void);
    bool test_bitvec_to_bytes(void);
    bool test_bitvec_from_bytes(void);

In BitVec.Convert.c:15:

    bool test_bitvec_to_string(void);
    bool test_bitvec_from_string(void);
    bool test_bitvec_to_bytes(void);
    bool test_bitvec_from_bytes(void);
    bool test_bitvec_to_integer(void);

In BitVec.Convert.c:16:

    bool test_bitvec_from_string(void);
    bool test_bitvec_to_bytes(void);
    bool test_bitvec_from_bytes(void);
    bool test_bitvec_to_integer(void);
    bool test_bitvec_from_integer(void);

In BitVec.Convert.c:17:

    bool test_bitvec_to_bytes(void);
    bool test_bitvec_from_bytes(void);
    bool test_bitvec_to_integer(void);
    bool test_bitvec_from_integer(void);
    bool test_bitvec_convert_edge_cases(void);

In BitVec.Convert.c:18:

    bool test_bitvec_from_bytes(void);
    bool test_bitvec_to_integer(void);
    bool test_bitvec_from_integer(void);
    bool test_bitvec_convert_edge_cases(void);
    bool test_bitvec_from_string_edge_cases(void);

In BitVec.Convert.c:19:

    bool test_bitvec_to_integer(void);
    bool test_bitvec_from_integer(void);
    bool test_bitvec_convert_edge_cases(void);
    bool test_bitvec_from_string_edge_cases(void);
    bool test_bitvec_bytes_conversion_edge_cases(void);

In BitVec.Convert.c:20:

    bool test_bitvec_from_integer(void);
    bool test_bitvec_convert_edge_cases(void);
    bool test_bitvec_from_string_edge_cases(void);
    bool test_bitvec_bytes_conversion_edge_cases(void);
    bool test_bitvec_integer_conversion_edge_cases(void);

In BitVec.Convert.c:21:

    bool test_bitvec_convert_edge_cases(void);
    bool test_bitvec_from_string_edge_cases(void);
    bool test_bitvec_bytes_conversion_edge_cases(void);
    bool test_bitvec_integer_conversion_edge_cases(void);
    bool test_bitvec_round_trip_conversions(void);

In BitVec.Convert.c:22:

    bool test_bitvec_from_string_edge_cases(void);
    bool test_bitvec_bytes_conversion_edge_cases(void);
    bool test_bitvec_integer_conversion_edge_cases(void);
    bool test_bitvec_round_trip_conversions(void);
    bool test_bitvec_conversion_bounds_checking(void);

In BitVec.Convert.c:23:

    bool test_bitvec_bytes_conversion_edge_cases(void);
    bool test_bitvec_integer_conversion_edge_cases(void);
    bool test_bitvec_round_trip_conversions(void);
    bool test_bitvec_conversion_bounds_checking(void);
    bool test_bitvec_conversion_comprehensive(void);

In BitVec.Convert.c:24:

    bool test_bitvec_integer_conversion_edge_cases(void);
    bool test_bitvec_round_trip_conversions(void);
    bool test_bitvec_conversion_bounds_checking(void);
    bool test_bitvec_conversion_comprehensive(void);
    bool test_bitvec_large_scale_conversions(void);

In BitVec.Convert.c:25:

    bool test_bitvec_round_trip_conversions(void);
    bool test_bitvec_conversion_bounds_checking(void);
    bool test_bitvec_conversion_comprehensive(void);
    bool test_bitvec_large_scale_conversions(void);
    bool test_bitvec_convert_null_failures(void);

In BitVec.Convert.c:26:

    bool test_bitvec_conversion_bounds_checking(void);
    bool test_bitvec_conversion_comprehensive(void);
    bool test_bitvec_large_scale_conversions(void);
    bool test_bitvec_convert_null_failures(void);
    bool test_bitvec_from_string_null_failures(void);

In BitVec.Convert.c:27:

    bool test_bitvec_conversion_comprehensive(void);
    bool test_bitvec_large_scale_conversions(void);
    bool test_bitvec_convert_null_failures(void);
    bool test_bitvec_from_string_null_failures(void);
    bool test_bitvec_bytes_null_failures(void);

In BitVec.Convert.c:28:

    bool test_bitvec_large_scale_conversions(void);
    bool test_bitvec_convert_null_failures(void);
    bool test_bitvec_from_string_null_failures(void);
    bool test_bitvec_bytes_null_failures(void);
    bool test_bitvec_bytes_bounds_failures(void);

In BitVec.Convert.c:29:

    bool test_bitvec_convert_null_failures(void);
    bool test_bitvec_from_string_null_failures(void);
    bool test_bitvec_bytes_null_failures(void);
    bool test_bitvec_bytes_bounds_failures(void);
    bool test_bitvec_integer_bounds_failures(void);

In BitVec.Convert.c:30:

    bool test_bitvec_from_string_null_failures(void);
    bool test_bitvec_bytes_null_failures(void);
    bool test_bitvec_bytes_bounds_failures(void);
    bool test_bitvec_integer_bounds_failures(void);

In BitVec.Convert.c:31:

    bool test_bitvec_bytes_null_failures(void);
    bool test_bitvec_bytes_bounds_failures(void);
    bool test_bitvec_integer_bounds_failures(void);
    
    // Test BitVecToStr function

In BitVec.Convert.c:34:

    
    // Test BitVecToStr function
    bool test_bitvec_to_string(void) {
    WriteFmt("Testing BitVecToStr\n");

In BitVec.Convert.c:63:

    
    // Test BitVecFromStr function
    bool test_bitvec_from_string(void) {
    WriteFmt("Testing BitVecFromStr\n");

In BitVec.Convert.c:89:

    
    // Test BitVecToBytes function
    bool test_bitvec_to_bytes(void) {
    WriteFmt("Testing BitVecToBytes\n");

In BitVec.Convert.c:121:

    
    // Test BitVecFromBytes function
    bool test_bitvec_from_bytes(void) {
    WriteFmt("Testing BitVecFromBytes\n");

In BitVec.Convert.c:154:

    
    // Test BitVecToInteger function
    bool test_bitvec_to_integer(void) {
    WriteFmt("Testing BitVecToInteger\n");

In BitVec.Convert.c:190:

    
    // Test BitVecFromInteger function
    bool test_bitvec_from_integer(void) {
    WriteFmt("Testing BitVecFromInteger\n");

In BitVec.Convert.c:237:

    
    // Edge case tests
    bool test_bitvec_convert_edge_cases(void) {
    WriteFmt("Testing BitVec convert edge cases\n");

In BitVec.Convert.c:268:

    }
    
    bool test_bitvec_from_string_edge_cases(void) {
    WriteFmt("Testing BitVecFromStr edge cases\n");

In BitVec.Convert.c:300:

    }
    
    bool test_bitvec_bytes_conversion_edge_cases(void) {
    WriteFmt("Testing BitVec bytes conversion edge cases\n");

In BitVec.Convert.c:327:

    }
    
    bool test_bitvec_integer_conversion_edge_cases(void) {
    WriteFmt("Testing BitVec integer conversion edge cases\n");

In BitVec.Convert.c:352:

    
    // Round-trip conversion tests
    bool test_bitvec_round_trip_conversions(void) {
    WriteFmt("Testing BitVec round-trip conversions\n");

In BitVec.Convert.c:411:

    
    // Bounds checking tests
    bool test_bitvec_conversion_bounds_checking(void) {
    WriteFmt("Testing BitVec conversion bounds checking\n");

In BitVec.Convert.c:456:

    
    // Comprehensive conversion validation
    bool test_bitvec_conversion_comprehensive(void) {
    WriteFmt("Testing BitVec comprehensive conversion validation\n");

In BitVec.Convert.c:523:

    
    // Large-scale conversion tests
    bool test_bitvec_large_scale_conversions(void) {
    WriteFmt("Testing BitVec large-scale conversions\n");

In BitVec.Convert.c:606:

    
    // Enhanced deadend tests
    bool test_bitvec_bytes_bounds_failures(void) {
    WriteFmt("Testing BitVec bytes bounds failures\n");

In BitVec.Convert.c:615:

    u8  small_buffer[1];
    u64 written = BitVecToBytes(&bv, small_buffer, 0); // 0 buffer size
    (void)written;                                     // Suppress unused variable warning
    
    // Should handle gracefully

In BitVec.Convert.c:629:

    }
    
    bool test_bitvec_integer_bounds_failures(void) {
    WriteFmt("Testing BitVec integer bounds failures\n");

In BitVec.Convert.c:634:

    // Test BitVecToInteger with NULL pointer - should abort
    u64 value = BitVecToInteger(NULL);
    (void)value; // Suppress unused variable warning
    
    return false;

In BitVec.Convert.c:640:

    
    // Deadend tests
    bool test_bitvec_convert_null_failures(void) {
    WriteFmt("Testing BitVec convert NULL pointer handling\n");

In BitVec.Convert.c:649:

    }
    
    bool test_bitvec_from_string_null_failures(void) {
    WriteFmt("Testing BitVec from string NULL handling\n");

In BitVec.Convert.c:658:

    }
    
    bool test_bitvec_bytes_null_failures(void) {
    WriteFmt("Testing BitVec bytes NULL handling\n");

In BitVec.Convert.c:668:

    
    // Main function that runs all tests
    int main(void) {
    WriteFmt("[INFO] Starting BitVec.Convert tests\n\n");

In RoundTrip.c:36:

    
    // Cleanup functions
    void TestPersonDeinit(TestPerson *person) {
    StrDeinit(&person->name);
    }

In RoundTrip.c:40:

    }
    
    void TestConfigDeinit(TestConfig *config) {
    StrDeinit(&config->log_level);
    VecDeinit(&config->features);

In RoundTrip.c:45:

    }
    
    void ComplexDataDeinit(ComplexData *data) {
    TestPersonDeinit(&data->user);
    TestConfigDeinit(&data->config);

In RoundTrip.c:53:

    
    // Function prototypes
    bool test_simple_roundtrip(void);
    bool test_numeric_roundtrip(void);
    bool test_boolean_roundtrip(void);

In RoundTrip.c:54:

    // Function prototypes
    bool test_simple_roundtrip(void);
    bool test_numeric_roundtrip(void);
    bool test_boolean_roundtrip(void);
    bool test_string_roundtrip(void);

In RoundTrip.c:55:

    bool test_simple_roundtrip(void);
    bool test_numeric_roundtrip(void);
    bool test_boolean_roundtrip(void);
    bool test_string_roundtrip(void);
    bool test_array_roundtrip(void);

In RoundTrip.c:56:

    bool test_numeric_roundtrip(void);
    bool test_boolean_roundtrip(void);
    bool test_string_roundtrip(void);
    bool test_array_roundtrip(void);
    bool test_nested_object_roundtrip(void);

In RoundTrip.c:57:

    bool test_boolean_roundtrip(void);
    bool test_string_roundtrip(void);
    bool test_array_roundtrip(void);
    bool test_nested_object_roundtrip(void);
    bool test_complex_data_roundtrip(void);

In RoundTrip.c:58:

    bool test_string_roundtrip(void);
    bool test_array_roundtrip(void);
    bool test_nested_object_roundtrip(void);
    bool test_complex_data_roundtrip(void);
    bool test_empty_containers_roundtrip(void);

In RoundTrip.c:59:

    bool test_array_roundtrip(void);
    bool test_nested_object_roundtrip(void);
    bool test_complex_data_roundtrip(void);
    bool test_empty_containers_roundtrip(void);
    bool test_edge_cases_roundtrip(void);

In RoundTrip.c:60:

    bool test_nested_object_roundtrip(void);
    bool test_complex_data_roundtrip(void);
    bool test_empty_containers_roundtrip(void);
    bool test_edge_cases_roundtrip(void);

In RoundTrip.c:61:

    bool test_complex_data_roundtrip(void);
    bool test_empty_containers_roundtrip(void);
    bool test_edge_cases_roundtrip(void);
    
    // Helper function to compare persons

In RoundTrip.c:85:

    
    // Test 1: Simple value round-trip
    bool test_simple_roundtrip(void) {
    WriteFmtLn("Testing simple value round-trip");

In RoundTrip.c:155:

    
    // Test 2: Numeric precision round-trip
    bool test_numeric_roundtrip(void) {
    WriteFmtLn("Testing numeric precision round-trip");

In RoundTrip.c:227:

    
    // Test 3: Boolean round-trip
    bool test_boolean_roundtrip(void) {
    WriteFmtLn("Testing boolean round-trip");

In RoundTrip.c:279:

    
    // Test 4: String round-trip
    bool test_string_roundtrip(void) {
    WriteFmtLn("Testing string round-trip");

In RoundTrip.c:346:

    
    // Test 5: Array round-trip
    bool test_array_roundtrip(void) {
    WriteFmtLn("Testing array round-trip");

In RoundTrip.c:449:

    
    // Test 6: Nested object round-trip
    bool test_nested_object_roundtrip(void) {
    WriteFmtLn("Testing nested object round-trip");

In RoundTrip.c:499:

    
    // Test 7: Complex data round-trip
    bool test_complex_data_roundtrip(void) {
    WriteFmtLn("Testing complex data round-trip");

In RoundTrip.c:642:

    
    // Test 8: Empty containers round-trip
    bool test_empty_containers_roundtrip(void) {
    WriteFmtLn("Testing empty containers round-trip");

In RoundTrip.c:717:

    
    // Test 9: Edge cases round-trip
    bool test_edge_cases_roundtrip(void) {
    WriteFmtLn("Testing edge cases round-trip");

In Read.Simple.c:34:

    
    // Cleanup functions
    void PersonDeinit(Person *person) {
    StrDeinit(&person->name);
    }

In Read.Simple.c:38:

    }
    
    void ConfigDeinit(Config *config) {
    StrDeinit(&config->log_level);
    }

In Read.Simple.c:42:

    }
    
    void SimpleProductDeinit(SimpleProduct *product) {
    StrDeinit(&product->name);
    VecDeinit(&product->tags);

In Read.Simple.c:48:

    
    // Function prototypes
    bool test_simple_string_parsing(void);
    bool test_simple_numbers(void);
    bool test_simple_boolean(void);

In Read.Simple.c:49:

    // Function prototypes
    bool test_simple_string_parsing(void);
    bool test_simple_numbers(void);
    bool test_simple_boolean(void);
    bool test_simple_person_object(void);

In Read.Simple.c:50:

    bool test_simple_string_parsing(void);
    bool test_simple_numbers(void);
    bool test_simple_boolean(void);
    bool test_simple_person_object(void);
    bool test_simple_config_object(void);

In Read.Simple.c:51:

    bool test_simple_numbers(void);
    bool test_simple_boolean(void);
    bool test_simple_person_object(void);
    bool test_simple_config_object(void);
    bool test_simple_array_of_strings(void);

In Read.Simple.c:52:

    bool test_simple_boolean(void);
    bool test_simple_person_object(void);
    bool test_simple_config_object(void);
    bool test_simple_array_of_strings(void);
    bool test_simple_nested_object(void);

In Read.Simple.c:53:

    bool test_simple_person_object(void);
    bool test_simple_config_object(void);
    bool test_simple_array_of_strings(void);
    bool test_simple_nested_object(void);
    bool test_simple_product_with_tags(void);

In Read.Simple.c:54:

    bool test_simple_config_object(void);
    bool test_simple_array_of_strings(void);
    bool test_simple_nested_object(void);
    bool test_simple_product_with_tags(void);

In Read.Simple.c:55:

    bool test_simple_array_of_strings(void);
    bool test_simple_nested_object(void);
    bool test_simple_product_with_tags(void);
    
    // Test 1: Simple string parsing

In Read.Simple.c:58:

    
    // Test 1: Simple string parsing
    bool test_simple_string_parsing(void) {
    WriteFmt("Testing simple string parsing\n");

In Read.Simple.c:98:

    
    // Test 2: Simple number parsing
    bool test_simple_numbers(void) {
    WriteFmt("Testing simple number parsing\n");

In Read.Simple.c:135:

    
    // Test 3: Simple boolean parsing
    bool test_simple_boolean(void) {
    WriteFmt("Testing simple boolean parsing\n");

In Read.Simple.c:165:

    
    // Test 4: Simple person object
    bool test_simple_person_object(void) {
    WriteFmt("Testing simple person object\n");

In Read.Simple.c:219:

    
    // Test 5: Simple config object
    bool test_simple_config_object(void) {
    WriteFmt("Testing simple config object\n");

In Read.Simple.c:260:

    
    // Test 6: Simple array of strings
    bool test_simple_array_of_strings(void) {
    WriteFmt("Testing simple array of strings\n");

In Read.Simple.c:321:

    
    // Test 7: Simple nested object (1 level)
    bool test_simple_nested_object(void) {
    WriteFmt("Testing simple nested object\n");

In Read.Simple.c:378:

    
    // Test 8: Simple product with tags array
    bool test_simple_product_with_tags(void) {
    WriteFmt("Testing simple product with tags array\n");

In Write.Simple.c:34:

    
    // Cleanup functions
    void PersonDeinit(Person *person) {
    StrDeinit(&person->name);
    }

In Write.Simple.c:38:

    }
    
    void ConfigDeinit(Config *config) {
    StrDeinit(&config->log_level);
    }

In Write.Simple.c:42:

    }
    
    void SimpleProductDeinit(SimpleProduct *product) {
    StrDeinit(&product->name);
    VecDeinit(&product->tags);

In Write.Simple.c:48:

    
    // Function prototypes
    bool test_simple_string_writing(void);
    bool test_simple_numbers_writing(void);
    bool test_simple_boolean_writing(void);

In Write.Simple.c:49:

    // Function prototypes
    bool test_simple_string_writing(void);
    bool test_simple_numbers_writing(void);
    bool test_simple_boolean_writing(void);
    bool test_simple_person_object_writing(void);

In Write.Simple.c:50:

    bool test_simple_string_writing(void);
    bool test_simple_numbers_writing(void);
    bool test_simple_boolean_writing(void);
    bool test_simple_person_object_writing(void);
    bool test_simple_config_object_writing(void);

In Write.Simple.c:51:

    bool test_simple_numbers_writing(void);
    bool test_simple_boolean_writing(void);
    bool test_simple_person_object_writing(void);
    bool test_simple_config_object_writing(void);
    bool test_simple_array_of_strings_writing(void);

In Write.Simple.c:52:

    bool test_simple_boolean_writing(void);
    bool test_simple_person_object_writing(void);
    bool test_simple_config_object_writing(void);
    bool test_simple_array_of_strings_writing(void);
    bool test_simple_nested_object_writing(void);

In Write.Simple.c:53:

    bool test_simple_person_object_writing(void);
    bool test_simple_config_object_writing(void);
    bool test_simple_array_of_strings_writing(void);
    bool test_simple_nested_object_writing(void);
    bool test_simple_product_with_tags_writing(void);

In Write.Simple.c:54:

    bool test_simple_config_object_writing(void);
    bool test_simple_array_of_strings_writing(void);
    bool test_simple_nested_object_writing(void);
    bool test_simple_product_with_tags_writing(void);

In Write.Simple.c:55:

    bool test_simple_array_of_strings_writing(void);
    bool test_simple_nested_object_writing(void);
    bool test_simple_product_with_tags_writing(void);
    
    // Helper function to compare expected JSON strings (removes spaces for comparison)

In Write.Simple.c:102:

    
    // Test 1: Simple string writing
    bool test_simple_string_writing(void) {
    WriteFmt("Testing simple string writing\n");

In Write.Simple.c:128:

    
    // Test 2: Simple number writing
    bool test_simple_numbers_writing(void) {
    WriteFmt("Testing simple number writing\n");

In Write.Simple.c:154:

    
    // Test 3: Simple boolean writing
    bool test_simple_boolean_writing(void) {
    WriteFmt("Testing simple boolean writing\n");

In Write.Simple.c:178:

    
    // Test 4: Simple person object writing
    bool test_simple_person_object_writing(void) {
    WriteFmt("Testing simple person object writing\n");

In Write.Simple.c:205:

    
    // Test 5: Simple config object writing
    bool test_simple_config_object_writing(void) {
    WriteFmt("Testing simple config object writing\n");

In Write.Simple.c:230:

    
    // Test 6: Simple array of strings writing
    bool test_simple_array_of_strings_writing(void) {
    WriteFmt("Testing simple array of strings writing\n");

In Write.Simple.c:260:

    
    // Test 7: Simple nested object writing
    bool test_simple_nested_object_writing(void) {
    WriteFmt("Testing simple nested object writing\n");

In Write.Simple.c:297:

    
    // Test 8: Simple product with tags array writing
    bool test_simple_product_with_tags_writing(void) {
    WriteFmt("Testing simple product with tags array writing\n");

In Read.Nested.c:33:

    } ApiResponse;
    
    void AnnSymbolDeinit(AnnSymbol *sym) {
    StrDeinit(&sym->analysis_name);
    StrDeinit(&sym->function_name);

In Read.Nested.c:71:

    typedef Vec(SearchResult) SearchResults;
    
    void FunctionInfoDeinit(FunctionInfo *info) {
    StrDeinit(&info->name);
    }

In Read.Nested.c:75:

    }
    
    void ModelInfoDeinit(ModelInfo *info) {
    StrDeinit(&info->name);
    }

In Read.Nested.c:79:

    }
    
    void SearchResultDeinit(SearchResult *result) {
    StrDeinit(&result->binary_name);
    StrDeinit(&result->sha256);

In Read.Nested.c:92:

    
    // Function prototypes
    bool test_basic_iterator_functionality(void);
    bool test_simple_json_object(void);
    bool test_two_level_nesting(void);

In Read.Nested.c:93:

    // Function prototypes
    bool test_basic_iterator_functionality(void);
    bool test_simple_json_object(void);
    bool test_two_level_nesting(void);
    bool test_three_level_nesting(void);

In Read.Nested.c:94:

    bool test_basic_iterator_functionality(void);
    bool test_simple_json_object(void);
    bool test_two_level_nesting(void);
    bool test_three_level_nesting(void);
    bool test_dynamic_key_parsing(void);

In Read.Nested.c:95:

    bool test_simple_json_object(void);
    bool test_two_level_nesting(void);
    bool test_three_level_nesting(void);
    bool test_dynamic_key_parsing(void);
    bool test_complex_api_response(void);

In Read.Nested.c:96:

    bool test_two_level_nesting(void);
    bool test_three_level_nesting(void);
    bool test_dynamic_key_parsing(void);
    bool test_complex_api_response(void);
    bool test_function_info_parsing(void);

In Read.Nested.c:97:

    bool test_three_level_nesting(void);
    bool test_dynamic_key_parsing(void);
    bool test_complex_api_response(void);
    bool test_function_info_parsing(void);
    bool test_model_info_parsing(void);

In Read.Nested.c:98:

    bool test_dynamic_key_parsing(void);
    bool test_complex_api_response(void);
    bool test_function_info_parsing(void);
    bool test_model_info_parsing(void);
    bool test_search_results_with_tags(void);

In Read.Nested.c:99:

    bool test_complex_api_response(void);
    bool test_function_info_parsing(void);
    bool test_model_info_parsing(void);
    bool test_search_results_with_tags(void);
    bool test_conditional_parsing(void);

In Read.Nested.c:100:

    bool test_function_info_parsing(void);
    bool test_model_info_parsing(void);
    bool test_search_results_with_tags(void);
    bool test_conditional_parsing(void);
    bool test_status_response_pattern(void);

In Read.Nested.c:101:

    bool test_model_info_parsing(void);
    bool test_search_results_with_tags(void);
    bool test_conditional_parsing(void);
    bool test_status_response_pattern(void);

In Read.Nested.c:102:

    bool test_search_results_with_tags(void);
    bool test_conditional_parsing(void);
    bool test_status_response_pattern(void);
    
    // Test basic iterator functionality

In Read.Nested.c:105:

    
    // Test basic iterator functionality
    bool test_basic_iterator_functionality(void) {
    WriteFmt("Testing basic iterator functionality\n");

In Read.Nested.c:128:

    
    // Test simple JSON object (1 level)
    bool test_simple_json_object(void) {
    WriteFmt("Testing simple JSON object (1 level)\n");

In Read.Nested.c:179:

    
    // Test two-level nesting
    bool test_two_level_nesting(void) {
    WriteFmt("Testing two-level nesting\n");

In Read.Nested.c:248:

    
    // Test three-level nesting
    bool test_three_level_nesting(void) {
    WriteFmt("Testing three-level nesting\n");

In Read.Nested.c:327:

    
    // Test dynamic key parsing (like your example) - Fixed initialization
    bool test_dynamic_key_parsing(void) {
    WriteFmt("Testing dynamic key parsing\n");

In Read.Nested.c:425:

    
    // Test complex API response similar to your example - Fixed initialization
    bool test_complex_api_response(void) {
    WriteFmt("Testing complex API response structure\n");

In Read.Nested.c:573:

    
    // Test function info parsing
    bool test_function_info_parsing(void) {
    WriteFmt("Testing function info parsing\n");

In Read.Nested.c:620:

    
    // Test model info parsing
    bool test_model_info_parsing(void) {
    WriteFmt("Testing model info parsing\n");

In Read.Nested.c:655:

    
    // Test search results with tags - Fixed implementation
    bool test_search_results_with_tags(void) {
    WriteFmt("Testing search results with tags\n");

In Read.Nested.c:741:

    
    // Test conditional parsing
    bool test_conditional_parsing(void) {
    WriteFmt("Testing conditional parsing\n");

In Read.Nested.c:910:

    
    // Test status response pattern
    bool test_status_response_pattern(void) {
    WriteFmt("Testing status response pattern\n");

In Read.EdgeCases.c:22:

    } EdgeCaseData;
    
    void EdgeCaseDataDeinit(EdgeCaseData *data) {
    StrDeinit(&data->empty_string);
    VecDeinit(&data->empty_array);

In Read.EdgeCases.c:29:

    
    // Function prototypes
    bool test_empty_object_reading(void);
    bool test_empty_array_reading(void);
    bool test_empty_string_reading(void);

In Read.EdgeCases.c:30:

    // Function prototypes
    bool test_empty_object_reading(void);
    bool test_empty_array_reading(void);
    bool test_empty_string_reading(void);
    bool test_negative_numbers_reading(void);

In Read.EdgeCases.c:31:

    bool test_empty_object_reading(void);
    bool test_empty_array_reading(void);
    bool test_empty_string_reading(void);
    bool test_negative_numbers_reading(void);
    bool test_large_numbers_reading(void);

In Read.EdgeCases.c:32:

    bool test_empty_array_reading(void);
    bool test_empty_string_reading(void);
    bool test_negative_numbers_reading(void);
    bool test_large_numbers_reading(void);
    bool test_zero_values_reading(void);

In Read.EdgeCases.c:33:

    bool test_empty_string_reading(void);
    bool test_negative_numbers_reading(void);
    bool test_large_numbers_reading(void);
    bool test_zero_values_reading(void);
    bool test_special_characters_in_strings(void);

In Read.EdgeCases.c:34:

    bool test_negative_numbers_reading(void);
    bool test_large_numbers_reading(void);
    bool test_zero_values_reading(void);
    bool test_special_characters_in_strings(void);
    bool test_escape_sequences_reading(void);

In Read.EdgeCases.c:35:

    bool test_large_numbers_reading(void);
    bool test_zero_values_reading(void);
    bool test_special_characters_in_strings(void);
    bool test_escape_sequences_reading(void);
    bool test_whitespace_variations_reading(void);

In Read.EdgeCases.c:36:

    bool test_zero_values_reading(void);
    bool test_special_characters_in_strings(void);
    bool test_escape_sequences_reading(void);
    bool test_whitespace_variations_reading(void);
    bool test_nested_empty_containers(void);

In Read.EdgeCases.c:37:

    bool test_special_characters_in_strings(void);
    bool test_escape_sequences_reading(void);
    bool test_whitespace_variations_reading(void);
    bool test_nested_empty_containers(void);
    bool test_mixed_empty_and_filled(void);

In Read.EdgeCases.c:38:

    bool test_escape_sequences_reading(void);
    bool test_whitespace_variations_reading(void);
    bool test_nested_empty_containers(void);
    bool test_mixed_empty_and_filled(void);
    bool test_boundary_integers(void);

In Read.EdgeCases.c:39:

    bool test_whitespace_variations_reading(void);
    bool test_nested_empty_containers(void);
    bool test_mixed_empty_and_filled(void);
    bool test_boundary_integers(void);
    bool test_boundary_floats(void);

In Read.EdgeCases.c:40:

    bool test_nested_empty_containers(void);
    bool test_mixed_empty_and_filled(void);
    bool test_boundary_integers(void);
    bool test_boundary_floats(void);

In Read.EdgeCases.c:41:

    bool test_mixed_empty_and_filled(void);
    bool test_boundary_integers(void);
    bool test_boundary_floats(void);
    
    // Test 1: Empty object reading

In Read.EdgeCases.c:44:

    
    // Test 1: Empty object reading
    bool test_empty_object_reading(void) {
    WriteFmtLn("Testing empty object reading");

In Read.EdgeCases.c:93:

    
    // Test 2: Empty array reading
    bool test_empty_array_reading(void) {
    WriteFmtLn("Testing empty array reading");

In Read.EdgeCases.c:148:

    
    // Test 3: Empty string reading
    bool test_empty_string_reading(void) {
    WriteFmt("Testing empty string reading\n");

In Read.EdgeCases.c:184:

    
    // Test 4: Negative numbers reading
    bool test_negative_numbers_reading(void) {
    WriteFmt("Testing negative numbers reading\n");

In Read.EdgeCases.c:226:

    
    // Test 5: Large numbers reading
    bool test_large_numbers_reading(void) {
    WriteFmt("Testing large numbers reading\n");

In Read.EdgeCases.c:269:

    
    // Test 6: Zero values reading
    bool test_zero_values_reading(void) {
    WriteFmt("Testing zero values reading\n");

In Read.EdgeCases.c:311:

    
    // Test 7: Special characters in strings
    bool test_special_characters_in_strings(void) {
    WriteFmt("Testing special characters in strings\n");

In Read.EdgeCases.c:355:

    
    // Test 8: Escape sequences reading
    bool test_escape_sequences_reading(void) {
    WriteFmt("Testing escape sequences reading\n");

In Read.EdgeCases.c:400:

    
    // Test 9: Whitespace variations reading
    bool test_whitespace_variations_reading(void) {
    WriteFmt("Testing whitespace variations reading\n");

In Read.EdgeCases.c:444:

    
    // Test 10: Nested empty containers
    bool test_nested_empty_containers(void) {
    WriteFmtLn("Testing nested empty containers\n");

In Read.EdgeCases.c:490:

    
    // Test 11: Mixed empty and filled containers
    bool test_mixed_empty_and_filled(void) {
    WriteFmt("Testing mixed empty and filled containers\n");

In Read.EdgeCases.c:551:

    
    // Test 12: Boundary integers
    bool test_boundary_integers(void) {
    WriteFmt("Testing boundary integers\n");

In Read.EdgeCases.c:598:

    
    // Test 13: Boundary floats
    bool test_boundary_floats(void) {
    WriteFmt("Testing boundary floats\n");

In Write.EdgeCases.c:57:

    
    // Function prototypes
    bool test_empty_object_writing(void);
    bool test_empty_array_writing(void);
    bool test_empty_string_writing(void);

In Write.EdgeCases.c:58:

    // Function prototypes
    bool test_empty_object_writing(void);
    bool test_empty_array_writing(void);
    bool test_empty_string_writing(void);
    bool test_negative_numbers_writing(void);

In Write.EdgeCases.c:59:

    bool test_empty_object_writing(void);
    bool test_empty_array_writing(void);
    bool test_empty_string_writing(void);
    bool test_negative_numbers_writing(void);
    bool test_large_numbers_writing(void);

In Write.EdgeCases.c:60:

    bool test_empty_array_writing(void);
    bool test_empty_string_writing(void);
    bool test_negative_numbers_writing(void);
    bool test_large_numbers_writing(void);
    bool test_zero_values_writing(void);

In Write.EdgeCases.c:61:

    bool test_empty_string_writing(void);
    bool test_negative_numbers_writing(void);
    bool test_large_numbers_writing(void);
    bool test_zero_values_writing(void);
    bool test_special_characters_writing(void);

In Write.EdgeCases.c:62:

    bool test_negative_numbers_writing(void);
    bool test_large_numbers_writing(void);
    bool test_zero_values_writing(void);
    bool test_special_characters_writing(void);
    bool test_escape_sequences_writing(void);

In Write.EdgeCases.c:63:

    bool test_large_numbers_writing(void);
    bool test_zero_values_writing(void);
    bool test_special_characters_writing(void);
    bool test_escape_sequences_writing(void);
    bool test_nested_empty_containers_writing(void);

In Write.EdgeCases.c:64:

    bool test_zero_values_writing(void);
    bool test_special_characters_writing(void);
    bool test_escape_sequences_writing(void);
    bool test_nested_empty_containers_writing(void);
    bool test_mixed_empty_and_filled_writing(void);

In Write.EdgeCases.c:65:

    bool test_special_characters_writing(void);
    bool test_escape_sequences_writing(void);
    bool test_nested_empty_containers_writing(void);
    bool test_mixed_empty_and_filled_writing(void);
    bool test_boundary_integers_writing(void);

In Write.EdgeCases.c:66:

    bool test_escape_sequences_writing(void);
    bool test_nested_empty_containers_writing(void);
    bool test_mixed_empty_and_filled_writing(void);
    bool test_boundary_integers_writing(void);
    bool test_boundary_floats_writing(void);

In Write.EdgeCases.c:67:

    bool test_nested_empty_containers_writing(void);
    bool test_mixed_empty_and_filled_writing(void);
    bool test_boundary_integers_writing(void);
    bool test_boundary_floats_writing(void);
    bool test_single_values_writing(void);

In Write.EdgeCases.c:68:

    bool test_mixed_empty_and_filled_writing(void);
    bool test_boundary_integers_writing(void);
    bool test_boundary_floats_writing(void);
    bool test_single_values_writing(void);

In Write.EdgeCases.c:69:

    bool test_boundary_integers_writing(void);
    bool test_boundary_floats_writing(void);
    bool test_single_values_writing(void);
    
    // Test 1: Empty object writing

In Write.EdgeCases.c:72:

    
    // Test 1: Empty object writing
    bool test_empty_object_writing(void) {
    WriteFmtLn("Testing empty object writing");

In Write.EdgeCases.c:96:

    
    // Test 2: Empty array writing
    bool test_empty_array_writing(void) {
    WriteFmtLn("Testing empty array writing");

In Write.EdgeCases.c:122:

    
    // Test 3: Empty string writing
    bool test_empty_string_writing(void) {
    WriteFmtLn("Testing empty string writing");

In Write.EdgeCases.c:148:

    
    // Test 4: Negative numbers writing
    bool test_negative_numbers_writing(void) {
    WriteFmtLn("Testing negative numbers writing");

In Write.EdgeCases.c:174:

    
    // Test 5: Large numbers writing
    bool test_large_numbers_writing(void) {
    WriteFmtLn("Testing large numbers writing");

In Write.EdgeCases.c:205:

    
    // Test 6: Zero values writing
    bool test_zero_values_writing(void) {
    WriteFmtLn("Testing zero values writing\n");

In Write.EdgeCases.c:231:

    
    // Test 7: Special characters writing
    bool test_special_characters_writing(void) {
    WriteFmtLn("Testing special characters writing");

In Write.EdgeCases.c:266:

    
    // Test 8: Escape sequences writing
    bool test_escape_sequences_writing(void) {
    WriteFmtLn("Testing escape sequences writing");

In Write.EdgeCases.c:304:

    
    // Test 9: Nested empty containers writing
    bool test_nested_empty_containers_writing(void) {
    WriteFmtLn("Testing nested empty containers writing");

In Write.EdgeCases.c:343:

    
    // Test 10: Mixed empty and filled containers writing
    bool test_mixed_empty_and_filled_writing(void) {
    WriteFmtLn("Testing mixed empty and filled containers writing");

In Write.EdgeCases.c:382:

    
    // Test 11: Boundary integers writing
    bool test_boundary_integers_writing(void) {
    WriteFmtLn("Testing boundary integers writing");

In Write.EdgeCases.c:410:

    
    // Test 12: Boundary floats writing
    bool test_boundary_floats_writing(void) {
    WriteFmtLn("Testing boundary floats writing");

In Write.EdgeCases.c:441:

    
    // Test 13: Single values writing (minimal valid JSON objects)
    bool test_single_values_writing(void) {
    WriteFmtLn("Testing single values writing");

In Write.Nested.c:53:

    
    // Cleanup functions
    void AnnSymbolDeinit(AnnSymbol *sym) {
    StrDeinit(&sym->analysis_name);
    StrDeinit(&sym->function_name);

In Write.Nested.c:60:

    }
    
    void FunctionInfoDeinit(FunctionInfo *info) {
    StrDeinit(&info->name);
    }

In Write.Nested.c:64:

    }
    
    void SearchResultDeinit(SearchResult *result) {
    StrDeinit(&result->binary_name);
    StrDeinit(&result->sha256);

In Write.Nested.c:117:

    
    // Function prototypes
    bool test_two_level_nesting_writing(void);
    bool test_three_level_nesting_writing(void);
    bool test_complex_api_response_writing(void);

In Write.Nested.c:118:

    // Function prototypes
    bool test_two_level_nesting_writing(void);
    bool test_three_level_nesting_writing(void);
    bool test_complex_api_response_writing(void);
    bool test_function_info_array_writing(void);

In Write.Nested.c:119:

    bool test_two_level_nesting_writing(void);
    bool test_three_level_nesting_writing(void);
    bool test_complex_api_response_writing(void);
    bool test_function_info_array_writing(void);
    bool test_search_results_with_tags_writing(void);

In Write.Nested.c:120:

    bool test_three_level_nesting_writing(void);
    bool test_complex_api_response_writing(void);
    bool test_function_info_array_writing(void);
    bool test_search_results_with_tags_writing(void);
    bool test_dynamic_object_keys_writing(void);

In Write.Nested.c:121:

    bool test_complex_api_response_writing(void);
    bool test_function_info_array_writing(void);
    bool test_search_results_with_tags_writing(void);
    bool test_dynamic_object_keys_writing(void);
    bool test_deeply_nested_structure_writing(void);

In Write.Nested.c:122:

    bool test_function_info_array_writing(void);
    bool test_search_results_with_tags_writing(void);
    bool test_dynamic_object_keys_writing(void);
    bool test_deeply_nested_structure_writing(void);
    bool test_mixed_array_types_writing(void);

In Write.Nested.c:123:

    bool test_search_results_with_tags_writing(void);
    bool test_dynamic_object_keys_writing(void);
    bool test_deeply_nested_structure_writing(void);
    bool test_mixed_array_types_writing(void);

In Write.Nested.c:124:

    bool test_dynamic_object_keys_writing(void);
    bool test_deeply_nested_structure_writing(void);
    bool test_mixed_array_types_writing(void);
    
    // Test 1: Two-level nesting writing

In Write.Nested.c:127:

    
    // Test 1: Two-level nesting writing
    bool test_two_level_nesting_writing(void) {
    WriteFmt("Testing two-level nesting writing\n");

In Write.Nested.c:170:

    
    // Test 2: Three-level nesting writing
    bool test_three_level_nesting_writing(void) {
    WriteFmt("Testing three-level nesting writing\n");

In Write.Nested.c:218:

    
    // Test 3: Complex API response writing
    bool test_complex_api_response_writing(void) {
    WriteFmt("Testing complex API response writing\n");

In Write.Nested.c:290:

    
    // Test 4: Function info array writing
    bool test_function_info_array_writing(void) {
    WriteFmt("Testing function info array writing\n");

In Write.Nested.c:327:

    
    // Test 5: Search results with tags writing
    bool test_search_results_with_tags_writing(void) {
    WriteFmt("Testing search results with tags writing\n");

In Write.Nested.c:378:

    
    // Test 6: Dynamic object keys writing
    bool test_dynamic_object_keys_writing(void) {
    WriteFmt("Testing dynamic object keys writing\n");

In Write.Nested.c:442:

    
    // Test 7: Deeply nested structure writing
    bool test_deeply_nested_structure_writing(void) {
    WriteFmt("Testing deeply nested structure writing\n");

In Write.Nested.c:478:

    
    // Test 8: Mixed array types writing
    bool test_mixed_array_types_writing(void) {
    WriteFmt("Testing mixed array types writing\n");

In TestRunner.h:20:

    /// TAGS: Testing, Function, Pointer
    ///
    typedef bool (*TestFunction)(void);
    
    ///

In TestRunner.c:20:

    
    // Callback function that gets called instead of abort()
    static void test_abort_handler(void) {
    g_abort_captured = true;
    longjmp(g_test_abort_jmp, 1);

In MisraDoc.c:27:

    } Project;
    
    void ProjectDeinit(Project *p) {
    if (!p) {
    LOG_ERROR("Invalid project object. Invalid arguments");

In Main.c:3:

    #include <Misra.h>
    
    int main(void) {
    Str file = StrInit();
    if (ReadCompleteFile("Bin/Demangler/CppNameManglingGrammar", &file.data, &file.length, &file.capacity)) {

In Sys.h:52:

    /// This allows custom handling of abort situations (e.g., for testing).
    ///
    typedef void (*SysAbortCallback)(void);
    
    ///

In Sys.h:65:

    /// TAGS: System, Testing, Callback
    ///
    void SysSetAbortCallback(SysAbortCallback callback);
    
    ///

In Sys.h:77:

    /// TAGS: System, Testing, Control
    ///
    void SysAbort(void);
    
    #endif // MISRA_SYS_H

In Types.h:355:

    ///
    /// TAGS: Memory, Deallocation, Safety
    #define FREE(x) ((x) ? free((void *)(x)) : (void)1, (x) = NULL)
    
    ///

In JSON.h:674:

    do {                                                                                                               \
    bool ___is_first___ = true;                                                                                    \
    (void)___is_first___;                                                                                          \
    StrPushBack(&(j), '{');                                                                                        \
    {writer};                                                                                                      \

In JSON.h:731:

    do {                                                                                                               \
    bool ___is_first___ = true;                                                                                    \
    (void)___is_first___;                                                                                          \
    StrPushBack(&(j), '[');                                                                                        \
    VecForeach(&(arr), item) {                                                                                     \

In Memory.h:27:

    ///
    /// TAGS: Memory, Comparison, Safety
    i32 MemCompare(const void *p1, const void *p2, size n);
    
    ///

In Memory.h:40:

    ///
    /// TAGS: Memory, Copy, Safety
    void *MemCopy(void *dst, const void *src, size n);
    
    ///

In Memory.h:53:

    ///
    /// TAGS: Memory, Move, Safety
    void *MemMove(void *dst, const void *src, size n);
    
    ///

In Memory.h:66:

    ///
    /// TAGS: Memory, Set, Safety
    void *MemSet(void *dst, i32 val, size n);
    
    ///

In Memory.h:158:

    /// FAILURE: Does not return.
    ///
    void ZstrDeinit(const char **zs);
    
    ///

In Log.h:20:

    
    // Forward declaration to avoid circular includes
    void SysAbort(void);
    
    ///

In Log.h:178:

    ///
    /// TAGS: Logging, Initialization, System
    void LogInit(bool redirect);
    
    ///

In Log.h:187:

    ///
    /// TAGS: Logging, Cleanup, System
    void LogDeinit(void);
    
    ///

In Log.h:201:

    ///
    /// TAGS: Logging, LowLevel, System
    void LogWrite(LogMessageType type, const char *tag, int line, const char *msg);
    
    #endif // MISRA_STD_LOG_H

In Io.h:102:

    /// TAGS: I/O, Generic, Container
    ///
    typedef const char *(*TypeSpecificReader)(const char *i, FmtInfo *fmt_info, void *data);
    
    ///

In Io.h:117:

    TypeSpecificWriter writer;
    TypeSpecificReader reader;
    void              *data;
    } TypeSpecificIO;

In Io.h:126:

    #endif
    
    static inline TypeSpecificIO TO_TYPE_SPECIFIC_IO_IMPL(TypeSpecificWriter w, TypeSpecificReader r, void *d) {
    return (TypeSpecificIO) {.writer = w, .reader = r, .data = d};
    }

In Io.h:170:

    _Generic(                                                                                                      \
    (x),                                                                                                       \
    Str: TO_TYPE_SPECIFIC_IO(Str, (void *)&(x)),                                                               \
    BitVec: TO_TYPE_SPECIFIC_IO(BitVec, (void *)&(x)),                                                         \
    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \

In Io.h:171:

    (x),                                                                                                       \
    Str: TO_TYPE_SPECIFIC_IO(Str, (void *)&(x)),                                                               \
    BitVec: TO_TYPE_SPECIFIC_IO(BitVec, (void *)&(x)),                                                         \
    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \
    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \

In Io.h:172:

    Str: TO_TYPE_SPECIFIC_IO(Str, (void *)&(x)),                                                               \
    BitVec: TO_TYPE_SPECIFIC_IO(BitVec, (void *)&(x)),                                                         \
    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \
    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    unsigned char: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                      \

In Io.h:173:

    BitVec: TO_TYPE_SPECIFIC_IO(BitVec, (void *)&(x)),                                                         \
    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \
    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    unsigned char: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                      \
    unsigned short: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                    \

In Io.h:174:

    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \
    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    unsigned char: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                      \
    unsigned short: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                    \
    unsigned int: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                      \

In Io.h:175:

    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    unsigned char: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                      \
    unsigned short: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                    \
    unsigned int: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                      \
    unsigned long: sizeof(unsigned long) == 4 ? TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)) :                       \

In Io.h:176:

    unsigned char: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                      \
    unsigned short: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                    \
    unsigned int: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                      \
    unsigned long: sizeof(unsigned long) == 4 ? TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)) :                       \
    TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                        \

In Io.h:177:

    unsigned short: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                    \
    unsigned int: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                      \
    unsigned long: sizeof(unsigned long) == 4 ? TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)) :                       \
    TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                        \
    unsigned long long: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                \

In Io.h:178:

    unsigned int: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                      \
    unsigned long: sizeof(unsigned long) == 4 ? TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)) :                       \
    TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                        \
    unsigned long long: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                \
    signed char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                        \

In Io.h:179:

    unsigned long: sizeof(unsigned long) == 4 ? TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)) :                       \
    TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                        \
    unsigned long long: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                \
    signed char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                        \
    signed short: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                      \

In Io.h:180:

    TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                        \
    unsigned long long: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                \
    signed char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                        \
    signed short: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                      \
    signed int: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                        \

In Io.h:181:

    unsigned long long: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                \
    signed char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                        \
    signed short: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                      \
    signed int: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                        \
    signed long: sizeof(signed long) == 4 ? TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)) :                           \

In Io.h:182:

    signed char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                        \
    signed short: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                      \
    signed int: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                        \
    signed long: sizeof(signed long) == 4 ? TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)) :                           \
    TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                            \

In Io.h:183:

    signed short: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                      \
    signed int: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                        \
    signed long: sizeof(signed long) == 4 ? TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)) :                           \
    TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                            \
    signed long long: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                  \

In Io.h:184:

    signed int: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                        \
    signed long: sizeof(signed long) == 4 ? TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)) :                           \
    TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                            \
    signed long long: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                  \
    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \

In Io.h:185:

    signed long: sizeof(signed long) == 4 ? TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)) :                           \
    TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                            \
    signed long long: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                  \
    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \
    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \

In Io.h:186:

    TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                            \
    signed long long: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                  \
    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \
    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \
    char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                               \

In Io.h:187:

    signed long long: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                  \
    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \
    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \
    char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                               \
    default: TO_TYPE_SPECIFIC_IO(UnsupportedType, NULL)                                                        \

In Io.h:188:

    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \
    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \
    char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                               \
    default: TO_TYPE_SPECIFIC_IO(UnsupportedType, NULL)                                                        \
    )

In Io.h:257:

    /// TAGS: Formatting, I/O, File
    ///
    void FReadFmtInternal(FILE *stream, const char *fmtstr, TypeSpecificIO *argv, u64 argc);
    
    ///

In Io.h:526:

    
    // not for direct use
    void _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    void _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);

In Io.h:527:

    // not for direct use
    void _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    void _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);

In Io.h:528:

    void _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    void _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.h:529:

    void _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);

In Io.h:530:

    void _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);

In Io.h:531:

    void _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);

In Io.h:532:

    void _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);

In Io.h:533:

    void _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s);

In Io.h:534:

    void _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s);

In Io.h:535:

    void _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);

In Io.h:536:

    void _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);

In Io.h:537:

    void _write_Zstr(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    void _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv);

In Io.h:538:

    void _write_UnsupportedType(Str *o, FmtInfo *fmt_info, const char **s);
    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    void _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv);

In Io.h:539:

    void _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    void _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    void _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv);
    
    const char *_read_Str(const char *i, FmtInfo *fmt_info, Str *s);

In Type.h:10:

    
    typedef struct GenericIter {
    void *data;
    size  length;
    size  pos;

In Type.h:17:

    } GenericIter;
    
    #define GENERIC_ITER(x) ((GenericIter *)(void *)(x))
    
    ///

In Type.h:57:

    ///
    #define ValidateIter(mi) validate_iter((GenericIter *)mi)
    void validate_iter(GenericIter *mi);
    
    ///

In Common.h:31:

    // from src to dst.
    
    typedef bool (*GenericCopyInit)(void *dst, void *src);
    typedef void (*GenericCopyDeinit)(void *copy);
    typedef i32 (*GenericCompare)(const void *first, const void *second);

In Common.h:32:

    
    typedef bool (*GenericCopyInit)(void *dst, void *src);
    typedef void (*GenericCopyDeinit)(void *copy);
    typedef i32 (*GenericCompare)(const void *first, const void *second);
    typedef u64 (*GenericHash)(const void *data, u32 size);

In Common.h:33:

    typedef bool (*GenericCopyInit)(void *dst, void *src);
    typedef void (*GenericCopyDeinit)(void *copy);
    typedef i32 (*GenericCompare)(const void *first, const void *second);
    typedef u64 (*GenericHash)(const void *data, u32 size);

In Common.h:34:

    typedef void (*GenericCopyDeinit)(void *copy);
    typedef i32 (*GenericCompare)(const void *first, const void *second);
    typedef u64 (*GenericHash)(const void *data, u32 size);
    
    #endif // MISRA_STD_CONTAINER_COMMON_H

In Insert.h:134:

    {                                                                                                              \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = (val);                                                              \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    insert_range_fast_into_vec(GENERIC_VEC(v), (char *)__ptr_val_##__LINE__, sizeof(VEC_DATATYPE(v)), (idx), 1);   \

In Insert.h:165:

    {                                                                                                              \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = (val);                                                              \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    insert_range_fast_into_vec(GENERIC_VEC(v), (char *)__ptr_val_##__LINE__, sizeof(VEC_DATATYPE(v)), (idx), 1);   \

In Insert.h:210:

    }                                                                                                          \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = *(varr);                                                            \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    VEC_DATATYPE(v) *__tmp_ptr_##__LINE__ = (varr);                                                                \

In Insert.h:215:

    insert_range_into_vec(GENERIC_VEC(v), (char *)__tmp_ptr_##__LINE__, sizeof(VEC_DATATYPE(v)), (idx), (count));  \
    if (!(v)->copy_init) {                                                                                         \
    memset((void *)(__tmp_ptr_##__LINE__), 0, (count) * sizeof(VEC_DATATYPE(v)));                              \
    }                                                                                                              \
    } while (0)

In Insert.h:247:

    }                                                                                                          \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = *(varr);                                                            \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp_ptr_##__LINE__ = (varr);                                                          \

In Insert.h:306:

    }                                                                                                          \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = *(varr);                                                            \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp_ptr_##__LINE__ = (varr);                                                          \

In Insert.h:317:

    );                                                                                                             \
    if (!(v)->copy_init) {                                                                                         \
    memset((void *)__tmp_ptr_##__LINE__, 0, (count) * sizeof(VEC_DATATYPE(v)));                                \
    }                                                                                                              \
    } while (0)

In Insert.h:351:

    }                                                                                                          \
    VEC_DATATYPE(v) __tmp_val_##__LINE__ = *(varr);                                                            \
    (void)__tmp_val_##__LINE__;                                                                                \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp_ptr_##__LINE__ = (varr);                                                          \

In Remove.h:29:

    if ((ptr) != NULL) {                                                                                           \
    const VEC_DATATYPE(v) __x = *(ptr);                                                                        \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    VEC_DATATYPE(v) *p = (ptr);                                                                                    \

In Remove.h:52:

    if ((ptr) != NULL) {                                                                                           \
    const VEC_DATATYPE(v) __x = *(ptr);                                                                        \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    VEC_DATATYPE(v) *p = (ptr);                                                                                    \

In Remove.h:75:

    if ((ptr) != NULL) {                                                                                           \
    const VEC_DATATYPE(v) __x = *(ptr);                                                                        \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    VEC_DATATYPE(v) *p = (ptr);                                                                                    \

In Remove.h:99:

    if ((ptr) != NULL) {                                                                                           \
    const VEC_DATATYPE(v) __x = *(ptr);                                                                        \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    VEC_DATATYPE(v) *p = (ptr);                                                                                    \

In Type.h:23:

    } GenericVec;
    
    #define GENERIC_VEC(x) ((GenericVec *)(void *)(x))
    
    ///

In Private.h:16:

    #endif
    
    void init_vec(
    GenericVec       *vec,
    size              item_size,

In Private.h:23:

    size              alignment
    );
    void deinit_vec(GenericVec *vec, size item_size);
    void clear_vec(GenericVec *vec, size item_size);
    void resize_vec(GenericVec *vec, size item_size, size new_size);

In Private.h:24:

    );
    void deinit_vec(GenericVec *vec, size item_size);
    void clear_vec(GenericVec *vec, size item_size);
    void resize_vec(GenericVec *vec, size item_size, size new_size);
    void reserve_vec(GenericVec *vec, size item_size, size n);

In Private.h:25:

    void deinit_vec(GenericVec *vec, size item_size);
    void clear_vec(GenericVec *vec, size item_size);
    void resize_vec(GenericVec *vec, size item_size, size new_size);
    void reserve_vec(GenericVec *vec, size item_size, size n);
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n);

In Private.h:26:

    void clear_vec(GenericVec *vec, size item_size);
    void resize_vec(GenericVec *vec, size item_size, size new_size);
    void reserve_vec(GenericVec *vec, size item_size, size n);
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n);
    void reduce_space_vec(GenericVec *vec, size item_size);

In Private.h:27:

    void resize_vec(GenericVec *vec, size item_size, size new_size);
    void reserve_vec(GenericVec *vec, size item_size, size n);
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n);
    void reduce_space_vec(GenericVec *vec, size item_size);
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);

In Private.h:28:

    void reserve_vec(GenericVec *vec, size item_size, size n);
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n);
    void reduce_space_vec(GenericVec *vec, size item_size);
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);

In Private.h:29:

    void reserve_pow2_vec(GenericVec *vec, size item_size, size n);
    void reduce_space_vec(GenericVec *vec, size item_size);
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);

In Private.h:30:

    void reduce_space_vec(GenericVec *vec, size item_size);
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);

In Private.h:31:

    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp);

In Private.h:32:

    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count);
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp);
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2);

In Private.h:33:

    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp);
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2);
    void reverse_vec(GenericVec *vec, size item_size);

In Private.h:34:

    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count);
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp);
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2);
    void reverse_vec(GenericVec *vec, size item_size);
    void validate_vec(const GenericVec *v);

In Private.h:35:

    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp);
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2);
    void reverse_vec(GenericVec *vec, size item_size);
    void validate_vec(const GenericVec *v);

In Private.h:36:

    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2);
    void reverse_vec(GenericVec *vec, size item_size);
    void validate_vec(const GenericVec *v);
    
    #ifdef __cplusplus

In Insert.h:192:

    LIST_DATA_TYPE(l) * UNPL(_ptrval)     = (arr);                                                                 \
    const LIST_DATA_TYPE(l) UNPL(_tmpval) = *UNPL(_ptrval);                                                        \
    (void)UNPL(_tmpval);                                                                                           \
    push_arr_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), UNPL(_ptrval), (count));                             \
    if (!(l)->copy_init) {                                                                                         \

In Insert.h:218:

    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \

In Insert.h:219:

    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \
    merge_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), GENERIC_LIST(l2));                                      \

In Insert.h:249:

    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \

In Insert.h:250:

    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \
    merge_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), GENERIC_LIST(l2));                                      \

In Type.h:24:

    GenericListNode *next;
    GenericListNode *prev;
    void            *data;
    };

In Type.h:43:

    /// Cast any list to a generic list
    ///
    #define GENERIC_LIST(list) ((GenericList *)(void *)(list))
    
    ///

In Type.h:48:

    /// Cast any list node to a generic list node
    ///
    #define GENERIC_LIST_NODE(node) ((GenericListNode *)(void *)(node))
    
    ///

In Foreach.h:31:

    for (GenericListNode * UNPL(node) = (GenericListNode *)ListNodeBegin(UNPL(pl)); UNPL(node);                          \
    UNPL(node)                   = ListNodeNext(UNPL(node)))                                                        \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                        \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \

In Foreach.h:32:

    UNPL(node)                   = ListNodeNext(UNPL(node)))                                                        \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                        \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data)); \

In Foreach.h:58:

    for (GenericListNode * UNPL(node) = (GenericListNode *)ListNodeBegin(UNPL(pl)); UNPL(node);                        \
    UNPL(node)                   = ListNodeNext(UNPL(node)))                                                      \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                      \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \

In Foreach.h:59:

    UNPL(node)                   = ListNodeNext(UNPL(node)))                                                      \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                      \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data); \

In Foreach.h:85:

    for (GenericListNode * UNPL(node) = (GenericListNode *)ListNodeEnd(UNPL(pl)); UNPL(node);                            \
    UNPL(node)                   = ListNodePrev(UNPL(node)))                                                        \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                        \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \

In Foreach.h:86:

    UNPL(node)                   = ListNodePrev(UNPL(node)))                                                        \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                        \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data)); \

In Foreach.h:112:

    for (GenericListNode * UNPL(node) = (GenericListNode *)ListNodeEnd(UNPL(pl)); UNPL(node);                          \
    UNPL(node)                   = ListNodePrev(UNPL(node)))                                                      \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                      \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \

In Foreach.h:113:

    UNPL(node)                   = ListNodePrev(UNPL(node)))                                                      \
    if (((void *)UNPL(node)->next != (void *)UNPL(node)) &&                                      \
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data); \

In Private.h:12:

    #include <Misra/Std/Container/List/Type.h>
    
    void             deinit_list(GenericList *list, u64 item_size);
    void             insert_into_list(GenericList *list, void *item_data, u64 item_size, u64 idx);
    void             remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count);

In Private.h:13:

    
    void             deinit_list(GenericList *list, u64 item_size);
    void             insert_into_list(GenericList *list, void *item_data, u64 item_size, u64 idx);
    void             remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count);
    void             qsort_list(GenericList *list, u64 item_size, GenericCompare comp);

In Private.h:14:

    void             deinit_list(GenericList *list, u64 item_size);
    void             insert_into_list(GenericList *list, void *item_data, u64 item_size, u64 idx);
    void             remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count);
    void             qsort_list(GenericList *list, u64 item_size, GenericCompare comp);
    void             swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2);

In Private.h:15:

    void             insert_into_list(GenericList *list, void *item_data, u64 item_size, u64 idx);
    void             remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count);
    void             qsort_list(GenericList *list, u64 item_size, GenericCompare comp);
    void             swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2);
    void             reverse_list(GenericList *list, u64 item_size);

In Private.h:16:

    void             remove_range_list(GenericList *list, void *removed_data, u64 item_size, u64 start, u64 count);
    void             qsort_list(GenericList *list, u64 item_size, GenericCompare comp);
    void             swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2);
    void             reverse_list(GenericList *list, u64 item_size);
    void             push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count);

In Private.h:17:

    void             qsort_list(GenericList *list, u64 item_size, GenericCompare comp);
    void             swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2);
    void             reverse_list(GenericList *list, u64 item_size);
    void             push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count);
    void             merge_list(GenericList *list1, u64 item_size, GenericList *list2);

In Private.h:18:

    void             swap_list(GenericList *list, u64 item_size, u64 idx1, u64 idx2);
    void             reverse_list(GenericList *list, u64 item_size);
    void             push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count);
    void             merge_list(GenericList *list1, u64 item_size, GenericList *list2);
    void             resize_list(GenericList *list, u64 item_size, u64 new_size);

In Private.h:19:

    void             reverse_list(GenericList *list, u64 item_size);
    void             push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count);
    void             merge_list(GenericList *list1, u64 item_size, GenericList *list2);
    void             resize_list(GenericList *list, u64 item_size, u64 new_size);
    void             clear_list(GenericList *list, u64 item_size);

In Private.h:20:

    void             push_arr_list(GenericList *list, u64 item_size, void *arr, u64 count);
    void             merge_list(GenericList *list1, u64 item_size, GenericList *list2);
    void             resize_list(GenericList *list, u64 item_size, u64 new_size);
    void             clear_list(GenericList *list, u64 item_size);
    GenericListNode *node_at_list(GenericList *list, u64 item_size, u64 idx);

In Private.h:21:

    void             merge_list(GenericList *list1, u64 item_size, GenericList *list2);
    void             resize_list(GenericList *list, u64 item_size, u64 new_size);
    void             clear_list(GenericList *list, u64 item_size);
    GenericListNode *node_at_list(GenericList *list, u64 item_size, u64 idx);
    void            *item_ptr_at_list(GenericList *list, u64 item_size, u64 idx);

In Private.h:23:

    void             clear_list(GenericList *list, u64 item_size);
    GenericListNode *node_at_list(GenericList *list, u64 item_size, u64 idx);
    void            *item_ptr_at_list(GenericList *list, u64 item_size, u64 idx);
    void             validate_list(const GenericList *list);
    GenericListNode *get_node_relative_to_list_node(GenericListNode *node, i64 ridx);

In Private.h:24:

    GenericListNode *node_at_list(GenericList *list, u64 item_size, u64 idx);
    void            *item_ptr_at_list(GenericList *list, u64 item_size, u64 idx);
    void             validate_list(const GenericList *list);
    GenericListNode *get_node_relative_to_list_node(GenericListNode *node, i64 ridx);
    GenericListNode *get_node_random_access(GenericList *list, GenericListNode *node, u64 nidx, i64 ridx);

In Insert.h:31:

    /// TAGS: Insert, BitVec, Range, Multiple
    ///
    void BitVecInsertRange(BitVec *bv, u64 idx, u64 count, bool value);
    
    ///

In Insert.h:46:

    /// TAGS: Insert, BitVec, Multiple, Copy
    ///
    void BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other);
    
    ///

In Insert.h:63:

    /// TAGS: Insert, BitVec, Pattern, Byte
    ///
    void BitVecInsertPattern(BitVec *bv, u64 idx, u8 pattern, u64 pattern_bits);
    
    ///

In Insert.h:78:

    /// TAGS: BitVec, Push, Append, Insert
    ///
    void BitVecPush(BitVec *bv, bool value);
    
    ///

In Insert.h:93:

    /// TAGS: BitVec, Insert, Shift, Single
    ///
    void BitVecInsert(BitVec *bv, u64 idx, bool value);
    
    #ifdef __cplusplus

In Remove.h:30:

    /// TAGS: Remove, BitVec, Range, Multiple
    ///
    void BitVecRemoveRange(BitVec *bv, u64 idx, u64 count);
    
    ///

In Type.h:54:

    /// FAILURE: `abort`
    ///
    void ValidateBitVec(const BitVec *bv);
    
    #endif // MISRA_STD_CONTAINER_BITVEC_TYPE_H

In Memory.h:28:

    /// TAGS: BitVec, Memory, Shrink, Optimize
    ///
    void BitVecShrinkToFit(BitVec *bv);

In Memory.h:44:

    /// TAGS: BitVec, Memory, Swap, Efficient
    ///
    void BitVecSwap(BitVec *bv1, BitVec *bv2);
    
    ///

In Init.h:80:

    /// TAGS: Deinit, BitVec, Cleanup, Memory
    ///
    void BitVecDeinit(BitVec *bv);
    
    ///

In Init.h:93:

    /// TAGS: Clear, BitVec, Reset
    ///
    void BitVecClear(BitVec *bv);
    
    ///

In Init.h:107:

    /// TAGS: BitVec, Reserve, Capacity, Memory
    ///
    void BitVecReserve(BitVec *bv, u64 n);
    
    ///

In Init.h:121:

    /// TAGS: BitVec, Resize, Length
    ///
    void BitVecResize(BitVec *bv, u64 n);
    
    #ifdef __cplusplus

In Access.h:44:

    /// TAGS: BitVec, Access, Set, Boolean
    ///
    void BitVecSet(BitVec *bv, u64 idx, bool value);
    
    ///

In Access.h:58:

    /// TAGS: BitVec, Access, Flip, Toggle
    ///
    void BitVecFlip(BitVec *bv, u64 idx);
    
    ///

In BitWise.h:29:

    /// TAGS: BitVec, And, Bitwise, Operation
    ///
    void BitVecAnd(BitVec *result, BitVec *a, BitVec *b);
    
    ///

In BitWise.h:44:

    /// TAGS: BitVec, Or, Bitwise, Operation
    ///
    void BitVecOr(BitVec *result, BitVec *a, BitVec *b);
    
    ///

In BitWise.h:59:

    /// TAGS: BitVec, Xor, Bitwise, Operation
    ///
    void BitVecXor(BitVec *result, BitVec *a, BitVec *b);
    
    ///

In BitWise.h:73:

    /// TAGS: BitVec, Not, Bitwise, Operation
    ///
    void BitVecNot(BitVec *result, BitVec *bv);
    
    ///

In BitWise.h:87:

    /// TAGS: BitVec, Shift, Left, Operation
    ///
    void BitVecShiftLeft(BitVec *bv, u64 positions);
    
    ///

In BitWise.h:101:

    /// TAGS: BitVec, Shift, Right, Operation
    ///
    void BitVecShiftRight(BitVec *bv, u64 positions);
    
    ///

In BitWise.h:115:

    /// TAGS: BitVec, Rotate, Left, Circular
    ///
    void BitVecRotateLeft(BitVec *bv, u64 positions);
    
    ///

In BitWise.h:129:

    /// TAGS: BitVec, Rotate, Right, Circular
    ///
    void BitVecRotateRight(BitVec *bv, u64 positions);
    
    ///

In BitWise.h:142:

    /// TAGS: BitVec, Reverse, Order
    ///
    void BitVecReverse(BitVec *bv);
    
    #ifdef __cplusplus

In Ops.h:180:

    /// FAILURE : No replacement if `match` not found.
    ///
    void StrReplaceZstr(Str *s, const char *match, const char *replacement, size count);
    
    ///

In Ops.h:195:

    /// FAILURE : No replacement if `match` not found.
    ///
    void StrReplaceCstr(
    Str        *s,
    const char *match,

In Ops.h:215:

    /// FAILURE : No replacement if `match` not found.
    ///
    void StrReplace(Str *s, const Str *match, const Str *replacement, size count);
    
    //

In Type.h:35:

    /// FAILURE: `abort`
    ///
    void ValidateStr(const Str *s);
    
    ///

In Type.h:47:

    /// FAILURE: `abort`
    ///
    void ValidateStrs(const Strs *vs);

In Init.h:126:

    /// str : Pointer to string to be deinited
    ///
    void StrDeinit(Str *str);
    
    ///

In Mutex.h:14:

    /// TAGS: System, Threading, Synchronization
    ///
    SysMutex *SysMutexCreate(void);
    
    ///

In Mutex.h:28:

    /// TAGS: System, Threading, Memory
    ///
    void SysMutexDestroy(SysMutex *m);
    
    ///

In Proc.h:48:

    /// FAILURE: Abort with log message.
    ///
    void SysProcWait(SysProc *proc);
    
    ///

In Proc.h:71:

    /// FAILURE: Abort with log message.
    ///
    void SysProcTerminate(SysProc *proc);
    
    ///

In Proc.h:81:

    /// FAILURE: Abort with log message.
    ///
    void SysProcDestroy(SysProc *proc);
    
    ///

In Proc.h:149:

    /// TAGS: System, Process
    ///
    SysProcId SysGetCurrentProcessId(void);
    
    ///

In Harness.h:21:

    // Common string generation for char* vectors
    char *generate_cstring(const uint8_t *data, size_t *offset, size_t size, size_t max_len);
    void  cleanup_cstring(char *str);
    
    // Note: Str generation function will be added later to avoid forward declaration conflicts

In Harness.c:90:

    
    // Clean up a generated C-string
    void cleanup_cstring(char *str) {
    free(str);
    }

In Harness.c:95:

    
    // Initialize all container objects in FuzzState
    static void init_fuzz_state(FuzzState *state) {
    if (state->initialized) {
    return;

In Harness.c:109:

    
    // Deinitialize all container objects in FuzzState
    static void deinit_fuzz_state(FuzzState *state) {
    if (!state->initialized) {
    return;

In Str.c:30:

    }
    
    void init_str(Str *str) {
    *str = StrInit();
    }

In Str.c:34:

    }
    
    void deinit_str(Str *str) {
    StrDeinit(str);
    }

In Str.c:38:

    }
    
    void fuzz_str(Str *str, StrFunction func, const uint8_t *data, size_t *offset, size_t size) {
    switch (func) {
    case STR_INIT : {

In Str.c:99:

    if (VecLen(str) > 0) {
    char first = StrFirst(str);
    (void)first; // Suppress unused variable warning
    }
    break;

In Str.c:107:

    if (VecLen(str) > 0) {
    char last = StrLast(str);
    (void)last; // Suppress unused variable warning
    }
    break;

In Str.c:114:

    case STR_BEGIN : {
    char *begin = StrBegin(str);
    (void)begin; // Suppress unused variable warning
    break;
    }

In Str.c:120:

    case STR_END : {
    char *end = StrEnd(str);
    (void)end; // Suppress unused variable warning
    break;
    }

In Str.c:128:

    size_t idx = extract_u16(data, offset, size) % VecLen(str);
    char   ch  = StrCharAt(str, idx);
    (void)ch; // Suppress unused variable warning
    }
    break;

In Str.c:137:

    size_t idx = extract_u16(data, offset, size) % VecLen(str);
    char  *ptr = StrCharPtrAt(str, idx);
    (void)ptr; // Suppress unused variable warning
    }
    break;

In Str.c:171:

    case STR_LEN : {
    size_t len = VecLen(str);
    (void)len; // Suppress unused variable warning
    break;
    }

In Str.c:177:

    case STR_SIZE : {
    size_t size_bytes = VecSize(str);
    (void)size_bytes; // Suppress unused variable warning
    break;
    }

In Str.c:186:

    Str temp   = generate_str_from_input(data, offset, size, 20);
    int result = StrCmp(str, &temp);
    (void)result; // Suppress unused variable warning
    StrDeinit(&temp);
    }

In Str.c:197:

    if (cstr) {
    int result = StrCmpCstr(str, cstr, strlen(cstr));
    (void)result; // Suppress unused variable warning
    free(cstr);
    }

In Str.c:209:

    if (zstr) {
    int result = StrCmpZstr(str, zstr);
    (void)result; // Suppress unused variable warning
    free(zstr);
    }

In Str.c:220:

    Str   temp  = generate_str_from_input(data, offset, size, 10);
    char *found = StrFindStr(str, &temp);
    (void)found; // Suppress unused variable warning
    StrDeinit(&temp);
    }

In Str.c:231:

    if (zstr) {
    char *found = StrFindZstr(str, zstr);
    (void)found; // Suppress unused variable warning
    free(zstr);
    }

In Str.c:243:

    if (cstr) {
    char *found = StrFindCstr(str, cstr, strlen(cstr));
    (void)found; // Suppress unused variable warning
    free(cstr);
    }

In Str.c:352:

    char ch;
    StrPopBack(str, &ch);
    (void)ch; // Suppress unused variable warning
    }
    break;

In Str.c:361:

    char ch;
    StrPopFront(str, &ch);
    (void)ch; // Suppress unused variable warning
    }
    break;

In Str.c:371:

    char   ch;
    StrRemove(str, &ch, idx);
    (void)ch; // Suppress unused variable warning
    }
    break;

In Str.c:465:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:476:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:487:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:498:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:509:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:520:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:531:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:542:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In Str.c:556:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In Str.c:571:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In Str.c:586:

    total_len += 1;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In Str.c:601:

    total_len += 1 + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecInt.c:13:

    
    // Comparator function for sorting integers
    static int compare_ints(const void *a, const void *b) {
    i32 ia = *(const i32 *)a;
    i32 ib = *(const i32 *)b;

In VecInt.c:19:

    }
    
    void init_int_vec(IntVec *vec) {
    *vec = VecInitT(*vec);
    }

In VecInt.c:23:

    }
    
    void deinit_int_vec(IntVec *vec) {
    VecDeinit(vec);
    }

In VecInt.c:27:

    }
    
    void fuzz_int_vec(IntVec *vec, VecIntFunction func, const uint8_t *data, size_t *offset, size_t size) {
    switch (func) {
    case VEC_INT_PUSH_BACK : {

In VecInt.c:88:

    if (idx < VecLen(vec)) {
    volatile i32 value = VecAt(vec, idx);
    (void)value; // Prevent optimization
    }
    break;

In VecInt.c:95:

    case VEC_INT_LEN : {
    volatile uint64_t len = VecLen(vec);
    (void)len;
    break;
    }

In VecInt.c:102:

    if (VecLen(vec) > 0) {
    volatile i32 first = VecFirst(vec);
    (void)first;
    }
    break;

In VecInt.c:110:

    if (VecLen(vec) > 0) {
    volatile i32 last = VecLast(vec);
    (void)last;
    }
    break;

In VecInt.c:142:

    case VEC_INT_SIZE : {
    volatile uint64_t size_val = VecSize(vec);
    (void)size_val;
    break;
    }

In VecInt.c:238:

    sum += removed_items[i];
    }
    (void)sum;
    }
    break;

In VecInt.c:306:

    case VEC_INT_BEGIN : {
    volatile i32 *begin_ptr = (i32 *)VecBegin(vec);
    (void)begin_ptr;
    break;
    }

In VecInt.c:311:

    
    case VEC_INT_END : {
    volatile void *end_ptr = VecEnd(vec);
    (void)end_ptr;
    break;

In VecInt.c:312:

    case VEC_INT_END : {
    volatile void *end_ptr = VecEnd(vec);
    (void)end_ptr;
    break;
    }

In VecInt.c:321:

    volatile i32 *ptr = VecPtrAt(vec, idx);
    volatile i32  val = *ptr;
    (void)val;
    }
    break;

In VecInt.c:360:

    if (idx <= VecLen(vec)) {
    volatile uint64_t offset_val = VecAlignedOffsetAt(vec, idx);
    (void)offset_val;
    }
    break;

In VecInt.c:402:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:413:

    sum += item + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:424:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:435:

    sum += *item_ptr + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:446:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:457:

    sum += item + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:468:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:479:

    sum += *item_ptr + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In VecInt.c:493:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In VecInt.c:508:

    sum += item + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In VecInt.c:523:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In VecInt.c:538:

    sum += *item_ptr + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In VecCharPtr.h:85:

    
    // Function prototypes
    void init_char_ptr_vec(CharPtrVec *vec);
    void deinit_char_ptr_vec(CharPtrVec *vec);
    void fuzz_char_ptr_vec(CharPtrVec *vec, VecCharPtrFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecCharPtr.h:86:

    // Function prototypes
    void init_char_ptr_vec(CharPtrVec *vec);
    void deinit_char_ptr_vec(CharPtrVec *vec);
    void fuzz_char_ptr_vec(CharPtrVec *vec, VecCharPtrFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecCharPtr.h:87:

    void init_char_ptr_vec(CharPtrVec *vec);
    void deinit_char_ptr_vec(CharPtrVec *vec);
    void fuzz_char_ptr_vec(CharPtrVec *vec, VecCharPtrFunction func, const uint8_t *data, size_t *offset, size_t size);
    
    #endif // FUZZ_VEC_CHAR_PTR_H

In VecStr.c:37:

    }
    
    void init_str_vec(StrVec *vec) {
    *vec = VecInitWithDeepCopyT(*vec, NULL, StrDeinit);
    }

In VecStr.c:41:

    }
    
    void deinit_str_vec(StrVec *vec) {
    // VecDeinit will automatically call StrDeinit on each element
    VecDeinit(vec);

In VecStr.c:46:

    }
    
    void fuzz_str_vec(StrVec *vec, VecStrFunction func, const uint8_t *data, size_t *offset, size_t size) {
    switch (func) {
    case VEC_STR_PUSH_BACK : {

In VecStr.c:110:

    size_t index = extract_u32(data, offset, size) % VecLen(vec);
    Str    str   = VecAt(vec, index);
    (void)str; // Use the result to avoid warnings
    }
    break;

In VecStr.c:117:

    case VEC_STR_LEN : {
    size_t len = VecLen(vec);
    (void)len; // Use the result to avoid warnings
    break;
    }

In VecStr.c:124:

    if (VecLen(vec) > 0) {
    Str first = VecFirst(vec);
    (void)first; // Use the result to avoid warnings
    }
    break;

In VecStr.c:132:

    if (VecLen(vec) > 0) {
    Str last = VecLast(vec);
    (void)last; // Use the result to avoid warnings
    }
    break;

In VecStr.c:178:

    case VEC_STR_SIZE : {
    size_t size_bytes = VecSize(vec);
    (void)size_bytes; // Use the result to avoid warnings
    break;
    }

In VecStr.c:325:

    if (VecLen(vec) > 0) {
    Str *begin = VecBegin(vec);
    (void)begin; // Use the result to avoid warnings
    }
    break;

In VecStr.c:333:

    if (VecLen(vec) > 0) {
    char *end = VecEnd(vec);
    (void)end; // Use the result to avoid warnings
    }
    break;

In VecStr.c:342:

    size_t index = extract_u32(data, offset, size) % VecLen(vec);
    Str   *ptr   = VecPtrAt(vec, index);
    (void)ptr; // Use the result to avoid warnings
    }
    break;

In VecStr.c:387:

    // Note: VecAlignedOffsetAt doesn't take alignment parameter
    size_t offset = VecAlignedOffsetAt(vec, index);
    (void)offset; // Use the result to avoid warnings
    }
    break;

In VecStr.c:432:

    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:443:

    total_len += strlen(str.data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:454:

    total_len += strlen(str_ptr->data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:465:

    total_len += strlen(str_ptr->data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:476:

    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:487:

    total_len += ZstrLen(str.data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:498:

    total_len += ZstrLen(str_ptr->data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:509:

    total_len += ZstrLen(str_ptr->data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecStr.c:523:

    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecStr.c:538:

    total_len += ZstrLen(str.data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecStr.c:553:

    total_len += ZstrLen(str_ptr->data);
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecStr.c:568:

    total_len += ZstrLen(str_ptr->data) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In Str.h:99:

    
    // Function prototypes
    void init_str(Str *str);
    void deinit_str(Str *str);
    void fuzz_str(Str *str, StrFunction func, const uint8_t *data, size_t *offset, size_t size);

In Str.h:100:

    // Function prototypes
    void init_str(Str *str);
    void deinit_str(Str *str);
    void fuzz_str(Str *str, StrFunction func, const uint8_t *data, size_t *offset, size_t size);

In Str.h:101:

    void init_str(Str *str);
    void deinit_str(Str *str);
    void fuzz_str(Str *str, StrFunction func, const uint8_t *data, size_t *offset, size_t size);
    
    #endif // FUZZ_STR_H

In VecStr.h:86:

    
    // Function prototypes
    void init_str_vec(StrVec *vec);
    void deinit_str_vec(StrVec *vec);
    void fuzz_str_vec(StrVec *vec, VecStrFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecStr.h:87:

    // Function prototypes
    void init_str_vec(StrVec *vec);
    void deinit_str_vec(StrVec *vec);
    void fuzz_str_vec(StrVec *vec, VecStrFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecStr.h:88:

    void init_str_vec(StrVec *vec);
    void deinit_str_vec(StrVec *vec);
    void fuzz_str_vec(StrVec *vec, VecStrFunction func, const uint8_t *data, size_t *offset, size_t size);
    
    #endif // FUZZ_VEC_STR_H

In VecCharPtr.c:24:

    
    // Deinit function for char* - frees the string
    static void char_ptr_deinit(char **str) {
    if (str && *str) {
    free(*str);

In VecCharPtr.c:31:

    }
    
    void init_char_ptr_vec(CharPtrVec *vec) {
    *vec = VecInitWithDeepCopyT(*vec, char_ptr_copy_init, char_ptr_deinit);
    }

In VecCharPtr.c:35:

    }
    
    void deinit_char_ptr_vec(CharPtrVec *vec) {
    // VecDeinit will automatically call char_ptr_deinit on each element
    VecDeinit(vec);

In VecCharPtr.c:40:

    }
    
    void fuzz_char_ptr_vec(CharPtrVec *vec, VecCharPtrFunction func, const uint8_t *data, size_t *offset, size_t size) {
    switch (func) {
    case VEC_CHAR_PTR_PUSH_BACK : {

In VecCharPtr.c:110:

    size_t index = extract_u32(data, offset, size) % VecLen(vec);
    char  *str   = VecAt(vec, index);
    (void)str; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:117:

    case VEC_CHAR_PTR_LEN : {
    size_t len = VecLen(vec);
    (void)len; // Use the result to avoid warnings
    break;
    }

In VecCharPtr.c:124:

    if (VecLen(vec) > 0) {
    char *first = VecFirst(vec);
    (void)first; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:132:

    if (VecLen(vec) > 0) {
    char *last = VecLast(vec);
    (void)last; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:180:

    case VEC_CHAR_PTR_SIZE : {
    size_t size_bytes = VecSize(vec);
    (void)size_bytes; // Use the result to avoid warnings
    break;
    }

In VecCharPtr.c:353:

    if (VecLen(vec) > 0) {
    char **begin = VecBegin(vec);
    (void)begin; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:361:

    if (VecLen(vec) > 0) {
    char *end = VecEnd(vec);
    (void)end; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:370:

    size_t index = extract_u32(data, offset, size) % VecLen(vec);
    char **ptr   = VecPtrAt(vec, index);
    (void)ptr; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:423:

    // Note: VecAlignedOffsetAt doesn't take alignment parameter
    size_t offset = VecAlignedOffsetAt(vec, index);
    (void)offset; // Use the result to avoid warnings
    }
    break;

In VecCharPtr.c:470:

    total_len += strlen(str);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:481:

    total_len += strlen(str) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:492:

    total_len += strlen(*str_ptr);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:503:

    total_len += strlen(*str_ptr) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:514:

    total_len += strlen(str);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:525:

    total_len += strlen(str) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:536:

    total_len += strlen(*str_ptr);
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:547:

    total_len += strlen(*str_ptr) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    break;

In VecCharPtr.c:561:

    total_len += strlen(str);
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecCharPtr.c:576:

    total_len += strlen(str) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecCharPtr.c:591:

    total_len += strlen(*str_ptr);
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In VecCharPtr.c:606:

    total_len += strlen(*str_ptr) + idx;
    }
    (void)total_len; // Suppress unused variable warning
    }
    }

In ListInt.c:13:

    
    // Comparator function for sorting integers
    static int compare_ints(const void *a, const void *b) {
    i32 ia = *(const i32 *)a;
    i32 ib = *(const i32 *)b;

In ListInt.c:19:

    }
    
    void init_int_list(IntList *list) {
    *list = ListInitT(*list);
    }

In ListInt.c:23:

    }
    
    void deinit_int_list(IntList *list) {
    ListDeinit(list);
    }

In ListInt.c:27:

    }
    
    void fuzz_int_list(IntList *list, ListIntFunction func, const uint8_t *data, size_t *offset, size_t size) {
    switch (func) {
    case LIST_INT_PUSH_BACK : {

In ListInt.c:88:

    if (idx < list->length) {
    volatile i32 value = ListAt(list, idx);
    (void)value; // Prevent optimization
    }
    break;

In ListInt.c:95:

    case LIST_INT_LEN : {
    volatile uint64_t len = list->length;
    (void)len;
    break;
    }

In ListInt.c:102:

    if (list->length > 0) {
    volatile i32 first = ListFirst(list);
    (void)first;
    }
    break;

In ListInt.c:110:

    if (list->length > 0) {
    volatile i32 last = ListLast(list);
    (void)last;
    }
    break;

In ListInt.c:188:

    if (ptr) {
    volatile i32 val = *ptr;
    (void)val;
    }
    }

In ListInt.c:216:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:227:

    sum += item + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:238:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:249:

    sum += *item_ptr + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:260:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:271:

    sum += item + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:282:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:293:

    sum += *item_ptr + (int)idx;
    }
    (void)sum; // Suppress unused variable warning
    }
    break;

In ListInt.c:307:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In ListInt.c:322:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In ListInt.c:337:

    sum += item;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In ListInt.c:352:

    sum += *item_ptr;
    }
    (void)sum; // Suppress unused variable warning
    }
    }

In ListInt.h:67:

    
    // Function prototypes
    void init_int_list(IntList *list);
    void deinit_int_list(IntList *list);
    void fuzz_int_list(IntList *list, ListIntFunction func, const uint8_t *data, size_t *offset, size_t size);

In ListInt.h:68:

    // Function prototypes
    void init_int_list(IntList *list);
    void deinit_int_list(IntList *list);
    void fuzz_int_list(IntList *list, ListIntFunction func, const uint8_t *data, size_t *offset, size_t size);

In ListInt.h:69:

    void init_int_list(IntList *list);
    void deinit_int_list(IntList *list);
    void fuzz_int_list(IntList *list, ListIntFunction func, const uint8_t *data, size_t *offset, size_t size);
    
    #endif // FUZZ_LIST_INT_H

In VecInt.h:85:

    
    // Function prototypes
    void init_int_vec(IntVec *vec);
    void deinit_int_vec(IntVec *vec);
    void fuzz_int_vec(IntVec *vec, VecIntFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecInt.h:86:

    // Function prototypes
    void init_int_vec(IntVec *vec);
    void deinit_int_vec(IntVec *vec);
    void fuzz_int_vec(IntVec *vec, VecIntFunction func, const uint8_t *data, size_t *offset, size_t size);

In VecInt.h:87:

    void init_int_vec(IntVec *vec);
    void deinit_int_vec(IntVec *vec);
    void fuzz_int_vec(IntVec *vec, VecIntFunction func, const uint8_t *data, size_t *offset, size_t size);
    
    #endif // FUZZ_VEC_INT_H

void

`void`

Description

Usage example (Cross-references)

Tags :

Share :