void

Type
August 22, 2025

Table of Contents

`void`

Description

Type-specific write callback signature

Usage example (Cross-references)

In Types.h:350:

    ///
    /// TAGS: Memory, Deallocation, Safety
    #define FREE(x) ((x) ? free((void *)(x)) : (void)1, (x) = NULL)
    
    ///

In Sys.h:142:

    /// TAGS: System, Process
    ///
    SysProcessId SysGetCurrentProcessId(void);
    
    ///

In Sys.h:164:

    /// TAGS: System, Threading, Synchronization
    ///
    SysMutex *SysMutexCreate(void);
    
    ///

In Sys.h:178:

    /// TAGS: System, Threading, Memory
    ///
    void SysMutexDestroy(SysMutex *m);
    
    ///

In Sys.h:280:

    /// TAGS: System, Process, Memory
    ///
    void SysDestroyProcess(SysProcInfo *proc_info);
    
    ///

In Sys.h:286:

    /// This allows custom handling of abort situations (e.g., for testing).
    ///
    typedef void (*SysAbortCallback)(void);
    
    ///

In Sys.h:299:

    /// TAGS: System, Testing, Callback
    ///
    void SysSetAbortCallback(SysAbortCallback callback);
    
    ///

In Sys.h:311:

    /// TAGS: System, Testing, Control
    ///
    void SysAbort(void);
    
    #endif // MISRA_SYS_H

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 Io.h:99:

    /// TAGS: I/O, Generic, Container
    ///
    typedef const char *(*TypeSpecificReader)(const char *i, FmtInfo *fmt_info, void *data);
    
    ///

In Io.h:114:

    TypeSpecificWriter writer;
    TypeSpecificReader reader;
    void              *data;
    } TypeSpecificIO;

In Io.h:123:

    #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:165:

    _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:166:

    (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:167:

    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)),                                                           \
    u8: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                                 \

In Io.h:168:

    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)),                                                           \
    u8: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                                 \
    u16: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                               \

In Io.h:169:

    const char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                     \
    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    u8: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                                 \
    u16: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                               \
    u32: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                               \

In Io.h:170:

    char *: TO_TYPE_SPECIFIC_IO(Zstr, (void *)&(x)),                                                           \
    u8: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                                 \
    u16: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                               \
    u32: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                               \
    u64: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                               \

In Io.h:171:

    u8: TO_TYPE_SPECIFIC_IO(u8, (void *)&(x)),                                                                 \
    u16: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                               \
    u32: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                               \
    u64: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                               \
    i8: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                                 \

In Io.h:172:

    u16: TO_TYPE_SPECIFIC_IO(u16, (void *)&(x)),                                                               \
    u32: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                               \
    u64: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                               \
    i8: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                                 \
    i16: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                               \

In Io.h:173:

    u32: TO_TYPE_SPECIFIC_IO(u32, (void *)&(x)),                                                               \
    u64: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                               \
    i8: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                                 \
    i16: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                               \
    i32: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                               \

In Io.h:174:

    u64: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                               \
    i8: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                                 \
    i16: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                               \
    i32: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                               \
    i64: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                               \

In Io.h:175:

    i8: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                                 \
    i16: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                               \
    i32: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                               \
    i64: TO_TYPE_SPECIFIC_IO(i64, (void *)&(x)),                                                               \
    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \

In Io.h:176:

    i16: TO_TYPE_SPECIFIC_IO(i16, (void *)&(x)),                                                               \
    i32: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                               \
    i64: 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:177:

    i32: TO_TYPE_SPECIFIC_IO(i32, (void *)&(x)),                                                               \
    i64: 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:178:

    i64: 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)),                                                               \
    size: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                              \

In Io.h:179:

    f32: TO_TYPE_SPECIFIC_IO(f32, (void *)&(x)),                                                               \
    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \
    char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                               \
    size: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                              \
    default: TO_TYPE_SPECIFIC_IO(UnsupportedType, NULL)                                                        \

In Io.h:180:

    f64: TO_TYPE_SPECIFIC_IO(f64, (void *)&(x)),                                                               \
    char: TO_TYPE_SPECIFIC_IO(i8, (void *)&(x)),                                                               \
    size: TO_TYPE_SPECIFIC_IO(u64, (void *)&(x)),                                                              \
    default: TO_TYPE_SPECIFIC_IO(UnsupportedType, NULL)                                                        \
    )

In Io.h:249:

    /// TAGS: Formatting, I/O, File
    ///
    void FReadFmtInternal(FILE *stream, const char *fmtstr, TypeSpecificIO *argv, size argc);
    
    ///

In Io.h:491:

    
    // 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:492:

    // 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:493:

    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:494:

    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:495:

    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:496:

    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:497:

    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:498:

    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:499:

    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:500:

    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:501:

    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:502:

    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:503:

    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:504:

    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 Log.h:20:

    
    // Forward declaration to avoid circular includes
    void SysAbort(void);
    
    ///

In Log.h:99:

    ///
    /// TAGS: Logging, Initialization, System
    void LogInit(bool redirect);
    
    ///

In Log.h:108:

    ///
    /// TAGS: Logging, Cleanup, System
    void LogDeinit(void);
    
    ///

In Log.h:122:

    ///
    /// TAGS: Logging, LowLevel, System
    void LogWrite(LogMessageType type, const char *tag, int line, const char *msg);
    
    #endif // MISRA_STD_LOG_H

In Memory.h:22:

    ///
    /// TAGS: Memory, Comparison, Safety
    i32 MemCompare(const void* p1, const void* p2, size n);
    
    ///

In Memory.h:35:

    ///
    /// TAGS: Memory, Copy, Safety
    void* MemCopy(void* dst, const void* src, size n);
    
    ///

In Memory.h:48:

    ///
    /// TAGS: Memory, Move, Safety
    void* MemMove(void* dst, const void* src, size n);
    
    ///

In Memory.h:61:

    ///
    /// TAGS: Memory, Set, Safety
    void* MemSet(void* dst, i32 val, size n);
    
    ///

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 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 Init.h:123:

    /// str : Pointer to string to be deinited
    ///
    void StrDeinit(Str* str);
    
    ///

In Type.h:35:

    /// FAILURE: `abort`
    ///
    void ValidateStr(const Str* s);
    
    ///

In Type.h:47:

    /// FAILURE: `abort`
    ///
    void ValidateStrs(const Strs* vs);

In Remove.h:30:

    /// TAGS: Remove, BitVec, Range, Multiple
    ///
    void BitVecRemoveRange(BitVec *bv, u64 idx, u64 count);
    
    ///

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 Init.h:76:

    /// TAGS: Deinit, BitVec, Cleanup, Memory
    ///
    void BitVecDeinit(BitVec *bv);
    
    ///

In Init.h:89:

    /// TAGS: Clear, BitVec, Reset
    ///
    void BitVecClear(BitVec *bv);
    
    ///

In Init.h:103:

    /// TAGS: BitVec, Reserve, Capacity, Memory
    ///
    void BitVecReserve(BitVec *bv, u64 n);
    
    ///

In Init.h:117:

    /// 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 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 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 Type.h:51:

    /// FAILURE: `abort`
    ///
    void ValidateBitVec(const BitVec *bv);
    
    #endif // MISRA_STD_CONTAINER_BITVEC_TYPE_H

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 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);

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);
    
    #ifdef __cplusplus

In Insert.h:196:

    }                                                                                                          \
    const VEC_DATATYPE(v) __x = *(varr);                                                                       \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp__ptr = (varr);                                                                    \

In Insert.h:201:

    insert_range_into_vec(GENERIC_VEC(v), (char *)__tmp__ptr, sizeof(VEC_DATATYPE(v)), (idx), (count));            \
    if (!(v)->copy_init) {                                                                                         \
    memset((void *)(varr), 0, (count) * sizeof(*varr));                                                        \
    }                                                                                                              \
    } while (0)

In Insert.h:232:

    }                                                                                                          \
    const VEC_DATATYPE(v) __x = *(varr);                                                                       \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp__ptr = (varr);                                                                    \

In Insert.h:290:

    }                                                                                                          \
    const VEC_DATATYPE(v) __x = *(varr);                                                                       \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp__ptr = (varr);                                                                    \

In Insert.h:295:

    insert_range_fast_into_vec(GENERIC_VEC(v), (char *)__tmp__ptr, sizeof(VEC_DATATYPE(v)), (idx), (count));       \
    if (!(v)->copy_init) {                                                                                         \
    memset((void *)(varr), 0, (count) * sizeof(*varr));                                                        \
    }                                                                                                              \
    } while (0)

In Insert.h:328:

    }                                                                                                          \
    const VEC_DATATYPE(v) __x = *(varr);                                                                       \
    (void)__x;                                                                                                 \
    }                                                                                                              \
    const VEC_DATATYPE(v) *__tmp__ptr = (varr);                                                                    \

In Type.h:22:

    } GenericVec;
    
    #define GENERIC_VEC(x) ((GenericVec *)(void *)(x))
    
    ///

