BitVecInit

Documentation

API Reference

BitVecInit

Description

Initialize bitvector with default values. It is mandatory to initialize bitvectors before use; not doing so is undefined behaviour.

This public macro supports both forms:

BitVecInit() - uses DefaultAllocator().
BitVecInit(alloc) - binds the supplied allocator.

Parameters

Name	Direction	Description
`alloc`	in	Optional allocator override.

Usage example (from documentation)

  BitVec flags = BitVecInit();

Success

Returns a fresh BitVec with length 0, capacity 0, NULL data pointer, and the chosen allocator bound. No heap allocation is performed until the bitvector is mutated.

Failure

Function cannot fail.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:39:

    
    BitVec BitVecInitWithCapacityAlloc(u64 cap, Allocator alloc) {
        BitVec result = BitVecInit(alloc);
    
        if (cap == 0) {

In BitVec.c:195:

        }
    
        *out = BitVecInit(bv->allocator);
        if (bv->length == 0) {
            return true;

In BitVec.c:203:

        if (!BitVecReserve(out, bv->length) || !BitVecResize(out, bv->length)) {
            BitVecDeinit(out);
            *out = BitVecInit(bv->allocator);
            return false;
        }

In BitVec.c:220:

    
        ValidateBitVec(bv);
        clone = BitVecInit(bv->allocator);
        (void)BitVecTryClone(&clone, bv);
        return clone;

In BitVec.c:843:

        }
    
        *out = BitVecInit(alloc);
    
        u64 str_len = ZstrLen(str);

In BitVec.c:854:

                if (!BitVecPush(out, true)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;
                }

In BitVec.c:860:

                if (!BitVecPush(out, false)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;
                }

In BitVec.c:874:

    
        if (!BitVecTryFromStrAlloc(&result, str, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.c:918:

        }
    
        *out = BitVecInit(alloc);
    
        // Handle empty bitvector case

In BitVec.c:927:

        if (!BitVecReserve(out, bit_len) || !BitVecResize(out, bit_len)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);
            return false;
        }

In BitVec.c:946:

    
        if (!BitVecTryFromBytesAlloc(&result, bytes, bit_len, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.c:976:

        }
    
        *out = BitVecInit(alloc);
        if (bits == 0) {
            return true;

In BitVec.c:988:

        if (!BitVecReserve(out, bits) || !BitVecResize(out, bits)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);
            return false;
        }

In BitVec.c:1005:

    
        if (!BitVecTryFromIntegerAlloc(&result, value, bits, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.Pattern.Deadend.c:38:

        WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:51:

        WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:65:

        WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:78:

        WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:104:

        WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");
    
        BitVec source = BitVecInit();
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:119:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:120:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:136:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        size   results[10];

In BitVec.Pattern.Deadend.c:137:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:154:

    bool test_bitvec_starts_with_null_source(void) {
        WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
        BitVec prefix = BitVecInit();
        BitVecPush(&prefix, true);
        BitVecStartsWith(NULL, &prefix);

In BitVec.Pattern.Deadend.c:163:

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

In BitVec.Pattern.Deadend.c:172:

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

In BitVec.Pattern.Deadend.c:181:

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

In BitVec.Pattern.Deadend.c:190:

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

In BitVec.Pattern.Deadend.c:199:

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

In BitVec.Pattern.Deadend.c:216:

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

In BitVec.Pattern.Deadend.c:217:

        WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        BitVecPush(&pattern, true);
        BitVecPush(&wildcard, false);

In BitVec.Pattern.Deadend.c:234:

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

In BitVec.Pattern.Deadend.c:252:

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

In BitVec.Pattern.Deadend.c:270:

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

In Io.Read.c:841:

    
        // Test 1: Reading binary string
        BitVec bv1 = BitVecInit();
        z          = "10110";
        StrReadFmt(z, "{}", bv1);

In Io.Read.c:855:

    
        // Test 2: Reading hex format
        BitVec bv2 = BitVecInit();
        z          = "0xDEAD";
        StrReadFmt(z, "{}", bv2);

In Io.Read.c:864:

    
        // Test 3: Reading octal format
        BitVec bv3 = BitVecInit();
        z          = "0o755";
        StrReadFmt(z, "{}", bv3);

In Io.Read.c:873:

    
        // Test 4: Reading with whitespace
        BitVec bv4 = BitVecInit();
        z          = "   1101";
        StrReadFmt(z, "{}", bv4);

In Io.Read.c:887:

    
        // Test 5: Reading zero values
        BitVec bv5 = BitVecInit();
        z          = "0";
        StrReadFmt(z, "{}", bv5);

In BitVec.Access.Simple.c:36:

        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit();
    
        // Push some bits

In BitVec.Access.Simple.c:56:

        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit();
    
        // Reserve space and set bits

In BitVec.Access.Simple.c:77:

        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit();
    
        // Push some bits

In BitVec.Access.Simple.c:103:

        WriteFmt("Testing BitVecLength and BitVecCapacity\n");
    
        BitVec bv = BitVecInit();
    
        // Initially empty

In BitVec.Access.Simple.c:129:

        WriteFmt("Testing BitVecCount operations\n");
    
        BitVec bv = BitVecInit();
    
        // Push a pattern: true, false, true, false, true

In BitVec.Access.Simple.c:149:

        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:171:

        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv = BitVecInit();
    
        // Set first bit

In BitVec.Access.Simple.c:190:

        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv = BitVecInit();
    
        // Test flipping single bit

In BitVec.Access.Simple.c:209:

        WriteFmt("Testing BitVecCount edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:237:

        WriteFmt("Testing BitVec multiple access operations\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:274:

        WriteFmt("Testing BitVec access with large patterns\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:309:

        WriteFmt("Testing BitVec macro functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:339:

        WriteFmt("Testing BitVec access stress test\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:389:

        WriteFmt("Testing BitVec comprehensive bit patterns\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:443:

        WriteFmt("Testing BitVecFind functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:477:

        WriteFmt("Testing BitVec predicate functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:524:

        WriteFmt("Testing BitVecLongestRun\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:561:

        WriteFmt("Testing BitVecFind edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:593:

        WriteFmt("Testing BitVec predicate edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.Simple.c:633:

        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.c:38:

        WriteFmt("Testing BitVecForeachIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.c:71:

        WriteFmt("Testing BitVecForeach macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true

In BitVec.Foreach.c:102:

        WriteFmt("Testing BitVecForeachReverseIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.c:133:

        WriteFmt("Testing BitVecForeachReverse macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true

In BitVec.Foreach.c:163:

        WriteFmt("Testing BitVecForeachInRangeIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false, true

In BitVec.Foreach.c:199:

        WriteFmt("Testing BitVecForeachInRange macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: false, true, true, false, true

In BitVec.Foreach.c:234:

        WriteFmt("Testing BitVec foreach edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;
        int    count  = 0;

In BitVec.Foreach.c:274:

        WriteFmt("Testing BitVec foreach idx edge cases\n");
    
        BitVec bv       = BitVecInit();
        bool   result   = true;
        u64    last_idx = SIZE_MAX;

In BitVec.Foreach.c:313:

        WriteFmt("Testing BitVec foreach reverse edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.c:351:

        WriteFmt("Testing BitVec foreach range edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.c:401:

    
        for (int sz = 0; sz < 100; sz += 10) {
            BitVec bv = BitVecInit();
    
            // Create bitvec of varying sz

In BitVec.Foreach.c:444:

        WriteFmt("Testing BitVecRunLengths basic functionality\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.c:483:

    
        // Test 1: Empty bitvector
        BitVec empty_bv = BitVecInit();
        u64    runs[5];
        bool   values[5];

In BitVec.Foreach.c:491:

    
        // Test 2: Single bit (true)
        BitVec single_bv = BitVecInit();
        BitVecPush(&single_bv, true);
        count  = BitVecRunLengths(&single_bv, runs, values, 5);

In BitVec.Foreach.c:499:

    
        // Test 3: Single bit (false)
        BitVec single_false_bv = BitVecInit();
        BitVecPush(&single_false_bv, false);
        count  = BitVecRunLengths(&single_false_bv, runs, values, 5);

In BitVec.Foreach.c:507:

    
        // Test 4: All same bits (all true)
        BitVec all_true_bv = BitVecInit();
        for (int i = 0; i < 10; i++) {
            BitVecPush(&all_true_bv, true);

In BitVec.Foreach.c:517:

    
        // Test 5: Alternating bits (0101010)
        BitVec alternating_bv = BitVecInit();
        for (int i = 0; i < 7; i++) {
            BitVecPush(&alternating_bv, i % 2 == 0);

In BitVec.Foreach.c:538:

        WriteFmt("Testing BitVecRunLengths boundary conditions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.c:578:

    
        // Test with large bitvector
        BitVec large_bv = BitVecInit();
    
        // Create pattern that results in many runs

In BitVec.Foreach.c:651:

        WriteFmt("Testing BitVecRunLengths with NULL runs array\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        bool values[5];

In BitVec.Foreach.c:665:

        WriteFmt("Testing BitVecRunLengths with NULL values array\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        u64 runs[5];

In BitVec.Foreach.c:679:

        WriteFmt("Testing BitVecRunLengths with zero max_runs\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        u64  runs[5];

In BitVec.Access.Deadend.c:85:

        WriteFmt("Testing BitVec get bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test get from empty bitvec - should abort

In BitVec.Access.Deadend.c:97:

        WriteFmt("Testing BitVec set bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test set on empty bitvec - should abort

In BitVec.Access.Deadend.c:109:

        WriteFmt("Testing BitVec flip bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test flip on empty bitvec - should abort

In BitVec.Access.Deadend.c:122:

        WriteFmt("Testing BitVec get with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.Deadend.c:137:

        WriteFmt("Testing BitVec set with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.Deadend.c:151:

        WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.Deadend.c:175:

        WriteFmt("Testing BitVec get with maximum index value\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);

In Io.Write.c:564:

    
        // Test 2: Empty BitVec
        BitVec bv_empty = BitVecInit();
        StrWriteFmt(&output, "{}", bv_empty);
        success = success && (output.length == 0);

In BitVec.Foreach.Simple.c:38:

        WriteFmt("Testing BitVecForeachIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.Simple.c:71:

        WriteFmt("Testing BitVecForeach macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true

In BitVec.Foreach.Simple.c:102:

        WriteFmt("Testing BitVecForeachReverseIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.Simple.c:133:

        WriteFmt("Testing BitVecForeachReverse macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true

In BitVec.Foreach.Simple.c:163:

        WriteFmt("Testing BitVecForeachInRangeIdx macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: true, false, true, false, true

In BitVec.Foreach.Simple.c:199:

        WriteFmt("Testing BitVecForeachInRange macro\n");
    
        BitVec bv = BitVecInit();
    
        // Add test pattern: false, true, true, false, true

In BitVec.Foreach.Simple.c:234:

        WriteFmt("Testing BitVec foreach edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;
        int    count  = 0;

In BitVec.Foreach.Simple.c:274:

        WriteFmt("Testing BitVec foreach idx edge cases\n");
    
        BitVec bv       = BitVecInit();
        bool   result   = true;
        u64    last_idx = SIZE_MAX;

In BitVec.Foreach.Simple.c:313:

        WriteFmt("Testing BitVec foreach reverse edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.Simple.c:351:

        WriteFmt("Testing BitVec foreach range edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.Simple.c:401:

    
        for (int sz = 0; sz < 100; sz += 10) {
            BitVec bv = BitVecInit();
    
            // Create bitvec of varying sz

In BitVec.Foreach.Simple.c:444:

        WriteFmt("Testing BitVecRunLengths basic functionality\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.Simple.c:483:

    
        // Test 1: Empty bitvector
        BitVec empty_bv = BitVecInit();
        u64    runs[5];
        bool   values[5];

In BitVec.Foreach.Simple.c:491:

    
        // Test 2: Single bit (true)
        BitVec single_bv = BitVecInit();
        BitVecPush(&single_bv, true);
        count  = BitVecRunLengths(&single_bv, runs, values, 5);

In BitVec.Foreach.Simple.c:499:

    
        // Test 3: Single bit (false)
        BitVec single_false_bv = BitVecInit();
        BitVecPush(&single_false_bv, false);
        count  = BitVecRunLengths(&single_false_bv, runs, values, 5);

In BitVec.Foreach.Simple.c:507:

    
        // Test 4: All same bits (all true)
        BitVec all_true_bv = BitVecInit();
        for (int i = 0; i < 10; i++) {
            BitVecPush(&all_true_bv, true);

In BitVec.Foreach.Simple.c:517:

    
        // Test 5: Alternating bits (0101010)
        BitVec alternating_bv = BitVecInit();
        for (int i = 0; i < 7; i++) {
            BitVecPush(&alternating_bv, i % 2 == 0);

In BitVec.Foreach.Simple.c:538:

        WriteFmt("Testing BitVecRunLengths boundary conditions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Foreach.Simple.c:578:

    
        // Test with large bitvector
        BitVec large_bv = BitVecInit();
    
        // Create pattern that results in many runs

In BitVec.Remove.c:30:

        WriteFmt("Testing BitVecPop\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits

In BitVec.Remove.c:64:

        WriteFmt("Testing BitVecRemove (single bit)\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:100:

        WriteFmt("Testing BitVecRemoveRange\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits: true, false, true, true, false, true

In BitVec.Remove.c:129:

        WriteFmt("Testing BitVecRemoveFirst\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:166:

        WriteFmt("Testing BitVecRemoveLast\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:204:

        WriteFmt("Testing BitVecRemoveAll\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits: true, false, true, false, true, false

In BitVec.Remove.c:241:

        WriteFmt("Testing BitVecPop edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Remove.c:266:

        WriteFmt("Testing BitVecRemove edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Remove.c:291:

        WriteFmt("Testing BitVecRemoveRange edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Remove.c:321:

        WriteFmt("Testing BitVecRemoveFirst/Last edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Remove.c:357:

        WriteFmt("Testing BitVecRemoveAll edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Remove.c:411:

        WriteFmt("Testing BitVec remove invalid range handling\n");
    
        BitVec bv = BitVecInit();
    
        // Test removing beyond capacity limit - should abort

In BitVec.Remove.c:423:

        WriteFmt("Testing BitVec pop bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test pop from empty bitvec - should abort

In BitVec.Remove.c:435:

        WriteFmt("Testing BitVec remove bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test remove from empty bitvec - should abort

In BitVec.Remove.c:447:

        WriteFmt("Testing BitVec remove range bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test remove range from empty bitvec - should abort

In BitVec.Math.c:55:

        WriteFmt("Testing BitVecHammingDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:56:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:97:

        WriteFmt("Testing BitVecHammingDistance edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:98:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:127:

        WriteFmt("Testing BitVecJaccardSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:128:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:176:

        WriteFmt("Testing BitVecJaccardSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:177:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:202:

        WriteFmt("Testing BitVecCosineSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:203:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:237:

        WriteFmt("Testing BitVecCosineSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:238:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:267:

        WriteFmt("Testing BitVecDotProduct basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:268:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:304:

        WriteFmt("Testing BitVecDotProduct edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:305:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:331:

        WriteFmt("Testing BitVecEditDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:332:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:375:

        WriteFmt("Testing BitVecEditDistance edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:376:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:403:

        WriteFmt("Testing BitVecCorrelation basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:404:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:439:

        WriteFmt("Testing BitVecCorrelation edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:440:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:467:

        WriteFmt("Testing BitVecEntropy basic functionality\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Math.c:496:

        WriteFmt("Testing BitVecEntropy edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Math.c:516:

        WriteFmt("Testing BitVecAlignmentScore basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:517:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:549:

        WriteFmt("Testing BitVecAlignmentScore edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:550:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:576:

        WriteFmt("Testing BitVecBestAlignment basic functionality\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:577:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:606:

        WriteFmt("Testing BitVecBestAlignment edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:607:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:631:

        WriteFmt("Testing BitVec Math stress tests\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:632:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Math.c:652:

    
        // Test edit distance with smaller vectors (expensive operation)
        BitVec small1 = BitVecInit();
        BitVec small2 = BitVecInit();
        for (int i = 0; i < 50; i++) {

In BitVec.Math.c:653:

        // Test edit distance with smaller vectors (expensive operation)
        BitVec small1 = BitVecInit();
        BitVec small2 = BitVecInit();
        for (int i = 0; i < 50; i++) {
            BitVecPush(&small1, i % 2 == 0);

In BitVec.Math.c:682:

    bool test_bitvec_hamming_distance_null_bv1(void) {
        WriteFmt("Testing BitVecHammingDistance(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv2, true);
        BitVecHammingDistance(NULL, &bv2);

In BitVec.Math.c:691:

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

In BitVec.Math.c:700:

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

In BitVec.Math.c:709:

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

In BitVec.Math.c:718:

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

In BitVec.Math.c:727:

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

In BitVec.Math.c:736:

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

In BitVec.Math.c:745:

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

In BitVec.Math.c:754:

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

In BitVec.Math.c:763:

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

In BitVec.Math.c:772:

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

In BitVec.Math.c:781:

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

In BitVec.Math.c:796:

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

In BitVec.Math.c:805:

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

In BitVec.Math.c:814:

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

In BitVec.Math.c:823:

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

In BitVec.Compare.c:38:

        WriteFmt("Testing BitVecEquals\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();

In BitVec.Compare.c:39:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();

In BitVec.Compare.c:40:

        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();
    
        // Test equal empty bitvectors

In BitVec.Compare.c:81:

        WriteFmt("Testing BitVecCompare\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:82:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test equal bitvectors

In BitVec.Compare.c:117:

        WriteFmt("Testing BitVecLexCompare\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:118:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test lexicographic comparison

In BitVec.Compare.c:151:

        WriteFmt("Testing BitVecNumericalCompare\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:152:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create bitvectors representing different numbers

In BitVec.Compare.c:187:

        WriteFmt("Testing BitVecWeightCompare\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:188:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // bv1: 111 (3 ones)

In BitVec.Compare.c:223:

        WriteFmt("Testing BitVecIsSubset\n");
    
        BitVec subset   = BitVecInit();
        BitVec superset = BitVecInit();

In BitVec.Compare.c:224:

    
        BitVec subset   = BitVecInit();
        BitVec superset = BitVecInit();
    
        // Create superset: 1111

In BitVec.Compare.c:266:

        WriteFmt("Testing BitVecSignedCompare\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:267:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test positive vs negative (MSB is sign bit)

In BitVec.Compare.c:309:

        WriteFmt("Testing BitVecIsSuperset\n");
    
        BitVec superset = BitVecInit();
        BitVec subset   = BitVecInit();

In BitVec.Compare.c:310:

    
        BitVec superset = BitVecInit();
        BitVec subset   = BitVecInit();
    
        // Create superset: 1111

In BitVec.Compare.c:352:

        WriteFmt("Testing BitVecOverlaps\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:353:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create overlapping bitvectors

In BitVec.Compare.c:393:

        WriteFmt("Testing BitVecDisjoint and BitVecIntersects\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:394:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create disjoint bitvectors

In BitVec.Compare.c:437:

        WriteFmt("Testing BitVecEqualsRange\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:438:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create test patterns

In BitVec.Compare.c:479:

        WriteFmt("Testing BitVecCompareRange\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:480:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create test patterns

In BitVec.Compare.c:526:

        WriteFmt("Testing BitVecIsLexicographicallyLess and BitVecIsNumericallyLess\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:527:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test lexicographic comparison

In BitVec.Compare.c:566:

        WriteFmt("Testing BitVecIsSorted\n");
    
        BitVec bv = BitVecInit();
    
        // Test empty bitvector (should be sorted)

In BitVec.Compare.c:610:

        WriteFmt("Testing BitVec compare edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:611:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:646:

        WriteFmt("Testing BitVec set operations edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:647:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:678:

        WriteFmt("Testing BitVec comprehensive comparison operations\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:679:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:709:

    
        // Test transitivity: if A < B and B < C, then A < C
        BitVec bv3 = BitVecInit();
        // bv3: larger than bv2
        for (int i = 0; i < 8; i++) {

In BitVec.Compare.c:720:

    
        // Test subset/superset consistency
        BitVec subset   = BitVecInit();
        BitVec superset = BitVecInit();

In BitVec.Compare.c:721:

        // Test subset/superset consistency
        BitVec subset   = BitVecInit();
        BitVec superset = BitVecInit();
    
        // Create actual subset/superset relationship

In BitVec.Compare.c:749:

        WriteFmt("Testing BitVec large-scale comparison operations\n");
    
        BitVec large1 = BitVecInit();
        BitVec large2 = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:750:

    
        BitVec large1 = BitVecInit();
        BitVec large2 = BitVecInit();
        bool   result = true;

In BitVec.Compare.c:777:

    
        // Verify signed vs unsigned comparison differences
        BitVec pos = BitVecInit();
        BitVec neg = BitVecInit();

In BitVec.Compare.c:778:

        // Verify signed vs unsigned comparison differences
        BitVec pos = BitVecInit();
        BitVec neg = BitVecInit();
    
        // Positive number (MSB = 0): 01111111

In BitVec.Compare.c:812:

        WriteFmt("Testing BitVec compare NULL pointer handling\n");
    
        BitVec bv = BitVecInit();
    
        // Test NULL pointer - should abort

In BitVec.Compare.c:833:

        WriteFmt("Testing BitVec range operations NULL handling\n");
    
        BitVec bv = BitVecInit();
    
        // Test NULL pointer in range operations - should abort

In BitVec.Compare.c:845:

        WriteFmt("Testing BitVec range operations bounds checking\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Compare.c:846:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Create small bitvectors

In BitVec.Init.c:24:

    // Test BitVecInit function
    bool test_bitvec_init(void) {
        WriteFmt("Testing BitVecInit\n");
    
        // Test basic initialization

In BitVec.Init.c:27:

    
        // Test basic initialization
        BitVec bv = BitVecInit();
    
        // Check initial state

In BitVec.Init.c:45:

        WriteFmt("Testing BitVecDeinit\n");
    
        BitVec bv = BitVecInit();
    
        // Add some data to make sure deinitialization works with allocated memory

In BitVec.Init.c:73:

        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit();
    
        // Reserve space for 50 bits

In BitVec.Init.c:106:

        WriteFmt("Testing BitVecClear\n");
    
        BitVec bv = BitVecInit();
    
        // Add some data

In BitVec.Init.c:141:

        WriteFmt("Testing BitVecResize\n");
    
        BitVec bv = BitVecInit();
    
        // Add some initial data

In BitVec.Init.c:180:

    // Edge case tests - boundary conditions and unusual but valid inputs
    bool test_bitvec_init_edge_cases(void) {
        WriteFmt("Testing BitVecInit edge cases\n");
    
        // Test multiple initializations

In BitVec.Init.c:183:

    
        // Test multiple initializations
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();

In BitVec.Init.c:184:

        // Test multiple initializations
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();

In BitVec.Init.c:185:

        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVec bv3 = BitVecInit();
    
        bool result = (bv1.length == 0) && (bv2.length == 0) && (bv3.length == 0);

In BitVec.Init.c:201:

        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Init.c:229:

        WriteFmt("Testing BitVecReu64 edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Init.c:265:

        WriteFmt("Testing BitVecClear edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Init.c:300:

        // Test multiple init/deinit cycles
        for (int cycle = 0; cycle < 100; cycle++) {
            BitVec bv = BitVecInit();
    
            // Add some data

In BitVec.Init.c:334:

        // failure rather than aborting. The Must variant aborts, so use it here
        // to validate the deadend abort path.
        BitVec bv = BitVecInit();
    
        BitVecMustReserve(&bv, SIZE_MAX);

In BitVec.Init.c:349:

        // failure rather than aborting. The Must variant aborts, so use it here
        // to validate the deadend abort path.
        BitVec bv = BitVecInit();
    
        BitVecMustResize(&bv, SIZE_MAX);

In BitVec.BitWise.Deadend.c:34:

        WriteFmt("Testing BitVec bitwise operations NULL handling\n");
    
        BitVec bv  = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.BitWise.Deadend.c:35:

    
        BitVec bv  = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test NULL pointer - should abort

In BitVec.BitWise.Deadend.c:76:

        WriteFmt("Testing BitVec AND with NULL result handling\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv1, true);

In BitVec.BitWise.Deadend.c:77:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);

In BitVec.BitWise.Deadend.c:92:

        WriteFmt("Testing BitVec OR with NULL operand handling\n");
    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();

In BitVec.BitWise.Deadend.c:93:

    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();
    
        // Test NULL operand - should abort

In BitVec.BitWise.Deadend.c:106:

        WriteFmt("Testing BitVec XOR with NULL second operand handling\n");
    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();

In BitVec.BitWise.Deadend.c:107:

    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();
    
        // Test NULL second operand - should abort

In BitVec.BitWise.Deadend.c:120:

        WriteFmt("Testing BitVec NOT with NULL handling\n");
    
        BitVec result = BitVecInit();
    
        // Test NULL operand - should abort

In BitVec.BitWise.Simple.c:35:

        WriteFmt("Testing BitVecAnd\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:36:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:37:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1101

In BitVec.BitWise.Simple.c:73:

        WriteFmt("Testing BitVecOr\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:74:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:75:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1100

In BitVec.BitWise.Simple.c:111:

        WriteFmt("Testing BitVecXor\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:112:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:113:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1100

In BitVec.BitWise.Simple.c:149:

        WriteFmt("Testing BitVecNot\n");
    
        BitVec bv     = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.Simple.c:150:

    
        BitVec bv     = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up bitvector: 1010

In BitVec.BitWise.Simple.c:179:

        WriteFmt("Testing BitVecShiftLeft\n");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011 (indices 0,1,2,3)

In BitVec.BitWise.Simple.c:220:

        WriteFmt("Testing BitVecShiftRight\n");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:254:

        WriteFmt("Testing BitVecRotateLeft\n");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:282:

        WriteFmt("Testing BitVecRotateRight\n");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:310:

        WriteFmt("Testing BitVecReverse\n");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:338:

        WriteFmt("Testing BitVec shift edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:374:

        WriteFmt("Testing BitVec rotate edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:402:

        WriteFmt("Testing BitVec bitwise operations edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:403:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:407:

    
        // Test operations on empty bitvecs
        BitVec result_bv = BitVecInit();
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (result_bv.length == 0);

In BitVec.BitWise.Simple.c:441:

        WriteFmt("Testing BitVecReverse edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:475:

        WriteFmt("Testing BitVec comprehensive bitwise operations\n");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.Simple.c:476:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:477:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:541:

        WriteFmt("Testing BitVec comprehensive shift operations\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:607:

        WriteFmt("Testing BitVec comprehensive rotate operations\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.Simple.c:669:

        WriteFmt("Testing BitVec bitwise identity operations\n");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.Simple.c:670:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:671:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:763:

        WriteFmt("Testing BitVec bitwise commutative properties\n");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();

In BitVec.BitWise.Simple.c:764:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();

In BitVec.BitWise.Simple.c:765:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:766:

        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:825:

        WriteFmt("Testing BitVec bitwise operations with large patterns\n");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.Simple.c:826:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.Simple.c:827:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.Type.c:19:

    
        // Create a bitvector
        BitVec bitvec = BitVecInit();
    
        // Check initial state

In BitVec.Type.c:35:

    
        // Create a valid bitvector
        BitVec bitvec = BitVecInit();
    
        // This should not abort

In BitVec.Foreach.Deadend.c:34:

        WriteFmt("Testing BitVecRunLengths with NULL runs array\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        bool values[5];

In BitVec.Foreach.Deadend.c:48:

        WriteFmt("Testing BitVecRunLengths with NULL values array\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        u64 runs[5];

In BitVec.Foreach.Deadend.c:62:

        WriteFmt("Testing BitVecRunLengths with zero max_runs\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        u64  runs[5];

In BitVec.Foreach.Deadend.c:82:

    
        // Test foreach with invalid bitvec (length > 0 but data is NULL)
        BitVec bv   = BitVecInit();
        bv.length   = 5;
        bv.capacity = 10;

In BitVec.Memory.c:28:

        WriteFmt("Testing BitVecShrinkToFit\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits

In BitVec.Memory.c:65:

        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit();
    
        // Add some bits

In BitVec.Memory.c:102:

        WriteFmt("Testing BitVecSwap\n");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.Memory.c:103:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Set up first bitvector

In BitVec.Memory.c:146:

        WriteFmt("Testing BitVecClone\n");
    
        BitVec original = BitVecInit();
    
        // Set up original bitvector

In BitVec.Memory.c:196:

        alloc.flags = 0x3C3Cu;
    
        BitVec original = BitVecInit(alloc);
        original.allocator.state = (void *)&original;

In BitVec.Memory.c:230:

        WriteFmt("Testing BitVecShrinkToFit edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Memory.c:261:

        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Memory.c:298:

        WriteFmt("Testing BitVecSwap edge cases\n");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Memory.c:299:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.Memory.c:339:

        WriteFmt("Testing BitVecClone edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Memory.c:384:

        // Test multiple clone/swap/reu64 cycles
        for (int cycle = 0; cycle < 10; cycle++) {
            BitVec bv1 = BitVecInit();
            BitVec bv2 = BitVecInit();

In BitVec.Memory.c:385:

        for (int cycle = 0; cycle < 10; cycle++) {
            BitVec bv1 = BitVecInit();
            BitVec bv2 = BitVecInit();
    
            // Add random-sized data

In BitVec.Memory.c:428:

        WriteFmt("Testing BitVec swap NULL handling\n");
    
        BitVec bv = BitVecInit();
    
        // Test NULL pointer - should abort

In BitVec.Convert.c:38:

        WriteFmt("Testing BitVecToStr\n");
    
        BitVec bv = BitVecInit();
    
        // Create pattern: 1011

In BitVec.Convert.c:95:

        WriteFmt("Testing BitVecToBytes\n");
    
        BitVec bv = BitVecInit();
    
        // Create pattern: 10110011 (0xB3)

In BitVec.Convert.c:161:

        WriteFmt("Testing BitVecToInteger\n");
    
        BitVec bv = BitVecInit();
    
        // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)

In BitVec.Convert.c:178:

    
        // Test with larger pattern
        BitVec bv2 = BitVecInit();
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv2, (i % 2 == 0)); // Alternating pattern

In BitVec.Convert.c:267:

        WriteFmt("Testing BitVec convert edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Convert.c:330:

        WriteFmt("Testing BitVec bytes conversion edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Convert.c:357:

        WriteFmt("Testing BitVec integer conversion edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Convert.c:452:

    
        // Test oversized bitvec to integer (should handle gracefully)
        BitVec oversized = BitVecInit();
        for (int i = 0; i < 100; i++) { // 100 bits > 64 bit limit
            BitVecPush(&oversized, i % 2 == 0);

In BitVec.Convert.c:463:

    
        // Test zero-length conversions
        BitVec empty = BitVecInit();
    
        Str empty_str = BitVecToStr(&empty);

In BitVec.Convert.c:556:

    
        // Test with very large bitvectors
        BitVec large_bv = BitVecInit();
    
        // Create a 1000-bit pattern

In BitVec.Convert.c:636:

        WriteFmt("Testing BitVec bytes bounds failures\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);

In BitVec.BitWise.c:35:

        WriteFmtLn("Testing BitVecAnd");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:36:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:37:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1101

In BitVec.BitWise.c:73:

        WriteFmtLn("Testing BitVecOr");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:74:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:75:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1100

In BitVec.BitWise.c:111:

        WriteFmtLn("Testing BitVecXor");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:112:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:113:

        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up first bitvector: 1100

In BitVec.BitWise.c:149:

        WriteFmtLn("Testing BitVecNot");
    
        BitVec bv     = BitVecInit();
        BitVec result = BitVecInit();

In BitVec.BitWise.c:150:

    
        BitVec bv     = BitVecInit();
        BitVec result = BitVecInit();
    
        // Set up bitvector: 1010

In BitVec.BitWise.c:179:

        WriteFmtLn("Testing BitVecShiftLeft");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011 (indices 0,1,2,3)

In BitVec.BitWise.c:220:

        WriteFmtLn("Testing BitVecShiftRight");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.c:254:

        WriteFmtLn("Testing BitVecRotateLeft");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.c:282:

        WriteFmtLn("Testing BitVecRotateRight");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.c:310:

        WriteFmtLn("Testing BitVecReverse");
    
        BitVec bv = BitVecInit();
    
        // Set up bitvector: 1011

In BitVec.BitWise.c:338:

        WriteFmtLn("Testing BitVec shift edge cases");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:374:

        WriteFmtLn("Testing BitVec rotate edge cases");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:402:

        WriteFmtLn("Testing BitVec bitwise operations edge cases");
    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:403:

    
        BitVec bv1    = BitVecInit();
        BitVec bv2    = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:407:

    
        // Test operations on empty bitvecs
        BitVec result_bv = BitVecInit();
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (result_bv.length == 0);

In BitVec.BitWise.c:441:

        WriteFmtLn("Testing BitVecReverse edge cases");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:475:

        WriteFmtLn("Testing BitVec comprehensive bitwise operations");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.c:476:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:477:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:541:

        WriteFmtLn("Testing BitVec comprehensive shift operations");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:607:

        WriteFmtLn("Testing BitVec comprehensive rotate operations");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.BitWise.c:669:

        WriteFmtLn("Testing BitVec bitwise identity operations");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.c:670:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:671:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:763:

        WriteFmtLn("Testing BitVec bitwise commutative properties");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();

In BitVec.BitWise.c:764:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();

In BitVec.BitWise.c:765:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:766:

        BitVec bv2         = BitVecInit();
        BitVec result1     = BitVecInit();
        BitVec result2     = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:825:

        WriteFmtLn("Testing BitVec bitwise operations with large patterns");
    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();

In BitVec.BitWise.c:826:

    
        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:827:

        BitVec bv1         = BitVecInit();
        BitVec bv2         = BitVecInit();
        BitVec result      = BitVecInit();
        bool   test_result = true;

In BitVec.BitWise.c:895:

        WriteFmtLn("Testing BitVec bitwise operations NULL handling");
    
        BitVec bv  = BitVecInit();
        BitVec bv2 = BitVecInit();

In BitVec.BitWise.c:896:

    
        BitVec bv  = BitVecInit();
        BitVec bv2 = BitVecInit();
    
        // Test NULL pointer - should abort

In BitVec.BitWise.c:937:

        WriteFmtLn("Testing BitVec AND with NULL result handling");
    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv1, true);

In BitVec.BitWise.c:938:

    
        BitVec bv1 = BitVecInit();
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);

In BitVec.BitWise.c:953:

        WriteFmtLn("Testing BitVec OR with NULL operand handling");
    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:954:

    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();
    
        // Test NULL operand - should abort

In BitVec.BitWise.c:967:

        WriteFmtLn("Testing BitVec XOR with NULL second operand handling");
    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:968:

    
        BitVec result = BitVecInit();
        BitVec bv1    = BitVecInit();
    
        // Test NULL second operand - should abort

In BitVec.BitWise.c:981:

        WriteFmtLn("Testing BitVec NOT with NULL handling");
    
        BitVec result = BitVecInit();
    
        // Test NULL operand - should abort

In BitVec.Insert.c:26:

        WriteFmt("Testing BitVecPush\n");
    
        BitVec bv = BitVecInit();
    
        // Push some bits

In BitVec.Insert.c:55:

        WriteFmt("Testing BitVecInsert (single bit)\n");
    
        BitVec bv = BitVecInit();
    
        // Insert at index 0 (empty bitvector)

In BitVec.Insert.c:90:

        WriteFmt("Testing BitVecInsertRange\n");
    
        BitVec bv = BitVecInit();
    
        // Create target bitvector

In BitVec.Insert.c:117:

        WriteFmt("Testing BitVecInsertMultiple\n");
    
        BitVec bv     = BitVecInit();
        BitVec source = BitVecInit();

In BitVec.Insert.c:118:

    
        BitVec bv     = BitVecInit();
        BitVec source = BitVecInit();
    
        // Start with some bits

In BitVec.Insert.c:151:

        WriteFmt("Testing BitVecInsertPattern\n");
    
        BitVec bv = BitVecInit();
    
        // Start with some bits

In BitVec.Insert.c:172:

    
        // Test with different pattern - 0x05 (0101 in binary) using only 3 bits
        BitVec bv2 = BitVecInit();
        BitVecPush(&bv2, true);

In BitVec.Insert.c:196:

        WriteFmt("Testing BitVecInsertRange edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Insert.c:224:

        WriteFmt("Testing BitVecInsertMultiple edge cases\n");
    
        BitVec bv     = BitVecInit();
        BitVec empty  = BitVecInit();
        BitVec source = BitVecInit();

In BitVec.Insert.c:225:

    
        BitVec bv     = BitVecInit();
        BitVec empty  = BitVecInit();
        BitVec source = BitVecInit();
        bool   result = true;

In BitVec.Insert.c:226:

        BitVec bv     = BitVecInit();
        BitVec empty  = BitVecInit();
        BitVec source = BitVecInit();
        bool   result = true;

In BitVec.Insert.c:257:

        WriteFmt("Testing BitVecInsertPattern edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Insert.c:292:

        WriteFmt("Testing BitVec insert invalid range handling\n");
    
        BitVec bv = BitVecInit();
    
        // Test inserting beyond capacity limit - should abort

In BitVec.Access.c:38:

        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit();
    
        // Add a pattern: 1010

In BitVec.Access.c:62:

        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit();
    
        // Initialize with some bits

In BitVec.Access.c:92:

        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit();
    
        // Initialize with pattern: 101

In BitVec.Access.c:129:

        WriteFmt("Testing BitVec length and capacity operations\n");
    
        BitVec bv = BitVecInit();
    
        // Initially should be empty

In BitVec.Access.c:160:

        WriteFmt("Testing BitVec count operations\n");
    
        BitVec bv = BitVecInit();
    
        // Create pattern: 1101000

In BitVec.Access.c:194:

        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:217:

        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:237:

        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:255:

        WriteFmt("Testing BitVec count edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:287:

        WriteFmt("Testing BitVec multiple access operations\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:313:

        WriteFmt("Testing BitVec large pattern access\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:350:

        WriteFmt("Testing BitVec macro functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:386:

        WriteFmt("Testing BitVec access stress test\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:426:

        WriteFmt("Testing BitVec comprehensive bit patterns\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:517:

        WriteFmt("Testing BitVec get bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test get from empty bitvec - should abort

In BitVec.Access.c:529:

        WriteFmt("Testing BitVec set bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test set on empty bitvec - should abort

In BitVec.Access.c:541:

        WriteFmt("Testing BitVec flip bounds checking\n");
    
        BitVec bv = BitVecInit();
    
        // Test flip on empty bitvec - should abort

In BitVec.Access.c:554:

        WriteFmt("Testing BitVec get with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.c:569:

        WriteFmt("Testing BitVec set with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.c:583:

        WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");
    
        BitVec bv = BitVecInit();
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.c:607:

        WriteFmt("Testing BitVec get with maximum index value\n");
    
        BitVec bv = BitVecInit();
        BitVecPush(&bv, true);

In BitVec.Access.c:621:

        WriteFmt("Testing BitVecFind and BitVecFindLast functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:665:

        WriteFmt("Testing BitVecAll, BitVecAny, BitVecNone functions\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:714:

        WriteFmt("Testing BitVecLongestRun function\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:763:

        WriteFmt("Testing BitVecFind edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:795:

        WriteFmt("Testing BitVec predicate edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Access.c:835:

        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:60:

        WriteFmt("Testing basic BitVec pattern functions\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:61:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:95:

        WriteFmt("Testing BitVecFindPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:96:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:142:

        WriteFmt("Testing BitVecFindLastPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:143:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:187:

        WriteFmt("Testing BitVecFindAllPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:188:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:245:

        WriteFmt("Testing BitVec pattern edge cases\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:246:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:314:

        WriteFmt("Testing BitVec pattern stress tests\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:315:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:355:

        WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.c:368:

        WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.c:382:

        WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.c:395:

        WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.c:421:

        WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");
    
        BitVec source = BitVecInit();
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.c:436:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        BitVecPush(&source, true);

In BitVec.Pattern.c:437:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.c:453:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        size   results[10];

In BitVec.Pattern.c:454:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.c:473:

        WriteFmt("Testing BitVecStartsWith basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:474:

    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:508:

        WriteFmt("Testing BitVecStartsWith edge cases\n");
    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:509:

    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:540:

        WriteFmt("Testing BitVecEndsWith basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:541:

    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:575:

        WriteFmt("Testing BitVecEndsWith edge cases\n");
    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:576:

    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:598:

        WriteFmt("Testing BitVecContains basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:599:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:635:

        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:636:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:665:

        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:666:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:689:

        WriteFmt("Testing BitVecCountPattern basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:690:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:724:

        WriteFmt("Testing BitVecRFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:725:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:761:

        WriteFmt("Testing BitVecReplace basic functionality\n");
    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();

In BitVec.Pattern.c:762:

    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.c:763:

        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.c:803:

        WriteFmt("Testing BitVecReplaceAll basic functionality\n");
    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();

In BitVec.Pattern.c:804:

    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.c:805:

        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.c:840:

        WriteFmt("Testing BitVecMatches basic functionality\n");
    
        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();

In BitVec.Pattern.c:841:

    
        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        bool   result   = true;

In BitVec.Pattern.c:842:

        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        bool   result   = true;

In BitVec.Pattern.c:875:

        WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:876:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.c:911:

        WriteFmt("Testing BitVecRegexMatch basic functionality\n");
    
        BitVec source = BitVecInit();
        bool   result = true;

In BitVec.Pattern.c:934:

        WriteFmt("Testing BitVecPrefixMatch basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec patterns[3];
        bool   result = true;

In BitVec.Pattern.c:940:

        // Initialize patterns
        for (int i = 0; i < 3; i++) {
            patterns[i] = BitVecInit();
        }

In BitVec.Pattern.c:980:

        WriteFmt("Testing BitVecSuffixMatch basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec patterns[3];
        bool   result = true;

In BitVec.Pattern.c:986:

        // Initialize patterns
        for (int i = 0; i < 3; i++) {
            patterns[i] = BitVecInit();
        }

In BitVec.Pattern.c:1026:

    bool test_bitvec_starts_with_null_source(void) {
        WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
        BitVec prefix = BitVecInit();
        BitVecPush(&prefix, true);
        BitVecStartsWith(NULL, &prefix);

In BitVec.Pattern.c:1035:

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

In BitVec.Pattern.c:1044:

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

In BitVec.Pattern.c:1053:

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

In BitVec.Pattern.c:1062:

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

In BitVec.Pattern.c:1071:

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

In BitVec.Pattern.c:1088:

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

In BitVec.Pattern.c:1089:

        WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        BitVecPush(&pattern, true);
        BitVecPush(&wildcard, false);

In BitVec.Pattern.c:1106:

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

In BitVec.Pattern.c:1115:

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

In BitVec.Pattern.c:1124:

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

In BitVec.Pattern.c:1133:

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

In BitVec.Pattern.c:1142:

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

In BitVec.Pattern.Simple.c:60:

        WriteFmt("Testing basic BitVec pattern functions\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:61:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:95:

        WriteFmt("Testing BitVecFindPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:96:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:142:

        WriteFmt("Testing BitVecFindLastPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:143:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:187:

        WriteFmt("Testing BitVecFindAllPattern function\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:188:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:245:

        WriteFmt("Testing BitVec pattern edge cases\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:246:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:314:

        WriteFmt("Testing BitVec pattern stress tests\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:315:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:357:

        WriteFmt("Testing BitVecStartsWith basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:358:

    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:392:

        WriteFmt("Testing BitVecStartsWith edge cases\n");
    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:393:

    
        BitVec source = BitVecInit();
        BitVec prefix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:424:

        WriteFmt("Testing BitVecEndsWith basic functionality\n");
    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:425:

    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:459:

        WriteFmt("Testing BitVecEndsWith edge cases\n");
    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:460:

    
        BitVec source = BitVecInit();
        BitVec suffix = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:482:

        WriteFmt("Testing BitVecFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:483:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:519:

        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:520:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:549:

        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:550:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:573:

        WriteFmt("Testing BitVecCountPattern basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:574:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:608:

        WriteFmt("Testing BitVecRFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:609:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:645:

        WriteFmt("Testing BitVecReplace basic functionality\n");
    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();

In BitVec.Pattern.Simple.c:646:

    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.Simple.c:647:

        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.Simple.c:687:

        WriteFmt("Testing BitVecReplaceAll basic functionality\n");
    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();

In BitVec.Pattern.Simple.c:688:

    
        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.Simple.c:689:

        BitVec source      = BitVecInit();
        BitVec old_pattern = BitVecInit();
        BitVec new_pattern = BitVecInit();
        bool   result      = true;

In BitVec.Pattern.Simple.c:724:

        WriteFmt("Testing BitVecMatches basic functionality\n");
    
        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();

In BitVec.Pattern.Simple.c:725:

    
        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        bool   result   = true;

In BitVec.Pattern.Simple.c:726:

        BitVec source   = BitVecInit();
        BitVec pattern  = BitVecInit();
        BitVec wildcard = BitVecInit();
        bool   result   = true;

In BitVec.Pattern.Simple.c:759:

        WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");
    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:760:

    
        BitVec source  = BitVecInit();
        BitVec pattern = BitVecInit();
        bool   result  = true;

In BitVec.Pattern.Simple.c:795:

        WriteFmt("Testing BitVecRegexMatch basic functionality\n");
    
        BitVec source = BitVecInit();
        bool   result = true;

In BitVec.Pattern.Simple.c:818:

        WriteFmt("Testing BitVecPrefixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit();
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit);
        bool    result   = true;

In BitVec.Pattern.Simple.c:836:

        BitVec *p2 = VecPtrAt(&patterns, 2);
    
        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();

In BitVec.Pattern.Simple.c:837:

    
        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();

In BitVec.Pattern.Simple.c:838:

        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();
    
        // Pattern 0: 111 (should not match)

In BitVec.Pattern.Simple.c:867:

        WriteFmt("Testing BitVecSuffixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit();
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit);
        bool    result   = true;

In BitVec.Pattern.Simple.c:885:

        BitVec *p2 = VecPtrAt(&patterns, 2);
    
        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();

In BitVec.Pattern.Simple.c:886:

    
        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();

In BitVec.Pattern.Simple.c:887:

        *p0 = BitVecInit();
        *p1 = BitVecInit();
        *p2 = BitVecInit();
    
        // Pattern 0: 111 (should not match)

In Init.h:103:

            })
    #else
    #    define BitVecInit(...) CONCAT(BitVecInit_, BITVEC_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #    define BitVecInit_0()                                                                                             \
            ((BitVec) {.length    = 0,                                                                                     \

In Init.h:24:

        Int value;
    
        value.bits = BitVecInit(alloc);
        return value;
    }

Last updated on May 14, 2026

BitVecHammingDistance BitVecInitWithCapacity