In Type.h:76:

    ///
    #define ValidateVec(v) validate_vec((const GenericVec *)GENERIC_VEC(v))
    void validate_vec(const GenericVec *v);
    
    #endif // MISRA_STD_CONTAINER_VEC_TYPE_H

In Sys.c:302:

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

In Sys.c:353:

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

In Sys.c:363:

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

In Sys.c:753:

    }
    
    void SysDestroyProcess(SysProcInfo* proc_info) {
    if (!proc_info) {
    return;

In Sys.c:771:

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

In Sys.c:775:

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

In Log.c:18:

    static SysMutex *log_mutex = NULL;
    
    void LogInit(bool redirect) {
    if (redirect) {
    // Get the current time

In Log.c:104:

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

In Log.c:115:

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

In Memory.c:10:

    #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:27:

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

In Memory.c:40:

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

In Memory.c:61:

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

In Io.c:22:

    #include <math.h>
    
    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:23:

    
    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:24:

    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:25:

    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:185:

    
    // 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:289:

    // 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:291:

    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:293:

    } 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:294:

    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:296:

    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:297:

    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:502:

    // 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:503:

    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:505:

    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 || read_fn == (void*)_read_f32) {

In Io.c:507:

    } 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;
    } else if (read_fn == (void*)_read_u64 || read_fn == (void*)_read_i64 || read_fn == (void*)_read_f64) {

In Io.c:509:

    } 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 || read_fn == (void*)_read_f64) {
    var_width = 8;
    } else {

In Io.c:592:

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

In Io.c:647:

    // 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:682:

    }
    
    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:776:

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

In Io.c:844:

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

In Io.c:917:

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

In Io.c:961:

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

In Io.c:977:

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

In Io.c:993:

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

In Io.c:1009:

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

In Io.c:1053:

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

In Io.c:1069:

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

In Io.c:1085:

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

In Io.c:1101:

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

In Io.c:1164:

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

In Io.c:2200:

    
    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:2231:

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

In Io.c:2280:

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

In Io.c:2281:

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

In Io.c:2282:

    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:2283:

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

In Io.c:2288:

    
    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:2404:

    
    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:2405:

    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:2522:

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

In Io.c:2530:

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

In Io.c:2559:

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

In Io.c:2594:

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

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 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:1640:

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

In BitVec.c:1654:

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

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:109:

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

In Vec.c:125:

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

In Vec.c:151:

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

In Vec.c:185:

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

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:388:

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

In Str.c:84:

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

In Str.c:224:

    
    // 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:242:

    }
    
    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:247:

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

In Str.c:259:

    }
    
    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:861:

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

In Str.c:865:

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

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 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) {
    printf("Testing simple string writing\n");

In Write.Simple.c:128:

    
    // Test 2: Simple number writing
    bool test_simple_numbers_writing(void) {
    printf("Testing simple number writing\n");

In Write.Simple.c:154:

    
    // Test 3: Simple boolean writing
    bool test_simple_boolean_writing(void) {
    printf("Testing simple boolean writing\n");

In Write.Simple.c:178:

    
    // Test 4: Simple person object writing
    bool test_simple_person_object_writing(void) {
    printf("Testing simple person object writing\n");

In Write.Simple.c:205:

    
    // Test 5: Simple config object writing
    bool test_simple_config_object_writing(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing simple product with tags array writing\n");

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) {
    printf("Testing simple string parsing\n");

In Read.Simple.c:98:

    
    // Test 2: Simple number parsing
    bool test_simple_numbers(void) {
    printf("Testing simple number parsing\n");

In Read.Simple.c:135:

    
    // Test 3: Simple boolean parsing
    bool test_simple_boolean(void) {
    printf("Testing simple boolean parsing\n");

In Read.Simple.c:165:

    
    // Test 4: Simple person object
    bool test_simple_person_object(void) {
    printf("Testing simple person object\n");

In Read.Simple.c:219:

    
    // Test 5: Simple config object
    bool test_simple_config_object(void) {
    printf("Testing simple config object\n");

In Read.Simple.c:260:

    
    // Test 6: Simple array of strings
    bool test_simple_array_of_strings(void) {
    printf("Testing simple array of strings\n");

In Read.Simple.c:321:

    
    // Test 7: Simple nested object (1 level)
    bool test_simple_nested_object(void) {
    printf("Testing simple nested object\n");

In Read.Simple.c:378:

    
    // Test 8: Simple product with tags array
    bool test_simple_product_with_tags(void) {
    printf("Testing simple product with tags array\n");

In Write.EdgeCases.c:56:

    
    // Function prototypes
    bool test_empty_object_writing(void);
    bool test_empty_array_writing(void);
    bool test_empty_string_writing(void);

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);
    bool test_negative_numbers_writing(void);

In Write.EdgeCases.c:58:

    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:59:

    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:60:

    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:61:

    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:62:

    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:63:

    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:64:

    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:65:

    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:66:

    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:67:

    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_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:71:

    
    // Test 1: Empty object writing
    bool test_empty_object_writing(void) {
    printf("Testing empty object writing\n");

In Write.EdgeCases.c:95:

    
    // Test 2: Empty array writing
    bool test_empty_array_writing(void) {
    printf("Testing empty array writing\n");

In Write.EdgeCases.c:121:

    
    // Test 3: Empty string writing
    bool test_empty_string_writing(void) {
    printf("Testing empty string writing\n");

In Write.EdgeCases.c:147:

    
    // Test 4: Negative numbers writing
    bool test_negative_numbers_writing(void) {
    printf("Testing negative numbers writing\n");

In Write.EdgeCases.c:173:

    
    // Test 5: Large numbers writing
    bool test_large_numbers_writing(void) {
    printf("Testing large numbers writing\n");

In Write.EdgeCases.c:204:

    
    // Test 6: Zero values writing
    bool test_zero_values_writing(void) {
    printf("Testing zero values writing\n");

In Write.EdgeCases.c:230:

    
    // Test 7: Special characters writing
    bool test_special_characters_writing(void) {
    printf("Testing special characters writing\n");

In Write.EdgeCases.c:265:

    
    // Test 8: Escape sequences writing
    bool test_escape_sequences_writing(void) {
    printf("Testing escape sequences writing\n");

In Write.EdgeCases.c:303:

    
    // Test 9: Nested empty containers writing
    bool test_nested_empty_containers_writing(void) {
    printf("Testing nested empty containers writing\n");

In Write.EdgeCases.c:342:

    
    // Test 10: Mixed empty and filled containers writing
    bool test_mixed_empty_and_filled_writing(void) {
    printf("Testing mixed empty and filled containers writing\n");

In Write.EdgeCases.c:381:

    
    // Test 11: Boundary integers writing
    bool test_boundary_integers_writing(void) {
    printf("Testing boundary integers writing\n");

In Write.EdgeCases.c:409:

    
    // Test 12: Boundary floats writing
    bool test_boundary_floats_writing(void) {
    printf("Testing boundary floats writing\n");

In Write.EdgeCases.c:440:

    
    // Test 13: Single values writing (minimal valid JSON objects)
    bool test_single_values_writing(void) {
    printf("Testing single values writing\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) {
    printf("Testing empty object reading\n");

In Read.EdgeCases.c:93:

    
    // Test 2: Empty array reading
    bool test_empty_array_reading(void) {
    printf("Testing empty array reading\n");

In Read.EdgeCases.c:148:

    
    // Test 3: Empty string reading
    bool test_empty_string_reading(void) {
    printf("Testing empty string reading\n");

In Read.EdgeCases.c:184:

    
    // Test 4: Negative numbers reading
    bool test_negative_numbers_reading(void) {
    printf("Testing negative numbers reading\n");

In Read.EdgeCases.c:226:

    
    // Test 5: Large numbers reading
    bool test_large_numbers_reading(void) {
    printf("Testing large numbers reading\n");

In Read.EdgeCases.c:269:

    
    // Test 6: Zero values reading
    bool test_zero_values_reading(void) {
    printf("Testing zero values reading\n");

In Read.EdgeCases.c:311:

    
    // Test 7: Special characters in strings
    bool test_special_characters_in_strings(void) {
    printf("Testing special characters in strings\n");

In Read.EdgeCases.c:355:

    
    // Test 8: Escape sequences reading
    bool test_escape_sequences_reading(void) {
    printf("Testing escape sequences reading\n");

In Read.EdgeCases.c:400:

    
    // Test 9: Whitespace variations reading
    bool test_whitespace_variations_reading(void) {
    printf("Testing whitespace variations reading\n");

In Read.EdgeCases.c:444:

    
    // Test 10: Nested empty containers
    bool test_nested_empty_containers(void) {
    printf("Testing nested empty containers\n");

In Read.EdgeCases.c:490:

    
    // Test 11: Mixed empty and filled containers
    bool test_mixed_empty_and_filled(void) {
    printf("Testing mixed empty and filled containers\n");

In Read.EdgeCases.c:551:

    
    // Test 12: Boundary integers
    bool test_boundary_integers(void) {
    printf("Testing boundary integers\n");

In Read.EdgeCases.c:598:

    
    // Test 13: Boundary floats
    bool test_boundary_floats(void) {
    printf("Testing boundary floats\n");

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) {
    printf("Testing two-level nesting writing\n");

In Write.Nested.c:170:

    
    // Test 2: Three-level nesting writing
    bool test_three_level_nesting_writing(void) {
    printf("Testing three-level nesting writing\n");

In Write.Nested.c:218:

    
    // Test 3: Complex API response writing
    bool test_complex_api_response_writing(void) {
    printf("Testing complex API response writing\n");

In Write.Nested.c:290:

    
    // Test 4: Function info array writing
    bool test_function_info_array_writing(void) {
    printf("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) {
    printf("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) {
    printf("Testing dynamic object keys writing\n");

In Write.Nested.c:442:

    
    // Test 7: Deeply nested structure writing
    bool test_deeply_nested_structure_writing(void) {
    printf("Testing deeply nested structure writing\n");

In Write.Nested.c:478:

    
    // Test 8: Mixed array types writing
    bool test_mixed_array_types_writing(void) {
    printf("Testing mixed array types writing\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) {
    printf("Testing simple value round-trip\n");

In RoundTrip.c:155:

    
    // Test 2: Numeric precision round-trip
    bool test_numeric_roundtrip(void) {
    printf("Testing numeric precision round-trip\n");

In RoundTrip.c:227:

    
    // Test 3: Boolean round-trip
    bool test_boolean_roundtrip(void) {
    printf("Testing boolean round-trip\n");

In RoundTrip.c:279:

    
    // Test 4: String round-trip
    bool test_string_roundtrip(void) {
    printf("Testing string round-trip\n");

In RoundTrip.c:346:

    
    // Test 5: Array round-trip
    bool test_array_roundtrip(void) {
    printf("Testing array round-trip\n");

In RoundTrip.c:449:

    
    // Test 6: Nested object round-trip
    bool test_nested_object_roundtrip(void) {
    printf("Testing nested object round-trip\n");

In RoundTrip.c:499:

    
    // Test 7: Complex data round-trip
    bool test_complex_data_roundtrip(void) {
    printf("Testing complex data round-trip\n");

In RoundTrip.c:642:

    
    // Test 8: Empty containers round-trip
    bool test_empty_containers_roundtrip(void) {
    printf("Testing empty containers round-trip\n");

In RoundTrip.c:717:

    
    // Test 9: Edge cases round-trip
    bool test_edge_cases_roundtrip(void) {
    printf("Testing edge cases round-trip\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:90:

    
    // Function prototypes
    bool test_basic_iterator_functionality(void);
    bool test_simple_json_object(void);
    bool test_two_level_nesting(void);

In Read.Nested.c:91:

    // 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:92:

    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:93:

    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:94:

    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:95:

    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:96:

    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:97:

    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:98:

    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:99:

    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:100:

    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:103:

    
    // Test basic iterator functionality
    bool test_basic_iterator_functionality(void) {
    printf("Testing basic iterator functionality\n");

In Read.Nested.c:126:

    
    // Test simple JSON object (1 level)
    bool test_simple_json_object(void) {
    printf("Testing simple JSON object (1 level)\n");

In Read.Nested.c:177:

    
    // Test two-level nesting
    bool test_two_level_nesting(void) {
    printf("Testing two-level nesting\n");

In Read.Nested.c:246:

    
    // Test three-level nesting
    bool test_three_level_nesting(void) {
    printf("Testing three-level nesting\n");

In Read.Nested.c:325:

    
    // Test dynamic key parsing (like your example) - Fixed initialization
    bool test_dynamic_key_parsing(void) {
    printf("Testing dynamic key parsing\n");

In Read.Nested.c:423:

    
    // Test complex API response similar to your example - Fixed initialization
    bool test_complex_api_response(void) {
    printf("Testing complex API response structure\n");

In Read.Nested.c:571:

    
    // Test function info parsing
    bool test_function_info_parsing(void) {
    printf("Testing function info parsing\n");

In Read.Nested.c:618:

    
    // Test model info parsing
    bool test_model_info_parsing(void) {
    printf("Testing model info parsing\n");

In Read.Nested.c:653:

    
    // Test search results with tags - Fixed implementation
    bool test_search_results_with_tags(void) {
    printf("Testing search results with tags\n");

In Read.Nested.c:739:

    
    // Test conditional parsing
    bool test_conditional_parsing(void) {
    printf("Testing conditional parsing\n");

In Read.Nested.c:908:

    
    // Test status response pattern
    bool test_status_response_pattern(void) {
    printf("Testing status response pattern\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) {
    printf("Testing Str type definition\n");

In Str.Type.c:41:

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

In Str.Type.c:71:

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

In Str.Type.c:91:

    
    // Test ValidateStrs macro
    bool test_validate_strs(void) {
    printf("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) {
    printf("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) {
    printf("Testing ValidateStrs with invalid Strs (should abort)\n");

In Str.Type.c:148:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Type 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) {
    printf("Testing StrFromU64\n");

In Str.Convert.c:91:

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

In Str.Convert.c:147:

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

In Str.Convert.c:228:

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

In Str.Convert.c:285:

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

In Str.Convert.c:329:

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

In Str.Convert.c:391:

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

In Str.Convert.c:470:

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

In Str.Convert.c:555:

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

In Str.Convert.c:622:

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

In Str.Convert.c:692:

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

In Str.Convert.c:759:

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

In Str.Convert.c:769:

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

In Str.Convert.c:779:

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

In Str.Convert.c:790:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Convert 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) {
    printf("Testing BitVecForeachIdx macro\n");

In BitVec.Foreach.c:68:

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

In BitVec.Foreach.c:99:

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

In BitVec.Foreach.c:130:

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

In BitVec.Foreach.c:160:

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

In BitVec.Foreach.c:196:

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

In BitVec.Foreach.c:231:

    
    // Edge case tests
    bool test_bitvec_foreach_edge_cases(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecRunLengths basic functionality\n");

In BitVec.Foreach.c:477:

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

In BitVec.Foreach.c:535:

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

In BitVec.Foreach.c:572:

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

In BitVec.Foreach.c:636:

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

In BitVec.Foreach.c:648:

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

In BitVec.Foreach.c:662:

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

In BitVec.Foreach.c:676:

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

In BitVec.Foreach.c:695:

    // with invalid macro usage scenarios
    
    bool test_bitvec_foreach_invalid_usage(void) {
    printf("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) {
    printf("[INFO] Starting BitVec.Foreach tests\n\n");

In Vec.Foreach.Simple.c:11:

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

In Vec.Foreach.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.c:18:

    bool test_vec_foreach_reverse_idx(void);
    bool test_vec_foreach_ptr_reverse(void);
    bool test_vec_foreach_ptr_reverse_idx(void);
    
    // Test VecForeach macro

In Vec.Foreach.Simple.c:21:

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

In Vec.Foreach.Simple.c:56:

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

In Vec.Foreach.Simple.c:88:

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

In Vec.Foreach.Simple.c:125:

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

In Vec.Foreach.Simple.c:154:

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

In Vec.Foreach.Simple.c:185:

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

In Vec.Foreach.Simple.c:212:

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

In Vec.Foreach.Simple.c:244:

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

In Vec.Foreach.Simple.c:277:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.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) {
    printf("Testing VecAt\n");

In Vec.Access.c:50:

    
    // Test VecPtrAt function
    bool test_vec_ptr_at(void) {
    printf("Testing VecPtrAt\n");

In Vec.Access.c:87:

    
    // Test VecFirst and VecLast functions
    bool test_vec_first_last(void) {
    printf("Testing VecFirst and VecLast\n");

In Vec.Access.c:118:

    
    // Test VecBegin and VecEnd functions
    bool test_vec_begin_end(void) {
    printf("Testing VecBegin and VecEnd\n");

In Vec.Access.c:148:

    
    // Test VecSize and VecLen functions
    bool test_vec_size_len(void) {
    printf("Testing VecSize and VecLen\n");

In Vec.Access.c:198:

    
    // Test VecAlignedOffsetAt function
    bool test_vec_aligned_offset_at(void) {
    printf("Testing VecAlignedOffsetAt\n");

In Vec.Access.c:232:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.Access 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) {
    printf("Testing StrTryReduceSpace\n");

In Str.Memory.c:43:

    
    // Test StrSwapCharAt function
    bool test_str_swap_char_at(void) {
    printf("Testing StrSwapCharAt\n");

In Str.Memory.c:65:

    
    // Test StrResize function
    bool test_str_resize(void) {
    printf("Testing StrResize\n");

In Str.Memory.c:91:

    
    // Test StrReserve function
    bool test_str_reserve(void) {
    printf("Testing StrReserve\n");

In Str.Memory.c:116:

    
    // Test StrClear function
    bool test_str_clear(void) {
    printf("Testing StrClear\n");

In Str.Memory.c:138:

    
    // Test StrReverse function
    bool test_str_reverse(void) {
    printf("Testing StrReverse\n");

In Str.Memory.c:184:

    
    // Main function that runs all tests
    int main(void) {
    printf("[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) {
    printf("Testing BitVecInit\n");

In BitVec.Init.c:42:

    
    // Test BitVecDeinit function
    bool test_bitvec_deinit(void) {
    printf("Testing BitVecDeinit\n");

In BitVec.Init.c:70:

    
    // Test BitVecReserve function
    bool test_bitvec_reserve(void) {
    printf("Testing BitVecReserve\n");

In BitVec.Init.c:103:

    
    // Test BitVecClear function
    bool test_bitvec_clear(void) {
    printf("Testing BitVecClear\n");

In BitVec.Init.c:138:

    
    // Test BitVecReu64 function
    bool test_bitvec_resize(void) {
    printf("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) {
    printf("Testing BitVecInit edge cases\n");

In BitVec.Init.c:198:

    }
    
    bool test_bitvec_reserve_edge_cases(void) {
    printf("Testing BitVecReserve edge cases\n");

In BitVec.Init.c:226:

    }
    
    bool test_bitvec_resize_edge_cases(void) {
    printf("Testing BitVecReu64 edge cases\n");

In BitVec.Init.c:262:

    }
    
    bool test_bitvec_clear_edge_cases(void) {
    printf("Testing BitVecClear edge cases\n");

In BitVec.Init.c:293:

    }
    
    bool test_bitvec_multiple_cycles(void) {
    printf("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) {
    printf("Testing BitVec NULL pointer handling\n");

In BitVec.Init.c:328:

    }
    
    bool test_bitvec_invalid_operations(void) {
    printf("Testing BitVec invalid operations\n");

In BitVec.Init.c:343:

    }
    
    bool test_bitvec_set_operations_failures(void) {
    printf("Testing BitVec set operations on invalid indices\n");

In BitVec.Init.c:359:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Init 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) {
    printf("Testing VecPushBack\n");

In Vec.Insert.c:51:

    
    // Test VecPushFront function
    bool test_vec_push_front(void) {
    printf("Testing VecPushFront\n");

In Vec.Insert.c:79:

    
    // Test VecInsert function
    bool test_vec_insert(void) {
    printf("Testing VecInsert\n");

In Vec.Insert.c:114:

    
    // Test VecPushBackArr function
    bool test_vec_push_back_arr(void) {
    printf("Testing VecPushBackArr\n");

In Vec.Insert.c:155:

    
    // Test VecPushFrontArr function
    bool test_vec_push_front_arr(void) {
    printf("Testing VecPushFrontArr\n");

In Vec.Insert.c:196:

    
    // Test VecInsertRange function for inserting at a specific index
    bool test_vec_push_arr(void) {
    printf("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) {
    printf("Testing VecInsertRange from another vector\n");

In Vec.Insert.c:267:

    
    // Test VecMerge function
    bool test_vec_merge(void) {
    printf("Testing VecMerge\n");

In Vec.Insert.c:308:

    
    // Test L-value and R-value operations
    bool test_lvalue_rvalue_operations(void) {
    printf("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) {
    printf("Testing L-value memset after insertion\n");

In Vec.Insert.c:467:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.Insert 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) {
    printf("Testing BitVecShrinkToFit\n");

In BitVec.Memory.c:61:

    
    // Test BitVecReserve function (replacing BitVecSetCapacity)
    bool test_bitvec_set_capacity(void) {
    printf("Testing BitVecReserve\n");

In BitVec.Memory.c:98:

    
    // Test BitVecSwap function
    bool test_bitvec_swap(void) {
    printf("Testing BitVecSwap\n");

In BitVec.Memory.c:142:

    
    // Test BitVecClone function
    bool test_bitvec_clone(void) {
    printf("Testing BitVecClone\n");

In BitVec.Memory.c:188:

    
    // Edge case tests
    bool test_bitvec_shrink_to_fit_edge_cases(void) {
    printf("Testing BitVecShrinkToFit edge cases\n");

In BitVec.Memory.c:219:

    }
    
    bool test_bitvec_set_capacity_edge_cases(void) {
    printf("Testing BitVecReserve edge cases\n");

In BitVec.Memory.c:256:

    }
    
    bool test_bitvec_swap_edge_cases(void) {
    printf("Testing BitVecSwap edge cases\n");

In BitVec.Memory.c:297:

    }
    
    bool test_bitvec_clone_edge_cases(void) {
    printf("Testing BitVecClone edge cases\n");

In BitVec.Memory.c:338:

    }
    
    bool test_bitvec_memory_stress_test(void) {
    printf("Testing BitVec memory stress test\n");

In BitVec.Memory.c:377:

    
    // Deadend tests
    bool test_bitvec_memory_null_failures(void) {
    printf("Testing BitVec memory NULL pointer handling\n");

In BitVec.Memory.c:386:

    }
    
    bool test_bitvec_swap_null_failures(void) {
    printf("Testing BitVec swap NULL handling\n");

In BitVec.Memory.c:398:

    }
    
    bool test_bitvec_clone_null_failures(void) {
    printf("Testing BitVec clone NULL handling\n");

In BitVec.Memory.c:408:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Memory 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) {
    printf("Testing basic Vec type functionality\n");

In Vec.Type.c:50:

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

In Vec.Type.c:70:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.Type 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) {
    printf("Testing VecTryReduceSpace\n");

In Vec.Memory.c:53:

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

In Vec.Memory.c:98:

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

In Vec.Memory.c:142:

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

In Vec.Memory.c:180:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.Memory 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) {
    printf("Testing BitVecGet\n");

In BitVec.Access.Simple.c:53:

    
    // Test BitVecSet function
    bool test_bitvec_set(void) {
    printf("Testing BitVecSet\n");

In BitVec.Access.Simple.c:74:

    
    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
    printf("Testing BitVecFlip\n");

In BitVec.Access.Simple.c:100:

    
    // Test BitVecLength and BitVecCapacity functions
    bool test_bitvec_length_capacity(void) {
    printf("Testing BitVecLength and BitVecCapacity\n");

In BitVec.Access.Simple.c:126:

    
    // Test BitVecCount functions
    bool test_bitvec_count_operations(void) {
    printf("Testing BitVecCount operations\n");

In BitVec.Access.Simple.c:146:

    
    // Edge case tests for BitVecGet
    bool test_bitvec_get_edge_cases(void) {
    printf("Testing BitVecGet edge cases\n");

In BitVec.Access.Simple.c:168:

    
    // Edge case tests for BitVecSet
    bool test_bitvec_set_edge_cases(void) {
    printf("Testing BitVecSet edge cases\n");

In BitVec.Access.Simple.c:187:

    
    // Edge case tests for BitVecFlip
    bool test_bitvec_flip_edge_cases(void) {
    printf("Testing BitVecFlip edge cases\n");

In BitVec.Access.Simple.c:206:

    
    // Edge case tests for BitVecCount
    bool test_bitvec_count_edge_cases(void) {
    printf("Testing BitVecCount edge cases\n");

In BitVec.Access.Simple.c:234:

    
    // Test multiple operations together
    bool test_bitvec_access_multiple_operations(void) {
    printf("Testing BitVec multiple access operations\n");

In BitVec.Access.Simple.c:271:

    
    // Test with large patterns
    bool test_bitvec_access_large_patterns(void) {
    printf("Testing BitVec access with large patterns\n");

In BitVec.Access.Simple.c:306:

    
    // Test macro functions
    bool test_bitvec_macro_functions(void) {
    printf("Testing BitVec macro functions\n");

In BitVec.Access.Simple.c:336:

    
    // Stress test for access operations
    bool test_bitvec_access_stress_test(void) {
    printf("Testing BitVec access stress test\n");

In BitVec.Access.Simple.c:386:

    
    // Comprehensive bit pattern testing
    bool test_bitvec_bit_patterns_comprehensive(void) {
    printf("Testing BitVec comprehensive bit patterns\n");

In BitVec.Access.Simple.c:440:

    
    // Test BitVecFind functions (Find, FindLast)
    bool test_bitvec_find_functions(void) {
    printf("Testing BitVecFind functions\n");

In BitVec.Access.Simple.c:474:

    
    // Test BitVec predicate functions (All, Any, None)
    bool test_bitvec_predicate_functions(void) {
    printf("Testing BitVec predicate functions\n");

In BitVec.Access.Simple.c:521:

    
    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
    printf("Testing BitVecLongestRun\n");

In BitVec.Access.Simple.c:558:

    
    // Edge case tests for Find functions
    bool test_bitvec_find_edge_cases(void) {
    printf("Testing BitVecFind edge cases\n");

In BitVec.Access.Simple.c:590:

    
    // Edge case tests for predicate functions
    bool test_bitvec_predicate_edge_cases(void) {
    printf("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) {
    printf("Testing BitVecLongestRun edge cases\n");

In BitVec.Access.Simple.c:663:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Access.Simple 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) {
    printf("Testing BitVecFind deadend scenarios\n");

In BitVec.Access.Deadend.c:36:

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

In BitVec.Access.Deadend.c:45:

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

In BitVec.Access.Deadend.c:55:

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

In BitVec.Access.Deadend.c:64:

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

In BitVec.Access.Deadend.c:73:

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

In BitVec.Access.Deadend.c:82:

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

In BitVec.Access.Deadend.c:94:

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

In BitVec.Access.Deadend.c:106:

    }
    
    bool test_bitvec_flip_bounds_failures(void) {
    printf("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) {
    printf("Testing BitVec get with large out-of-bounds index\n");

In BitVec.Access.Deadend.c:134:

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

In BitVec.Access.Deadend.c:148:

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

In BitVec.Access.Deadend.c:163:

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

In BitVec.Access.Deadend.c:172:

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

In BitVec.Access.Deadend.c:186:

    
    // Main function that runs all deadend tests
    int main(void) {
    printf("[INFO] Starting BitVec.Access.Deadend 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) {
    printf("Testing BitVecPush\n");

In BitVec.Insert.c:52:

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

In BitVec.Insert.c:87:

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

In BitVec.Insert.c:114:

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

In BitVec.Insert.c:148:

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

In BitVec.Insert.c:193:

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

In BitVec.Insert.c:221:

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

In BitVec.Insert.c:254:

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

In BitVec.Insert.c:280:

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

In BitVec.Insert.c:289:

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

In BitVec.Insert.c:301:

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

In BitVec.Insert.c:311:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Insert 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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
    BitVec prefix = BitVecInit();

In BitVec.Pattern.Deadend.c:161:

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

In BitVec.Pattern.Deadend.c:170:

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

In BitVec.Pattern.Deadend.c:179:

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

In BitVec.Pattern.Deadend.c:188:

    }
    
    bool test_bitvec_contains_at_null_source(void) {
    printf("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) {
    printf("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.Deadend.c:206:

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

In BitVec.Pattern.Deadend.c:214:

    }
    
    bool test_bitvec_matches_null_source(void) {
    printf("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) {
    printf("Testing BitVecRegexMatch(NULL, pattern) - should fatal\n");
    BitVecRegexMatch(NULL, "101");

In BitVec.Pattern.Deadend.c:232:

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

In BitVec.Pattern.Deadend.c:241:

    }
    
    bool test_bitvec_prefix_match_null_source(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("[INFO] Starting BitVec.Pattern.Deadend 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) {
    printf("Testing BitVecPop\n");

In BitVec.Remove.c:61:

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

In BitVec.Remove.c:97:

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

In BitVec.Remove.c:126:

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

In BitVec.Remove.c:163:

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

In BitVec.Remove.c:201:

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

In BitVec.Remove.c:238:

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

In BitVec.Remove.c:263:

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

In BitVec.Remove.c:288:

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

In BitVec.Remove.c:318:

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

In BitVec.Remove.c:354:

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

In BitVec.Remove.c:390:

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

In BitVec.Remove.c:399:

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

In BitVec.Remove.c:408:

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

In BitVec.Remove.c:420:

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

In BitVec.Remove.c:432:

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

In BitVec.Remove.c:444:

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

In BitVec.Remove.c:457:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Remove 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) {
    printf("Testing vector initialization with complex structure\n");

In Vec.Complex.c:180:

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

In Vec.Complex.c:224:

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

In Vec.Complex.c:267:

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

In Vec.Complex.c:345:

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

In Vec.Complex.c:393:

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

In Vec.Complex.c:470:

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

In Vec.Complex.c:561:

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

In Vec.Complex.c:623:

    
    // Test VecPushBackL memset behavior with complex structures
    bool test_lvalue_memset_pushback(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing array operations with L-value semantics\n");

In Vec.Complex.c:856:

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

In Vec.Foreach.Deadend.c:11:

    
    // Deadend test prototypes (tests that should crash due to out-of-bounds access)
    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.Deadend.c:12:

    // Deadend test prototypes (tests that should crash due to out-of-bounds access)
    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.Deadend.c:13:

    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.Deadend.c:14:

    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.Deadend.c:15:

    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.Deadend.c:16:

    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.Deadend.c:17:

    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);
    
    // Deadend test: Make idx go out of bounds during VecForeach by modifying vector during iteration

In Vec.Foreach.Deadend.c:20:

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

In Vec.Foreach.Deadend.c:52:

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

In Vec.Foreach.Deadend.c:84:

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

In Vec.Foreach.Deadend.c:117:

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

In Vec.Foreach.Deadend.c:149:

    
    // Deadend test: 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) {
    printf("Testing VecForeachPtrReverseIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.Deadend.c:180:

    
    // Deadend test: 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) {
    printf("Testing VecForeachPtrInRangeIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.Deadend.c:216:

    
    // Deadend test: 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) {
    printf("Testing basic VecForeachIdx where idx goes out of bounds (should crash)\n");

In Vec.Foreach.Deadend.c:248:

    
    // Main function that runs all deadend tests
    int main(void) {
    printf("[INFO] Starting Vec.Foreach.Deadend 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) {
    printf("Testing StrInsertCharAt\n");

In Str.Insert.c:57:

    
    // Test StrInsertCstr function
    bool test_str_insert_cstr(void) {
    printf("Testing StrInsertCstr\n");

In Str.Insert.c:73:

    
    // Test StrInsertZstr function
    bool test_str_insert_zstr(void) {
    printf("Testing StrInsertZstr\n");

In Str.Insert.c:89:

    
    // Test StrInsert function
    bool test_str_insert(void) {
    printf("Testing StrInsert\n");

In Str.Insert.c:107:

    
    // Test StrPushCstr function
    bool test_str_push_cstr(void) {
    printf("Testing StrPushCstr\n");

In Str.Insert.c:123:

    
    // Test StrPushZstr function
    bool test_str_push_zstr(void) {
    printf("Testing StrPushZstr\n");

In Str.Insert.c:139:

    
    // Test StrPushBackCstr function
    bool test_str_push_back_cstr(void) {
    printf("Testing StrPushBackCstr\n");

In Str.Insert.c:155:

    
    // Test StrPushBackZstr function
    bool test_str_push_back_zstr(void) {
    printf("Testing StrPushBackZstr\n");

In Str.Insert.c:171:

    
    // Test StrPushFrontCstr function
    bool test_str_push_front_cstr(void) {
    printf("Testing StrPushFrontCstr\n");

In Str.Insert.c:187:

    
    // Test StrPushFrontZstr function
    bool test_str_push_front_zstr(void) {
    printf("Testing StrPushFrontZstr\n");

In Str.Insert.c:203:

    
    // Test StrPushBack function
    bool test_str_push_back(void) {
    printf("Testing StrPushBack\n");

In Str.Insert.c:224:

    
    // Test StrPushFront function
    bool test_str_push_front(void) {
    printf("Testing StrPushFront\n");

In Str.Insert.c:245:

    
    // Test StrMergeL function
    bool test_str_merge_l(void) {
    printf("Testing StrMergeL\n");

In Str.Insert.c:270:

    
    // Test StrMergeR function
    bool test_str_merge_r(void) {
    printf("Testing StrMergeR\n");

In Str.Insert.c:291:

    
    // Test StrMerge function (alias for StrMergeR)
    bool test_str_merge(void) {
    printf("Testing StrMerge\n");

In Str.Insert.c:312:

    
    // Test StrAppendf function
    bool test_str_appendf(void) {
    printf("Testing StrAppendf\n");

In Str.Insert.c:328:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Insert 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) {
    printf("Testing StrPopBack\n");

In Str.Remove.c:44:

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

In Str.Remove.c:68:

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

In Str.Remove.c:92:

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

In Str.Remove.c:119:

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

In Str.Remove.c:141:

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

In Str.Remove.c:163:

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

In Str.Remove.c:185:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Remove 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) {
    printf("Testing VecPopBack\n");

In Vec.Remove.c:76:

    
    // Test VecPopFront function
    bool test_vec_pop_front(void) {
    printf("Testing VecPopFront\n");

In Vec.Remove.c:124:

    
    // Test VecDelete function
    bool test_vec_delete(void) {
    printf("Testing VecDelete\n");

In Vec.Remove.c:172:

    
    // Test VecDeleteFast function
    bool test_vec_delete_fast(void) {
    printf("Testing VecDeleteFast\n");

In Vec.Remove.c:209:

    
    // Test VecDeleteRange function
    bool test_vec_delete_range(void) {
    printf("Testing VecDeleteRange\n");

In Vec.Remove.c:245:

    
    // Test VecDeleteRangeFast
    bool test_vec_delete_range_fast(void) {
    printf("Testing VecDeleteRangeFast\n");

In Vec.Remove.c:321:

    
    // Test VecDeleteLast function
    bool test_vec_delete_last(void) {
    printf("Testing VecDeleteLast\n");

In Vec.Remove.c:367:

    
    // Test L-value standard delete operations
    bool test_lvalue_delete_operations(void) {
    printf("Testing L-value standard delete operations\n");

In Vec.Remove.c:403:

    
    // Test R-value standard delete operations
    bool test_rvalue_delete_operations(void) {
    printf("Testing R-value standard delete operations\n");

In Vec.Remove.c:438:

    
    // Test L-value fast delete operations
    bool test_lvalue_fast_delete_operations(void) {
    printf("Testing L-value fast delete operations\n");

In Vec.Remove.c:514:

    
    // Test R-value fast delete operations
    bool test_rvalue_fast_delete_operations(void) {
    printf("Testing R-value fast delete operations\n");

In Vec.Remove.c:591:

    
    // Test L-value delete range operations
    bool test_lvalue_delete_range_operations(void) {
    printf("Testing L-value delete range operations\n");

In Vec.Remove.c:628:

    
    // Test R-value delete range operations
    bool test_rvalue_delete_range_operations(void) {
    printf("Testing R-value delete range operations\n");

In Vec.Remove.c:663:

    
    // Test L-value fast delete range operations
    bool test_lvalue_fast_delete_range_operations(void) {
    printf("Testing L-value fast delete range operations\n");

In Vec.Remove.c:742:

    
    // Test R-value fast delete range operations
    bool test_rvalue_fast_delete_range_operations(void) {
    printf("Testing R-value fast delete range operations\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) {
    printf("Testing BitVecAnd\n");

In BitVec.BitWise.c:70:

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

In BitVec.BitWise.c:108:

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

In BitVec.BitWise.c:146:

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

In BitVec.BitWise.c:176:

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

In BitVec.BitWise.c:217:

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

In BitVec.BitWise.c:251:

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

In BitVec.BitWise.c:279:

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

In BitVec.BitWise.c:307:

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

In BitVec.BitWise.c:335:

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

In BitVec.BitWise.c:371:

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

In BitVec.BitWise.c:399:

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

In BitVec.BitWise.c:438:

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

In BitVec.BitWise.c:472:

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

In BitVec.BitWise.c:538:

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

In BitVec.BitWise.c:604:

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

In BitVec.BitWise.c:666:

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

In BitVec.BitWise.c:760:

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

In BitVec.BitWise.c:822:

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

In BitVec.BitWise.c:883:

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

In BitVec.BitWise.c:892:

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

In BitVec.BitWise.c:906:

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

In BitVec.BitWise.c:916:

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

In BitVec.BitWise.c:925:

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

In BitVec.BitWise.c:934:

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

In BitVec.BitWise.c:950:

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

In BitVec.BitWise.c:964:

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

In BitVec.BitWise.c:978:

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

In BitVec.BitWise.c:991:

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

In Str.Foreach.Deadend.c:10:

    
    // Deadend test prototypes (tests that should crash due to out-of-bounds access)
    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.Deadend.c:11:

    // Deadend test prototypes (tests that should crash due to out-of-bounds access)
    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.Deadend.c:12:

    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.Deadend.c:13:

    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.Deadend.c:14:

    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.Deadend.c:15:

    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.Deadend.c:16:

    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);
    
    // Deadend test: Make idx go out of bounds in StrForeachInRangeIdx by shrinking string during iteration

In Str.Foreach.Deadend.c:19:

    
    // Deadend test: Make idx go out of bounds in StrForeachInRangeIdx by shrinking string during iteration
    bool test_str_foreach_out_of_bounds_access(void) {
    printf("Testing StrForeachInRangeIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:52:

    
    // Deadend test: Make idx go out of bounds in StrForeachInRangeIdx by deleting characters
    bool test_str_foreach_idx_out_of_bounds_access(void) {
    printf("Testing StrForeachInRangeIdx with character deletion where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:85:

    
    // Deadend test: Make idx go out of bounds in StrForeachReverseIdx by modifying string during iteration
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void) {
    printf("Testing StrForeachReverseIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:112:

    
    // Deadend test: Make idx go out of bounds in StrForeachPtrIdx by modifying string during iteration
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void) {
    printf("Testing StrForeachPtrIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:138:

    
    // Deadend test: 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) {
    printf("Testing StrForeachReversePtrIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:163:

    
    // Deadend test: 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) {
    printf("Testing StrForeachPtrInRangeIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:193:

    
    // Deadend test: 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) {
    printf("Testing basic StrForeachIdx where idx goes out of bounds (should crash)\n");

In Str.Foreach.Deadend.c:219:

    
    // Main function that runs all deadend tests
    int main(void) {
    printf("[INFO] Starting Str.Foreach.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) {
    printf("Testing basic formatting\n");

In Io.Write.c:60:

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

In Io.Write.c:102:

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

In Io.Write.c:175:

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

In Io.Write.c:194:

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

In Io.Write.c:209:

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

In Io.Write.c:224:

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

In Io.Write.c:244:

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

In Io.Write.c:269:

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

In Io.Write.c:296:

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

In Io.Write.c:334:

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

In Io.Write.c:357:

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

In Io.Write.c:549:

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

In Io.Write.c:636:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting format writer 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) {
    printf("Testing VecInit\n");

In Vec.Init.c:72:

    
    // Test aligned vector initialization
    bool test_vec_init_aligned(void) {
    printf("Testing VecInitAligned\n");

In Vec.Init.c:102:

    
    // Test vector initialization with deep copy functions
    bool test_vec_init_with_deep_copy(void) {
    printf("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) {
    printf("Testing VecInitAlignedWithDeepCopy\n");

In Vec.Init.c:140:

    
    // Test vector stack initialization
    bool test_vec_init_stack(void) {
    printf("Testing VecInitStack\n");

In Vec.Init.c:212:

    
    // Test vector clone initialization
    bool test_vec_init_clone(void) {
    printf("Testing vector cloning\n");

In Vec.Init.c:253:

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

In Str.Foreach.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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.Simple.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);
    
    // Test StrForeachIdx macro

In Str.Foreach.Simple.c:25:

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

In Str.Foreach.Simple.c:43:

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

In Str.Foreach.Simple.c:79:

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

In Str.Foreach.Simple.c:108:

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

In Str.Foreach.Simple.c:151:

    
    // Test StrForeach macro
    bool test_str_foreach(void) {
    printf("Testing StrForeach\n");

In Str.Foreach.Simple.c:172:

    
    // Test StrForeachReverse macro
    bool test_str_foreach_reverse(void) {
    printf("Testing StrForeachReverse\n");

In Str.Foreach.Simple.c:203:

    
    // Test StrForeachPtr macro
    bool test_str_foreach_ptr(void) {
    printf("Testing StrForeachPtr\n");

In Str.Foreach.Simple.c:232:

    
    // Test StrForeachPtrReverse macro
    bool test_str_foreach_ptr_reverse(void) {
    printf("Testing StrForeachPtrReverse\n");

In Str.Foreach.Simple.c:271:

    
    // Test StrForeachInRangeIdx macro
    bool test_str_foreach_in_range_idx(void) {
    printf("Testing StrForeachInRangeIdx\n");

In Str.Foreach.Simple.c:303:

    
    // Test StrForeachInRange macro
    bool test_str_foreach_in_range(void) {
    printf("Testing StrForeachInRange\n");

In Str.Foreach.Simple.c:335:

    
    // Test StrForeachPtrInRangeIdx macro
    bool test_str_foreach_ptr_in_range_idx(void) {
    printf("Testing StrForeachPtrInRangeIdx\n");

In Str.Foreach.Simple.c:364:

    
    // Test StrForeachPtrInRange macro
    bool test_str_foreach_ptr_in_range(void) {
    printf("Testing StrForeachPtrInRange\n");

In Str.Foreach.Simple.c:393:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Foreach.Simple 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) {
    printf("Testing BitVecAnd\n");

In BitVec.BitWise.Simple.c:70:

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

In BitVec.BitWise.Simple.c:108:

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

In BitVec.BitWise.Simple.c:146:

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

In BitVec.BitWise.Simple.c:176:

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

In BitVec.BitWise.Simple.c:217:

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

In BitVec.BitWise.Simple.c:251:

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

In BitVec.BitWise.Simple.c:279:

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

In BitVec.BitWise.Simple.c:307:

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

In BitVec.BitWise.Simple.c:335:

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

In BitVec.BitWise.Simple.c:371:

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

In BitVec.BitWise.Simple.c:399:

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

In BitVec.BitWise.Simple.c:438:

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

In BitVec.BitWise.Simple.c:472:

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

In BitVec.BitWise.Simple.c:538:

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

In BitVec.BitWise.Simple.c:604:

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

In BitVec.BitWise.Simple.c:666:

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

In BitVec.BitWise.Simple.c:760:

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

In BitVec.BitWise.Simple.c:822:

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

In BitVec.BitWise.Simple.c:892:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.BitWise 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) {
    printf("Testing StrFirst\n");

In Str.Access.c:35:

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

In Str.Access.c:51:

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

In Str.Access.c:67:

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

In Str.Access.c:83:

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

In Str.Access.c:104:

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

In Str.Access.c:128:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.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) {
    printf("Testing BitVecToStr\n");

In BitVec.Convert.c:63:

    
    // Test BitVecFromStr function
    bool test_bitvec_from_string(void) {
    printf("Testing BitVecFromStr\n");

In BitVec.Convert.c:89:

    
    // Test BitVecToBytes function
    bool test_bitvec_to_bytes(void) {
    printf("Testing BitVecToBytes\n");

In BitVec.Convert.c:121:

    
    // Test BitVecFromBytes function
    bool test_bitvec_from_bytes(void) {
    printf("Testing BitVecFromBytes\n");

In BitVec.Convert.c:154:

    
    // Test BitVecToInteger function
    bool test_bitvec_to_integer(void) {
    printf("Testing BitVecToInteger\n");

In BitVec.Convert.c:190:

    
    // Test BitVecFromInteger function
    bool test_bitvec_from_integer(void) {
    printf("Testing BitVecFromInteger\n");

In BitVec.Convert.c:237:

    
    // Edge case tests
    bool test_bitvec_convert_edge_cases(void) {
    printf("Testing BitVec convert edge cases\n");

In BitVec.Convert.c:268:

    }
    
    bool test_bitvec_from_string_edge_cases(void) {
    printf("Testing BitVecFromStr edge cases\n");

In BitVec.Convert.c:300:

    }
    
    bool test_bitvec_bytes_conversion_edge_cases(void) {
    printf("Testing BitVec bytes conversion edge cases\n");

In BitVec.Convert.c:327:

    }
    
    bool test_bitvec_integer_conversion_edge_cases(void) {
    printf("Testing BitVec integer conversion edge cases\n");

In BitVec.Convert.c:352:

    
    // Round-trip conversion tests
    bool test_bitvec_round_trip_conversions(void) {
    printf("Testing BitVec round-trip conversions\n");

In BitVec.Convert.c:411:

    
    // Bounds checking tests
    bool test_bitvec_conversion_bounds_checking(void) {
    printf("Testing BitVec conversion bounds checking\n");

In BitVec.Convert.c:456:

    
    // Comprehensive conversion validation
    bool test_bitvec_conversion_comprehensive(void) {
    printf("Testing BitVec comprehensive conversion validation\n");

In BitVec.Convert.c:523:

    
    // Large-scale conversion tests
    bool test_bitvec_large_scale_conversions(void) {
    printf("Testing BitVec large-scale conversions\n");

In BitVec.Convert.c:606:

    
    // Enhanced deadend tests
    bool test_bitvec_bytes_bounds_failures(void) {
    printf("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) {
    printf("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) {
    printf("Testing BitVec convert NULL pointer handling\n");

In BitVec.Convert.c:649:

    }
    
    bool test_bitvec_from_string_null_failures(void) {
    printf("Testing BitVec from string NULL handling\n");

In BitVec.Convert.c:658:

    }
    
    bool test_bitvec_bytes_null_failures(void) {
    printf("Testing BitVec bytes NULL handling\n");

In BitVec.Convert.c:668:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Convert 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) {
    printf("Testing StrInit\n");

In Str.Init.c:39:

    
    // Test StrInitFromCstr function
    bool test_str_init_from_cstr(void) {
    printf("Testing StrInitFromCstr\n");

In Str.Init.c:57:

    
    // Test StrInitFromZstr function
    bool test_str_init_from_zstr(void) {
    printf("Testing StrInitFromZstr\n");

In Str.Init.c:74:

    
    // Test StrInitFromStr function
    bool test_str_init_from_str(void) {
    printf("Testing StrInitFromStr\n");

In Str.Init.c:93:

    
    // Test StrDup function (alias for StrInitFromStr)
    bool test_str_dup(void) {
    printf("Testing StrDup\n");

In Str.Init.c:112:

    
    // Test StrPrintf function
    bool test_str_printf(void) {
    printf("Testing StrPrintf\n");

In Str.Init.c:129:

    
    // Test StrInitStack macro
    bool test_str_init_stack(void) {
    printf("Testing StrInitStack\n");

In Str.Init.c:163:

    
    // Test StrInitCopy function
    bool test_str_init_copy(void) {
    printf("Testing StrInitCopy\n");

In Str.Init.c:185:

    
    // Test StrDeinit function
    bool test_str_deinit(void) {
    printf("Testing StrDeinit\n");

In Str.Init.c:204:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Str.Init 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) {
    printf("Testing integer decimal reading\n");

In Io.Read.c:125:

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

In Io.Read.c:155:

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

In Io.Read.c:177:

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

In Io.Read.c:203:

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

In Io.Read.c:240:

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

In Io.Read.c:278:

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

In Io.Read.c:305:

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

In Io.Read.c:337:

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

In Io.Read.c:365:

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

In Io.Read.c:528:

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

In Io.Read.c:658:

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

In Io.Read.c:726:

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

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) {
    printf("Testing basic BitVec type functionality\n");

In BitVec.Type.c:31:

    
    // Test ValidateBitVec macro
    bool test_bitvec_validate(void) {
    printf("Testing ValidateBitVec macro\n");

In BitVec.Type.c:50:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Type 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) {
    printf("Testing VecSwapItems\n");

In Vec.Ops.c:64:

    
    // Test VecReverse function
    bool test_vec_reverse(void) {
    printf("Testing VecReverse\n");

In Vec.Ops.c:116:

    
    // Test VecSort function
    bool test_vec_sort(void) {
    printf("Testing VecSort\n");

In Vec.Ops.c:155:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting Vec.Ops 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) {
    printf("Testing BitVecForeachIdx macro\n");

In BitVec.Foreach.Simple.c:68:

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

In BitVec.Foreach.Simple.c:99:

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

In BitVec.Foreach.Simple.c:130:

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

In BitVec.Foreach.Simple.c:160:

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

In BitVec.Foreach.Simple.c:196:

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

In BitVec.Foreach.Simple.c:231:

    
    // Edge case tests
    bool test_bitvec_foreach_edge_cases(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecRunLengths basic functionality\n");

In BitVec.Foreach.Simple.c:477:

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

In BitVec.Foreach.Simple.c:535:

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

In BitVec.Foreach.Simple.c:572:

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

In BitVec.Foreach.Simple.c:635:

    
    // Main function that runs all simple tests
    int main(void) {
    printf("[INFO] Starting BitVec.Foreach.Simple 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) {
    printf("Testing StrCmp and StrCmpCstr\n");

In Str.Ops.c:55:

    
    // Test string find functions
    bool test_str_find(void) {
    printf("Testing StrFindStr, StrFindZstr, and StrFindCstr\n");

In Str.Ops.c:91:

    
    // Test string starts/ends with functions
    bool test_str_starts_ends_with(void) {
    printf("Testing StrStartsWith and StrEndsWith variants\n");

In Str.Ops.c:127:

    
    // Test string replace functions
    bool test_str_replace(void) {
    printf("Testing StrReplace variants\n");

In Str.Ops.c:162:

    
    // Test string split functions
    bool test_str_split(void) {
    printf("Testing StrSplit and StrSplitToIters\n");

In Str.Ops.c:208:

    
    // Test string strip functions
    bool test_str_strip(void) {
    printf("Testing StrStrip variants\n");

In Str.Ops.c:248:

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

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) {
    printf("Testing basic BitVec pattern functions\n");

In BitVec.Pattern.Simple.c:92:

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

In BitVec.Pattern.Simple.c:139:

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

In BitVec.Pattern.Simple.c:184:

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

In BitVec.Pattern.Simple.c:242:

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

In BitVec.Pattern.Simple.c:311:

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

In BitVec.Pattern.Simple.c:354:

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

In BitVec.Pattern.Simple.c:389:

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

In BitVec.Pattern.Simple.c:421:

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

In BitVec.Pattern.Simple.c:456:

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

In BitVec.Pattern.Simple.c:479:

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

In BitVec.Pattern.Simple.c:516:

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

In BitVec.Pattern.Simple.c:546:

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

In BitVec.Pattern.Simple.c:570:

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

In BitVec.Pattern.Simple.c:605:

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

In BitVec.Pattern.Simple.c:642:

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

In BitVec.Pattern.Simple.c:684:

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

In BitVec.Pattern.Simple.c:721:

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

In BitVec.Pattern.Simple.c:756:

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

In BitVec.Pattern.Simple.c:792:

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

In BitVec.Pattern.Simple.c:815:

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

In BitVec.Pattern.Simple.c:860:

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

In BitVec.Pattern.Simple.c:905:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Pattern.Simple 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) {
    printf("Testing BitVecHammingDistance basic functionality\n");

In BitVec.Math.c:94:

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

In BitVec.Math.c:124:

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

In BitVec.Math.c:173:

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

In BitVec.Math.c:199:

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

In BitVec.Math.c:234:

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

In BitVec.Math.c:264:

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

In BitVec.Math.c:301:

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

In BitVec.Math.c:328:

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

In BitVec.Math.c:371:

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

In BitVec.Math.c:399:

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

In BitVec.Math.c:435:

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

In BitVec.Math.c:463:

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

In BitVec.Math.c:492:

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

In BitVec.Math.c:512:

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

In BitVec.Math.c:545:

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

In BitVec.Math.c:572:

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

In BitVec.Math.c:602:

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

In BitVec.Math.c:627:

    
    // Stress test for Math functions
    bool test_bitvec_math_stress_tests(void) {
    printf("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) {
    printf("Testing BitVecHammingDistance(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:688:

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

In BitVec.Math.c:697:

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

In BitVec.Math.c:706:

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

In BitVec.Math.c:715:

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

In BitVec.Math.c:724:

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

In BitVec.Math.c:733:

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

In BitVec.Math.c:742:

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

In BitVec.Math.c:751:

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

In BitVec.Math.c:760:

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

In BitVec.Math.c:769:

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

In BitVec.Math.c:778:

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

In BitVec.Math.c:787:

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

In BitVec.Math.c:793:

    }
    
    bool test_bitvec_alignment_score_null_bv1(void) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecBestAlignment(NULL, bv2) - should fatal\n");
    BitVec bv2 = BitVecInit();

In BitVec.Math.c:820:

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

In BitVec.Math.c:830:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Math 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) {
    printf("Testing basic BitVec pattern functions\n");

In BitVec.Pattern.c:92:

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

In BitVec.Pattern.c:139:

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

In BitVec.Pattern.c:184:

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

In BitVec.Pattern.c:242:

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

In BitVec.Pattern.c:311:

    
    // Stress tests with large data
    bool test_bitvec_pattern_stress_tests(void) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");

In BitVec.Pattern.c:470:

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

In BitVec.Pattern.c:505:

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

In BitVec.Pattern.c:537:

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

In BitVec.Pattern.c:572:

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

In BitVec.Pattern.c:595:

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

In BitVec.Pattern.c:632:

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

In BitVec.Pattern.c:662:

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

In BitVec.Pattern.c:686:

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

In BitVec.Pattern.c:721:

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

In BitVec.Pattern.c:758:

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

In BitVec.Pattern.c:800:

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

In BitVec.Pattern.c:837:

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

In BitVec.Pattern.c:872:

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

In BitVec.Pattern.c:908:

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

In BitVec.Pattern.c:931:

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

In BitVec.Pattern.c:977:

    
    // BitVecSuffixMatch tests
    bool test_bitvec_suffix_match_basic(void) {
    printf("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) {
    printf("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
    BitVec prefix = BitVecInit();

In BitVec.Pattern.c:1033:

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

In BitVec.Pattern.c:1042:

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

In BitVec.Pattern.c:1051:

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

In BitVec.Pattern.c:1060:

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

In BitVec.Pattern.c:1069:

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

In BitVec.Pattern.c:1078:

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

In BitVec.Pattern.c:1086:

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

In BitVec.Pattern.c:1098:

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

In BitVec.Pattern.c:1104:

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

In BitVec.Pattern.c:1113:

    }
    
    bool test_bitvec_prefix_match_null_source(void) {
    printf("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) {
    printf("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();

In BitVec.Pattern.c:1131:

    }
    
    bool test_bitvec_suffix_match_null_source(void) {
    printf("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) {
    printf("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) {
    printf("[INFO] Starting BitVec.Pattern 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) {
    printf("Testing BitVec bitwise NULL pointer handling\n");

In BitVec.BitWise.Deadend.c:31:

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

In BitVec.BitWise.Deadend.c:45:

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

In BitVec.BitWise.Deadend.c:55:

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

In BitVec.BitWise.Deadend.c:64:

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

In BitVec.BitWise.Deadend.c:73:

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

In BitVec.BitWise.Deadend.c:89:

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

In BitVec.BitWise.Deadend.c:103:

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

In BitVec.BitWise.Deadend.c:117:

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

In BitVec.BitWise.Deadend.c:130:

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

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) {
    printf("Testing BitVecRunLengths with NULL bitvector\n");

In BitVec.Foreach.Deadend.c:31:

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

In BitVec.Foreach.Deadend.c:45:

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

In BitVec.Foreach.Deadend.c:59:

    }
    
    bool test_bitvec_run_lengths_zero_max_runs(void) {
    printf("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) {
    printf("Testing BitVec foreach with invalid bitvec\n");

In BitVec.Foreach.Deadend.c:87:

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

In BitVec.Foreach.Deadend.c:92:

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

In BitVec.Foreach.Deadend.c:97:

    
    // Main function that runs all deadend tests
    int main(void) {
    printf("[INFO] Starting BitVec.Foreach.Deadend 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) {
    printf("Testing BitVecGet\n");

In BitVec.Access.c:59:

    
    // Test BitVecSet function
    bool test_bitvec_set(void) {
    printf("Testing BitVecSet\n");

In BitVec.Access.c:89:

    
    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
    printf("Testing BitVecFlip\n");

In BitVec.Access.c:126:

    
    // Test length and capacity operations
    bool test_bitvec_length_capacity(void) {
    printf("Testing BitVec length and capacity operations\n");

In BitVec.Access.c:157:

    
    // Test count operations
    bool test_bitvec_count_operations(void) {
    printf("Testing BitVec count operations\n");

In BitVec.Access.c:191:

    
    // Edge case tests
    bool test_bitvec_get_edge_cases(void) {
    printf("Testing BitVecGet edge cases\n");

In BitVec.Access.c:214:

    }
    
    bool test_bitvec_set_edge_cases(void) {
    printf("Testing BitVecSet edge cases\n");

In BitVec.Access.c:234:

    }
    
    bool test_bitvec_flip_edge_cases(void) {
    printf("Testing BitVecFlip edge cases\n");

In BitVec.Access.c:252:

    }
    
    bool test_bitvec_count_edge_cases(void) {
    printf("Testing BitVec count edge cases\n");

In BitVec.Access.c:284:

    }
    
    bool test_bitvec_access_multiple_operations(void) {
    printf("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) {
    printf("Testing BitVec large pattern access\n");

In BitVec.Access.c:347:

    
    // NEW: Test macro functions comprehensively
    bool test_bitvec_macro_functions(void) {
    printf("Testing BitVec macro functions\n");

In BitVec.Access.c:383:

    
    // NEW: Stress test for access operations
    bool test_bitvec_access_stress_test(void) {
    printf("Testing BitVec access stress test\n");

In BitVec.Access.c:423:

    
    // NEW: Comprehensive bit pattern testing
    bool test_bitvec_bit_patterns_comprehensive(void) {
    printf("Testing BitVec comprehensive bit patterns\n");

In BitVec.Access.c:487:

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

In BitVec.Access.c:496:

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

In BitVec.Access.c:505:

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

In BitVec.Access.c:514:

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

In BitVec.Access.c:526:

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

In BitVec.Access.c:538:

    }
    
    bool test_bitvec_flip_bounds_failures(void) {
    printf("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) {
    printf("Testing BitVec get with large out-of-bounds index\n");

In BitVec.Access.c:566:

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

In BitVec.Access.c:580:

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

In BitVec.Access.c:595:

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

In BitVec.Access.c:604:

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

In BitVec.Access.c:618:

    
    // Test BitVecFind and BitVecFindLast functions
    bool test_bitvec_find_functions(void) {
    printf("Testing BitVecFind and BitVecFindLast functions\n");

In BitVec.Access.c:662:

    
    // Test BitVecAll, BitVecAny, BitVecNone functions
    bool test_bitvec_predicate_functions(void) {
    printf("Testing BitVecAll, BitVecAny, BitVecNone functions\n");

In BitVec.Access.c:711:

    
    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
    printf("Testing BitVecLongestRun function\n");

In BitVec.Access.c:760:

    
    // Edge case tests for Find functions
    bool test_bitvec_find_edge_cases(void) {
    printf("Testing BitVecFind edge cases\n");

In BitVec.Access.c:792:

    
    // Edge case tests for predicate functions
    bool test_bitvec_predicate_edge_cases(void) {
    printf("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) {
    printf("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) {
    printf("Testing BitVecFind deadend scenarios\n");

In BitVec.Access.c:874:

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

In BitVec.Access.c:883:

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

In BitVec.Access.c:893:

    
    // Main function that runs all tests
    int main(void) {
    printf("[INFO] Starting BitVec.Access 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) {
    printf("Testing BitVecEquals\n");

In BitVec.Compare.c:78:

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

In BitVec.Compare.c:114:

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

In BitVec.Compare.c:148:

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

In BitVec.Compare.c:184:

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

In BitVec.Compare.c:220:

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

In BitVec.Compare.c:263:

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

In BitVec.Compare.c:306:

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

In BitVec.Compare.c:349:

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

In BitVec.Compare.c:390:

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

In BitVec.Compare.c:434:

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

In BitVec.Compare.c:476:

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

In BitVec.Compare.c:523:

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

In BitVec.Compare.c:563:

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

In BitVec.Compare.c:607:

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

In BitVec.Compare.c:643:

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

In BitVec.Compare.c:675:

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

In BitVec.Compare.c:746:

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

In BitVec.Compare.c:809:

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

In BitVec.Compare.c:821:

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

In BitVec.Compare.c:830:

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

In BitVec.Compare.c:842:

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

In BitVec.Compare.c:862:

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

In BitVec.Compare.c:872:

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

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 TestRunner.h:20:

    /// TAGS: Testing, Function, Pointer
    ///
    typedef bool (*TestFunction)(void);
    
    ///

void

`void`

Description

Usage example (Cross-references)

Tags :

Share :

Related Posts

Vec