BitVecGet

Documentation

API Reference

BitVecGet

Description

Get the value of bit at given index in bitvector.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to get bit from
`idx`	in	Index of bit to get (0-based)

Usage example (from documentation)

  bool flag = BitVecGet(&flags, 5);

Returns

true if bit is set, false otherwise

Usage example (Cross-references)

Usage examples (Cross-references)

In Int.c:38:

    
        for (u64 i = value->bits.length; i > 0; i--) {
            if (BitVecGet(INT_BITS(value), i - 1)) {
                return i;
            }

In Int.c:160:

    static bool int_is_odd(Int *value) {
        ValidateInt(value);
        return value->bits.length > 0 && BitVecGet(INT_BITS(value), 0);
    }

In Int.c:165:

    static bool int_is_one(Int *value) {
        ValidateInt(value);
        return IntBitLength(value) == 1 && BitVecGet(INT_BITS(value), 0);
    }

In Int.c:307:

    
        for (u64 i = 0; i < value->bits.length; i++) {
            if (BitVecGet(INT_BITS(value), i)) {
                return i;
            }

In Int.c:418:

                u64 bit_idx = i * 8 + bit;
    
                if (bit_idx < value->bits.length && BitVecGet(INT_BITS(value), bit_idx)) {
                    byte |= (u8)(1u << bit);
                }

In Int.c:470:

                u64 bit_idx = i * 8 + bit;
    
                if (bit_idx < value->bits.length && BitVecGet(INT_BITS(value), bit_idx)) {
                    byte |= (u8)(1u << bit);
                }

In Int.c:609:

    
        for (u64 i = lhs_bits; i > 0; i--) {
            bool lhs_bit = BitVecGet(INT_BITS(lhs), i - 1);
            bool rhs_bit = BitVecGet(INT_BITS(rhs), i - 1);

In Int.c:610:

        for (u64 i = lhs_bits; i > 0; i--) {
            bool lhs_bit = BitVecGet(INT_BITS(lhs), i - 1);
            bool rhs_bit = BitVecGet(INT_BITS(rhs), i - 1);
    
            if (lhs_bit != rhs_bit) {

In Int.c:666:

    
        for (u64 i = bits; i > 0; i--) {
            BitVecSet(INT_BITS(value), i - 1 + positions, BitVecGet(INT_BITS(value), i - 1));
        }

In Int.c:689:

    
        for (u64 i = 0; i + positions < bits; i++) {
            BitVecSet(INT_BITS(value), i, BitVecGet(INT_BITS(value), i + positions));
        }

In Int.c:710:

            u64 sum = carry ? 1u : 0u;
    
            if (i < a_bits && BitVecGet(INT_BITS(a), i)) {
                sum++;
            }

In Int.c:713:

                sum++;
            }
            if (i < b_bits && BitVecGet(INT_BITS(b), i)) {
                sum++;
            }

In Int.c:771:

    
        for (u64 i = 0; i < a_bits; i++) {
            int ai   = (i < a_bits && BitVecGet(INT_BITS(a), i)) ? 1 : 0;
            int bi   = (i < b_bits && BitVecGet(INT_BITS(b), i)) ? 1 : 0;
            int diff = ai - bi - (borrow ? 1 : 0);

In Int.c:772:

        for (u64 i = 0; i < a_bits; i++) {
            int ai   = (i < a_bits && BitVecGet(INT_BITS(a), i)) ? 1 : 0;
            int bi   = (i < b_bits && BitVecGet(INT_BITS(b), i)) ? 1 : 0;
            int diff = ai - bi - (borrow ? 1 : 0);

In Int.c:831:

    
        for (u64 i = 0; i < b_bits; i++) {
            if (!BitVecGet(INT_BITS(b), i)) {
                continue;
            }

In BitVec.c:179:

        // Copy all bits
        for (u64 i = 0; i < bv->length; i++) {
            bool bit = BitVecGet(bv, i);
            BitVecSet(&clone, i, bit);
        }

In BitVec.c:186:

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

In BitVec.c:239:

            LOG_FATAL("Cannot pop from empty bitvector");
        }
        bool value = BitVecGet(bitvec, bitvec->length - 1);
        BitVecResize(bitvec, bitvec->length - 1);
        return value;

In BitVec.c:254:

        // Shift bits right from idx to end
        for (u64 i = bitvec->length - 1; i > idx; i--) {
            bool bit = BitVecGet(bitvec, i - 1);
            BitVecSet(bitvec, i, bit);
        }

In BitVec.c:277:

        for (u64 i = old_length; i > idx;) {
            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + count, bit);
        }

In BitVec.c:304:

        for (u64 i = old_length; i > idx;) {
            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + other->length, bit);
        }

In BitVec.c:310:

        // Insert bits from other bitvector
        for (u64 i = 0; i < other->length; i++) {
            bool bit = BitVecGet(other, i);
            BitVecSet(bv, idx + i, bit);
        }

In BitVec.c:331:

        for (u64 i = old_length; i > idx;) {
            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + pattern_bits, bit);
        }

In BitVec.c:349:

    
        // Get the bit value before removing it
        bool removed_bit = BitVecGet(bv, idx);
    
        // Shift bits left from idx+1 to end

In BitVec.c:353:

        // Shift bits left from idx+1 to end
        for (u64 i = idx; i < bv->length - 1; i++) {
            bool bit = BitVecGet(bv, i + 1);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:377:

        // Shift bits left to close the gap
        for (u64 i = idx + count; i < bv->length; i++) {
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i - count, bit);
        }

In BitVec.c:417:

        // Compact the bitvector by copying only bits that don't match the value
        for (u64 read_idx = 0; read_idx < bv->length; read_idx++) {
            bool bit = BitVecGet(bv, read_idx);
            if (bit != value) {
                // Keep this bit

In BitVec.c:442:

        u64 count = 0;
        for (u64 i = 0; i < bitvec->length; i++) {
            if (BitVecGet(bitvec, i)) {
                count++;
            }

In BitVec.c:463:

    
        for (u64 i = 0; i < min_len; i++) {
            bool bit_a = BitVecGet(a, i);
            bool bit_b = BitVecGet(b, i);
            BitVecSet(result, i, bit_a && bit_b);

In BitVec.c:464:

        for (u64 i = 0; i < min_len; i++) {
            bool bit_a = BitVecGet(a, i);
            bool bit_b = BitVecGet(b, i);
            BitVecSet(result, i, bit_a && bit_b);
        }

In BitVec.c:478:

    
        for (u64 i = 0; i < max_len; i++) {
            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a || bit_b);

In BitVec.c:479:

        for (u64 i = 0; i < max_len; i++) {
            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a || bit_b);
        }

In BitVec.c:493:

    
        for (u64 i = 0; i < max_len; i++) {
            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a != bit_b);

In BitVec.c:494:

        for (u64 i = 0; i < max_len; i++) {
            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a != bit_b);
        }

In BitVec.c:506:

    
        for (u64 i = 0; i < bitvec->length; i++) {
            bool bit = BitVecGet(bitvec, i);
            BitVecSet(result, i, !bit);
        }

In BitVec.c:535:

    
        for (u64 i = 0; i < len; i++) {
            if (BitVecGet(bv1, start1 + i) != BitVecGet(bv2, start2 + i)) {
                return false;
            }

In BitVec.c:578:

        // Compare bit by bit in the specified range
        for (u64 i = 0; i < len; i++) {
            bool bit1 = BitVecGet(bv1, start1 + i);
            bool bit2 = BitVecGet(bv2, start2 + i);

In BitVec.c:579:

        for (u64 i = 0; i < len; i++) {
            bool bit1 = BitVecGet(bv1, start1 + i);
            bool bit2 = BitVecGet(bv2, start2 + i);
    
            if (bit1 != bit2) {

In BitVec.c:601:

        for (u64 i = max_len; i > 0;) {
            i--;
            bool bit1 = i < bv1->length ? BitVecGet(bv1, i) : false;
            bool bit2 = i < bv2->length ? BitVecGet(bv2, i) : false;

In BitVec.c:602:

            i--;
            bool bit1 = i < bv1->length ? BitVecGet(bv1, i) : false;
            bool bit2 = i < bv2->length ? BitVecGet(bv2, i) : false;
    
            if (bit1 != bit2) {

In BitVec.c:637:

    
        // Get sign bits (MSB)
        bool sign1 = bv1->length > 0 ? BitVecGet(bv1, bv1->length - 1) : false;
        bool sign2 = bv2->length > 0 ? BitVecGet(bv2, bv2->length - 1) : false;

In BitVec.c:638:

        // Get sign bits (MSB)
        bool sign1 = bv1->length > 0 ? BitVecGet(bv1, bv1->length - 1) : false;
        bool sign2 = bv2->length > 0 ? BitVecGet(bv2, bv2->length - 1) : false;
    
        // If signs differ, negative < positive

In BitVec.c:664:

    
        for (u64 i = 0; i < max_len; i++) {
            bool bit1 = i < bv1->length ? BitVecGet(bv1, i) : false;
            bool bit2 = i < bv2->length ? BitVecGet(bv2, i) : false;

In BitVec.c:665:

        for (u64 i = 0; i < max_len; i++) {
            bool bit1 = i < bv1->length ? BitVecGet(bv1, i) : false;
            bool bit2 = i < bv2->length ? BitVecGet(bv2, i) : false;
    
            // If bv1 has a 1-bit where bv2 has a 0-bit, bv1 is not a subset

In BitVec.c:688:

    
        for (u64 i = 0; i < min_len; i++) {
            if (BitVecGet(bv1, i) && BitVecGet(bv2, i)) {
                return false; // Found common 1-bit
            }

In BitVec.c:710:

    
        for (u64 i = 0; i < bv->length; i++) {
            bool bit = BitVecGet(bv, i);
    
            if (bit) {

In BitVec.c:737:

        // Convert each bit to '0' or '1'
        for (u64 i = 0; i < bv->length; i++) {
            char bit_char = BitVecGet(bv, i) ? '1' : '0';
            StrPushBack(&result, bit_char);
        }

In BitVec.c:786:

        // Copy bits to bytes
        for (u64 i = 0; i < bv->length && i / 8 < bytes_to_copy; i++) {
            if (BitVecGet(bv, i)) {
                u64 byte_idx     = i / 8;
                u64 bit_offset   = i % 8;

In BitVec.c:833:

        // Convert bits to integer (LSB first)
        for (u64 i = 0; i < max_bits; i++) {
            if (BitVecGet(bv, i)) {
                result |= (1ULL << i);
            }

In BitVec.c:879:

        // Shift bits left (move bits to higher indices)
        for (u64 i = bv->length - 1; i >= positions; i--) {
            bool bit = BitVecGet(bv, i - positions);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:903:

        // Shift bits right (move bits to lower indices)
        for (u64 i = 0; i < bv->length - positions; i++) {
            bool bit = BitVecGet(bv, i + positions);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:930:

        for (u64 i = 0; i < bv->length; i++) {
            u64  src_idx = (i + positions) % bv->length;
            bool bit     = BitVecGet(&temp, src_idx);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:954:

        for (u64 i = 0; i < bv->length; i++) {
            u64  src_idx = (i + bv->length - positions) % bv->length;
            bool bit     = BitVecGet(&temp, src_idx);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:970:

        for (u64 i = 0; i < bv->length / 2; i++) {
            u64  j     = bv->length - 1 - i;
            bool bit_i = BitVecGet(bv, i);
            bool bit_j = BitVecGet(bv, j);
            BitVecSet(bv, i, bit_j);

In BitVec.c:971:

            u64  j     = bv->length - 1 - i;
            bool bit_i = BitVecGet(bv, i);
            bool bit_j = BitVecGet(bv, j);
            BitVecSet(bv, i, bit_j);
            BitVecSet(bv, j, bit_i);

In BitVec.c:983:

    
        for (u64 i = 0; i < bv->length; i++) {
            if (BitVecGet(bv, i) == value) {
                return i;
            }

In BitVec.c:998:

    
        for (u64 i = bv->length - 1; i < bv->length; i--) { // i < bv->length handles underflow
            if (BitVecGet(bv, i) == value) {
                return i;
            }

In BitVec.c:1011:

    
        for (u64 i = 0; i < bv->length; i++) {
            if (BitVecGet(bv, i) != value) {
                return false;
            }

In BitVec.c:1038:

    
        for (u64 i = 0; i < bv->length; i++) {
            if (BitVecGet(bv, i) == value) {
                current_run++;
                if (current_run > max_run) {

In BitVec.c:1126:

        u64  run_count          = 0;
        u64  current_run_length = 1;
        bool current_value      = BitVecGet(bv, 0);
    
        for (u64 i = 1; i < bv->length; i++) {

In BitVec.c:1129:

    
        for (u64 i = 1; i < bv->length; i++) {
            bool bit = BitVecGet(bv, i);
            if (bit == current_value) {
                current_run_length++;

In BitVec.c:1171:

        // Count differences in overlapping region
        for (u64 i = 0; i < min_length; i++) {
            if (BitVecGet(bv1, i) != BitVecGet(bv2, i)) {
                distance++;
            }

In BitVec.c:1198:

    
        for (u64 i = 0; i < max_length; i++) {
            bool bit1 = (i < bv1->length) ? BitVecGet(bv1, i) : false;
            bool bit2 = (i < bv2->length) ? BitVecGet(bv2, i) : false;

In BitVec.c:1199:

        for (u64 i = 0; i < max_length; i++) {
            bool bit1 = (i < bv1->length) ? BitVecGet(bv1, i) : false;
            bool bit2 = (i < bv2->length) ? BitVecGet(bv2, i) : false;
    
            if (bit1 || bit2) {

In BitVec.c:1235:

    
        for (u64 i = 0; i < min_length; i++) {
            if (BitVecGet(bv1, i) && BitVecGet(bv2, i)) {
                product++;
            }

In BitVec.c:1274:

    
            for (u64 j = 1; j <= len2; j++) {
                u64 cost = BitVecGet(bv1, i - 1) == BitVecGet(bv2, j - 1) ? 0 : 1;
    
                u64 deletion     = prev_row[j] + 1;

In BitVec.c:1308:

    
        for (u64 i = 0; i < max_length; i++) {
            double val1 = (i < bv1->length && BitVecGet(bv1, i)) ? 1.0 : 0.0;
            double val2 = (i < bv2->length && BitVecGet(bv2, i)) ? 1.0 : 0.0;

In BitVec.c:1309:

        for (u64 i = 0; i < max_length; i++) {
            double val1 = (i < bv1->length && BitVecGet(bv1, i)) ? 1.0 : 0.0;
            double val2 = (i < bv2->length && BitVecGet(bv2, i)) ? 1.0 : 0.0;
    
            sum1        += val1;

In BitVec.c:1351:

    
        for (u64 i = 0; i < min_length; i++) {
            if (BitVecGet(bv1, i) == BitVecGet(bv2, i)) {
                score += match;
            } else {

In BitVec.c:1378:

    
            for (u64 i = 0; i < bv2->length && (offset + i) < bv1->length; i++) {
                if (BitVecGet(bv1, offset + i) == BitVecGet(bv2, i)) {
                    score++;
                } else {

In BitVec.c:1431:

    
        for (u64 i = 0; i < pattern->length; i++) {
            if (BitVecGet(bv, idx + i) != BitVecGet(pattern, i)) {
                return false;
            }

In BitVec.c:1492:

        // Insert new pattern
        for (u64 i = 0; i < new_pattern->length; i++) {
            BitVecInsert(bv, pos + i, BitVecGet(new_pattern, i));
        }

In BitVec.c:1529:

            // Insert new pattern
            for (u64 i = 0; i < new_pattern->length; i++) {
                BitVecInsert(bv, match_pos + i, BitVecGet(new_pattern, i));
            }

In BitVec.c:1549:

    
        for (u64 i = 0; i < bv->length; i++) {
            if (!BitVecGet(wildcard, i)) { // Not a wildcard position
                if (BitVecGet(bv, i) != BitVecGet(pattern, i)) {
                    return false;

In BitVec.c:1550:

        for (u64 i = 0; i < bv->length; i++) {
            if (!BitVecGet(wildcard, i)) { // Not a wildcard position
                if (BitVecGet(bv, i) != BitVecGet(pattern, i)) {
                    return false;
                }

In BitVec.c:1570:

            u64 errors = 0;
            for (u64 j = 0; j < pattern->length; j++) {
                if (BitVecGet(bv, i + j) != BitVecGet(pattern, j)) {
                    errors++;
                    if (errors > max_errors) {

In BitVec.Access.Simple.c:34:

    // Test BitVecGet function
    bool test_bitvec_get(void) {
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit();

In BitVec.Access.Simple.c:45:

    
        // Test getting bits
        bool result = (BitVecGet(&bv, 0) == true) && (BitVecGet(&bv, 1) == false) && (BitVecGet(&bv, 2) == true) &&
                      (BitVecGet(&bv, 3) == false);

In BitVec.Access.Simple.c:46:

        // Test getting bits
        bool result = (BitVecGet(&bv, 0) == true) && (BitVecGet(&bv, 1) == false) && (BitVecGet(&bv, 2) == true) &&
                      (BitVecGet(&bv, 3) == false);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:66:

    
        // Test getting the set bits
        bool result = (BitVecGet(&bv, 0) == true) && (BitVecGet(&bv, 1) == false) && (BitVecGet(&bv, 2) == true) &&
                      (BitVecGet(&bv, 3) == false);

In BitVec.Access.Simple.c:67:

        // Test getting the set bits
        bool result = (BitVecGet(&bv, 0) == true) && (BitVecGet(&bv, 1) == false) && (BitVecGet(&bv, 2) == true) &&
                      (BitVecGet(&bv, 3) == false);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:90:

    
        // Test the flipped bits
        bool result = (BitVecGet(&bv, 0) == false) && // was true, now false
                      (BitVecGet(&bv, 1) == true) &&  // was false, now true
                      (BitVecGet(&bv, 2) == true) &&  // unchanged

In BitVec.Access.Simple.c:91:

        // Test the flipped bits
        bool result = (BitVecGet(&bv, 0) == false) && // was true, now false
                      (BitVecGet(&bv, 1) == true) &&  // was false, now true
                      (BitVecGet(&bv, 2) == true) &&  // unchanged
                      (BitVecGet(&bv, 3) == false);   // unchanged

In BitVec.Access.Simple.c:92:

        bool result = (BitVecGet(&bv, 0) == false) && // was true, now false
                      (BitVecGet(&bv, 1) == true) &&  // was false, now true
                      (BitVecGet(&bv, 2) == true) &&  // unchanged
                      (BitVecGet(&bv, 3) == false);   // unchanged

In BitVec.Access.Simple.c:93:

                      (BitVecGet(&bv, 1) == true) &&  // was false, now true
                      (BitVecGet(&bv, 2) == true) &&  // unchanged
                      (BitVecGet(&bv, 3) == false);   // unchanged
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:147:

    // Edge case tests for BitVecGet
    bool test_bitvec_get_edge_cases(void) {
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.Simple.c:154:

        // Test with single bit
        BitVecPush(&bv, true);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test with larger index

In BitVec.Access.Simple.c:161:

        }
    
        result = result && (BitVecGet(&bv, 63) == false); // 63 % 2 == 1, so i%2==0 is false for i=63
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:176:

        BitVecResize(&bv, 1);
        BitVecSet(&bv, 0, true);
        bool result = (BitVecGet(&bv, 0) == true);
    
        // Set same bit to false

In BitVec.Access.Simple.c:180:

        // Set same bit to false
        BitVecSet(&bv, 0, false);
        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:195:

        BitVecPush(&bv, false);
        BitVecFlip(&bv, 0);
        bool result = (BitVecGet(&bv, 0) == true);
    
        // Flip it again

In BitVec.Access.Simple.c:199:

        // Flip it again
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:249:

    
        // Verify pattern: T F T F T
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.Simple.c:250:

        // Verify pattern: T F T F T
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == false);

In BitVec.Access.Simple.c:251:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == false);
        result = result && (BitVecGet(&bv, 4) == true);

In BitVec.Access.Simple.c:252:

        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == false);
        result = result && (BitVecGet(&bv, 4) == true);

In BitVec.Access.Simple.c:253:

        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == false);
        result = result && (BitVecGet(&bv, 4) == true);
    
        // Count and verify

In BitVec.Access.Simple.c:283:

    
        // Verify some positions
        result = result && (BitVecGet(&bv, 0) == true);    // 0 % 2 == 0
        result = result && (BitVecGet(&bv, 1) == false);   // 1 % 2 != 0
        result = result && (BitVecGet(&bv, 500) == true);  // 500 % 2 == 0

In BitVec.Access.Simple.c:284:

        // Verify some positions
        result = result && (BitVecGet(&bv, 0) == true);    // 0 % 2 == 0
        result = result && (BitVecGet(&bv, 1) == false);   // 1 % 2 != 0
        result = result && (BitVecGet(&bv, 500) == true);  // 500 % 2 == 0
        result = result && (BitVecGet(&bv, 999) == false); // 999 % 2 != 0

In BitVec.Access.Simple.c:285:

        result = result && (BitVecGet(&bv, 0) == true);    // 0 % 2 == 0
        result = result && (BitVecGet(&bv, 1) == false);   // 1 % 2 != 0
        result = result && (BitVecGet(&bv, 500) == true);  // 500 % 2 == 0
        result = result && (BitVecGet(&bv, 999) == false); // 999 % 2 != 0

In BitVec.Access.Simple.c:286:

        result = result && (BitVecGet(&bv, 1) == false);   // 1 % 2 != 0
        result = result && (BitVecGet(&bv, 500) == true);  // 500 % 2 == 0
        result = result && (BitVecGet(&bv, 999) == false); // 999 % 2 != 0
    
        // Verify counts

In BitVec.Access.Simple.c:324:

        BitVecSet(&bv, 1, true);
    
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);

In BitVec.Access.Simple.c:325:

    
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);
    
        // Test count operations

In BitVec.Access.Simple.c:354:

        // Verify pattern
        for (int i = 0; i < size && result; i++) {
            result = result && (BitVecGet(&bv, i) == (i % 3 == 0));
        }

In BitVec.Access.Simple.c:378:

                expected = !expected; // Flipped
            }
            result = result && (BitVecGet(&bv, i) == expected);
        }

In BitVec.Access.Simple.c:432:

        for (int i = 0; i < 100 && result; i++) {
            bool expected = (i * 17 + 3) % 7 < 3;
            result        = result && (BitVecGet(&bv, i) == expected);
        }

In BitVec.Access.Deadend.c:59:

    
        // Test NULL bitvec pointer - should abort
        BitVecGet(NULL, 0);
    
        return false;

In BitVec.Access.Deadend.c:88:

    
        // Test get from empty bitvec - should abort
        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.Deadend.c:128:

    
        // Test with index way beyond length (3) - should abort
        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);

In BitVec.Access.Deadend.c:179:

    
        // Test with maximum possible index value - should abort
        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);

In BitVec.Remove.c:42:

        // Check result
        bool result = (popped == true) && (bv.length == 2);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);

In BitVec.Remove.c:43:

        bool result = (popped == true) && (bv.length == 2);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
    
        // Pop another bit

In BitVec.Remove.c:48:

        popped = BitVecPop(&bv);
        result = result && (popped == false) && (bv.length == 1);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Pop the last bit

In BitVec.Remove.c:78:

        // Check result: true, false, false, true
        bool result = (removed == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == false);

In BitVec.Remove.c:79:

        bool result = (removed == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:80:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:81:

        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);
    
        // Remove bit at index 0 (first bit)

In BitVec.Remove.c:86:

        removed = BitVecRemove(&bv, 0);
        result  = result && (removed == true) && (bv.length == 3);
        result  = result && (BitVecGet(&bv, 0) == false);
        result  = result && (BitVecGet(&bv, 1) == false);
        result  = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:87:

        result  = result && (removed == true) && (bv.length == 3);
        result  = result && (BitVecGet(&bv, 0) == false);
        result  = result && (BitVecGet(&bv, 1) == false);
        result  = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:88:

        result  = result && (BitVecGet(&bv, 0) == false);
        result  = result && (BitVecGet(&bv, 1) == false);
        result  = result && (BitVecGet(&bv, 2) == true);
    
        // Clean up

In BitVec.Remove.c:115:

        // Check result: true, false, true (removed false, true, true)
        bool result = (bv.length == 3);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:116:

        bool result = (bv.length == 3);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:117:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
    
        // Clean up

In BitVec.Remove.c:143:

        // Check result: true, true, false, true (removed first false at index 1)
        bool result = (found == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);

In BitVec.Remove.c:144:

        bool result = (found == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:145:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:146:

        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);
        result      = result && (BitVecGet(&bv, 3) == true);
    
        // Try to remove first occurrence of a value that doesn't exist (after removal)

In BitVec.Remove.c:180:

        // Check result: true, false, true, true (removed last false at index 3)
        bool result = (found == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:181:

        bool result = (found == true) && (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:182:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Remove.c:183:

        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
    
        // Remove last occurrence of true

In BitVec.Remove.c:190:

        // Check result: true, false, true (removed last true at index 3)
        result = result && (found == true) && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:191:

        result = result && (found == true) && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:192:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
    
        // Clean up

In BitVec.Remove.c:219:

        // Check result: true, true, true (all false bits removed)
        bool result = (removed_count == 3) && (bv.length == 3);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:220:

        bool result = (removed_count == 3) && (bv.length == 3);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Remove.c:221:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
    
        // Try to remove all false bits again (should return 0)

In BitVec.Init.c:129:

        BitVecPush(&bv, true);
        result = result && (bv.length == 1);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Clean up

In BitVec.Init.c:153:

        // Check that length was increased and new bits have the default value
        bool result = (bv.length == 6);
        result      = result && (BitVecGet(&bv, 0) == true);  // Original data
        result      = result && (BitVecGet(&bv, 1) == false); // Original data
        result      = result && (BitVecGet(&bv, 2) == true);  // Original data

In BitVec.Init.c:154:

        bool result = (bv.length == 6);
        result      = result && (BitVecGet(&bv, 0) == true);  // Original data
        result      = result && (BitVecGet(&bv, 1) == false); // Original data
        result      = result && (BitVecGet(&bv, 2) == true);  // Original data
        result      = result && (BitVecGet(&bv, 3) == false); // New data (likely default to false)

In BitVec.Init.c:155:

        result      = result && (BitVecGet(&bv, 0) == true);  // Original data
        result      = result && (BitVecGet(&bv, 1) == false); // Original data
        result      = result && (BitVecGet(&bv, 2) == true);  // Original data
        result      = result && (BitVecGet(&bv, 3) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 4) == false); // New data (likely default to false)

In BitVec.Init.c:156:

        result      = result && (BitVecGet(&bv, 1) == false); // Original data
        result      = result && (BitVecGet(&bv, 2) == true);  // Original data
        result      = result && (BitVecGet(&bv, 3) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 4) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 5) == false); // New data (likely default to false)

In BitVec.Init.c:157:

        result      = result && (BitVecGet(&bv, 2) == true);  // Original data
        result      = result && (BitVecGet(&bv, 3) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 4) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 5) == false); // New data (likely default to false)

In BitVec.Init.c:158:

        result      = result && (BitVecGet(&bv, 3) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 4) == false); // New data (likely default to false)
        result      = result && (BitVecGet(&bv, 5) == false); // New data (likely default to false)
    
        // Test resizing to smaller size

In BitVec.Init.c:165:

        // Check that length was decreased and data was truncated
        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);  // Original data preserved
        result = result && (BitVecGet(&bv, 1) == false); // Original data preserved

In BitVec.Init.c:166:

        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);  // Original data preserved
        result = result && (BitVecGet(&bv, 1) == false); // Original data preserved
    
        // Test resizing to same size (should be no-op)

In BitVec.Init.c:243:

        // New bits should be false
        for (u64 i = 0; i < 5; i++) {
            result = result && (BitVecGet(&bv, i) == false);
        }

In BitVec.BitWise.Simple.c:56:

        // Expected result: 1000 (1101 AND 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);

In BitVec.BitWise.Simple.c:57:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:58:

        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:59:

        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:94:

        // Expected result: 1110 (1100 OR 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);

In BitVec.BitWise.Simple.c:95:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:96:

        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:97:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:132:

        // Expected result: 0110 (1100 XOR 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);

In BitVec.BitWise.Simple.c:133:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:134:

        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.Simple.c:135:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:163:

        // Expected result: 0101 (NOT 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);

In BitVec.BitWise.Simple.c:164:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);

In BitVec.BitWise.Simple.c:165:

        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);

In BitVec.BitWise.Simple.c:166:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);
    
        // Clean up

In BitVec.BitWise.Simple.c:205:

        // New bit[1] = 0 (filled)
        // Expected result: 0010
        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.Simple.c:206:

        // Expected result: 0010
        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:207:

        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:208:

        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:239:

    
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.Simple.c:240:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:241:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:242:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:267:

        // Expected result: 1110 (1011 rotated left by 2)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.Simple.c:268:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:269:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.Simple.c:270:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.Simple.c:295:

        // Expected result: 1101 (1011 rotated right by 1)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.Simple.c:296:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.Simple.c:297:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.Simple.c:298:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);
    
        // Clean up

In BitVec.BitWise.Simple.c:323:

        // Expected result: 1101 (1011 reversed)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.Simple.c:324:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.Simple.c:325:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.Simple.c:326:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);
    
        // Clean up

In BitVec.BitWise.Simple.c:353:

        BitVecShiftLeft(&bv, 0);
        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test shift larger than length (should clear all bits)

In BitVec.BitWise.Simple.c:384:

        BitVecPush(&bv, true);
        BitVecRotateRight(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test rotate by length (should be no-op)

In BitVec.BitWise.Simple.c:429:

        BitVecPush(&bv1, true);
        BitVecNot(&result_bv, &bv1);
        result = result && (BitVecGet(&result_bv, 0) == false);
    
        BitVecDeinit(&result_bv);

In BitVec.BitWise.Simple.c:452:

        BitVecReverse(&bv);
        result = result && (bv.length == 1);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test reverse even length

In BitVec.BitWise.Simple.c:459:

        BitVecPush(&bv, false);
        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);

In BitVec.BitWise.Simple.c:460:

        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);
    
        // Test double reverse (should restore original)

In BitVec.BitWise.Simple.c:464:

        // Test double reverse (should restore original)
        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);

In BitVec.BitWise.Simple.c:465:

        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.Simple.c:510:

        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (result.length == 1);
        test_result = test_result && (BitVecGet(&result, 0) == false);
    
        BitVecOr(&result, &bv1, &bv2);

In BitVec.BitWise.Simple.c:513:

    
        BitVecOr(&result, &bv1, &bv2);
        test_result = test_result && (BitVecGet(&result, 0) == true);
    
        // Test NOT on large bitvector

In BitVec.BitWise.Simple.c:526:

        // Verify NOT correctness
        for (int i = 0; i < 100; i++) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);

In BitVec.BitWise.Simple.c:527:

        for (int i = 0; i < 100; i++) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);
        }

In BitVec.BitWise.Simple.c:561:

        bool changed = false;
        for (int i = 0; i < (int)original.length; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                changed = true;
                break;

In BitVec.BitWise.Simple.c:594:

        BitVecShiftLeft(&bv, 2);
        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0

In BitVec.BitWise.Simple.c:595:

        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0

In BitVec.BitWise.Simple.c:596:

        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0
    
        BitVecDeinit(&bv);

In BitVec.BitWise.Simple.c:625:

        bool restored = true;
        for (int i = 0; i < 8; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                restored = false;
                break;

In BitVec.BitWise.Simple.c:637:

        bool unchanged = true;
        for (int i = 0; i < 8; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                unchanged = false;
                break;

In BitVec.BitWise.Simple.c:654:

        BitVecRotateLeft(&bv, 2);
        // 10101 -> 10110 (rotated left by 2)
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.Simple.c:655:

        // 10101 -> 10110 (rotated left by 2)
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.Simple.c:656:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.BitWise.Simple.c:657:

        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.BitWise.Simple.c:658:

        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.Simple.c:683:

        bool and_identity = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                and_identity = false;
                break;

In BitVec.BitWise.Simple.c:694:

        bool or_identity = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                or_identity = false;
                break;

In BitVec.BitWise.Simple.c:705:

        test_result = test_result && (result.length == 16);
        for (int i = 0; i < 16; i++) {
            test_result = test_result && (BitVecGet(&result, i) == false);
        }

In BitVec.BitWise.Simple.c:714:

        bool double_not = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                double_not = false;
                break;

In BitVec.BitWise.Simple.c:730:

        bool and_zero = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != false) {
                and_zero = false;
                break;

In BitVec.BitWise.Simple.c:746:

        bool or_ones = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != true) {
                or_ones = false;
                break;

In BitVec.BitWise.Simple.c:781:

        bool and_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                and_commutative = false;
                break;

In BitVec.BitWise.Simple.c:794:

        bool or_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                or_commutative = false;
                break;

In BitVec.BitWise.Simple.c:807:

        bool xor_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                xor_commutative = false;
                break;

In BitVec.BitWise.Simple.c:843:

        for (int i = 0; i < 1000; i += 77) { // Check every 77th bit
            bool expected = (i % 7 == 0) && (i % 11 == 0);
            bool actual   = BitVecGet(&result, i);
            test_result   = test_result && (expected == actual);
        }

In BitVec.BitWise.Simple.c:857:

        // Verify NOT correctness on sample
        for (int i = 0; i < 1000; i += 123) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);

In BitVec.BitWise.Simple.c:858:

        for (int i = 0; i < 1000; i += 123) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);
        }

In BitVec.BitWise.Simple.c:873:

        // First 100 bits should be 0
        for (int i = 0; i < 100; i++) {
            test_result = test_result && (BitVecGet(&result, i) == false);
        }

In BitVec.Memory.c:50:

        // Check that data is still intact
        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Memory.c:51:

        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Memory.c:52:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
    
        // Clean up

In BitVec.Memory.c:77:

    
        // Check that data is still intact
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);

In BitVec.Memory.c:78:

        // Check that data is still intact
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
    
        // Try to set capacity smaller than current length (should not shrink below length)

In BitVec.Memory.c:88:

    
        // Data should still be intact
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);

In BitVec.Memory.c:89:

        // Data should still be intact
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
    
        // Clean up

In BitVec.Memory.c:125:

        // Check bv1 (should now have bv2's original content)
        result = result && (bv1.length == 2);
        result = result && (BitVecGet(&bv1, 0) == false);
        result = result && (BitVecGet(&bv1, 1) == false);

In BitVec.Memory.c:126:

        result = result && (bv1.length == 2);
        result = result && (BitVecGet(&bv1, 0) == false);
        result = result && (BitVecGet(&bv1, 1) == false);
    
        // Check bv2 (should now have bv1's original content)

In BitVec.Memory.c:130:

        // Check bv2 (should now have bv1's original content)
        result = result && (bv2.length == 3);
        result = result && (BitVecGet(&bv2, 0) == true);
        result = result && (BitVecGet(&bv2, 1) == false);
        result = result && (BitVecGet(&bv2, 2) == true);

In BitVec.Memory.c:131:

        result = result && (bv2.length == 3);
        result = result && (BitVecGet(&bv2, 0) == true);
        result = result && (BitVecGet(&bv2, 1) == false);
        result = result && (BitVecGet(&bv2, 2) == true);

In BitVec.Memory.c:132:

        result = result && (BitVecGet(&bv2, 0) == true);
        result = result && (BitVecGet(&bv2, 1) == false);
        result = result && (BitVecGet(&bv2, 2) == true);
    
        // Clean up

In BitVec.Memory.c:160:

    
        for (u64 i = 0; i < original.length; i++) {
            result = result && (BitVecGet(&clone, i) == BitVecGet(&original, i));
        }

In BitVec.Memory.c:168:

        // Clone should remain unchanged
        result = result && (clone.length == 4) && (original.length == 5);
        result = result && (BitVecGet(&clone, 0) == true);
        result = result && (BitVecGet(&clone, 1) == false);
        result = result && (BitVecGet(&clone, 2) == true);

In BitVec.Memory.c:169:

        result = result && (clone.length == 4) && (original.length == 5);
        result = result && (BitVecGet(&clone, 0) == true);
        result = result && (BitVecGet(&clone, 1) == false);
        result = result && (BitVecGet(&clone, 2) == true);
        result = result && (BitVecGet(&clone, 3) == false);

In BitVec.Memory.c:170:

        result = result && (BitVecGet(&clone, 0) == true);
        result = result && (BitVecGet(&clone, 1) == false);
        result = result && (BitVecGet(&clone, 2) == true);
        result = result && (BitVecGet(&clone, 3) == false);

In BitVec.Memory.c:171:

        result = result && (BitVecGet(&clone, 1) == false);
        result = result && (BitVecGet(&clone, 2) == true);
        result = result && (BitVecGet(&clone, 3) == false);
    
        // Modify clone to verify independence

In BitVec.Memory.c:177:

    
        // Original should remain unchanged at index 0
        result = result && (BitVecGet(&original, 0) == true);
        result = result && (BitVecGet(&clone, 0) == false);

In BitVec.Memory.c:178:

        // Original should remain unchanged at index 0
        result = result && (BitVecGet(&original, 0) == true);
        result = result && (BitVecGet(&clone, 0) == false);
    
        // Clean up

In BitVec.Memory.c:202:

        BitVecShrinkToFit(&bv);
        result = result && (bv.length == 1) && (bv.capacity >= 1);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test multiple shrinks (should be safe)

In BitVec.Memory.c:245:

        result = result && (bv.length == original_length);
        for (u64 i = 0; i < bv.length; i++) {
            result = result && (BitVecGet(&bv, i) == (i % 2 == 0));
        }

In BitVec.Memory.c:274:

        result = result && (bv1.length == 0);
        result = result && (bv2.length == 2);
        result = result && (BitVecGet(&bv2, 0) == true);
        result = result && (BitVecGet(&bv2, 1) == false);

In BitVec.Memory.c:275:

        result = result && (bv2.length == 2);
        result = result && (BitVecGet(&bv2, 0) == true);
        result = result && (BitVecGet(&bv2, 1) == false);
    
        // Test swap with large data

In BitVec.Memory.c:285:

        BitVecSwap(&bv1, &bv2);
        result = result && (bv1.length == 2) && (bv2.length == 1000);
        result = result && (BitVecGet(&bv2, 0) == true); // 0 % 3 == 0
        result = result && (BitVecGet(&bv2, 999) == (999 % 3 == 0));

In BitVec.Memory.c:286:

        result = result && (bv1.length == 2) && (bv2.length == 1000);
        result = result && (BitVecGet(&bv2, 0) == true); // 0 % 3 == 0
        result = result && (BitVecGet(&bv2, 999) == (999 % 3 == 0));
    
        // Test swapping with itself (should be safe)

In BitVec.Memory.c:312:

        BitVec clone2 = BitVecClone(&bv);
        result        = result && (clone2.length == 1);
        result        = result && (BitVecGet(&clone2, 0) == true);
        BitVecDeinit(&clone2);

In BitVec.Memory.c:326:

        // Verify all bits match
        for (u64 i = 0; i < 1000; i++) {
            result = result && (BitVecGet(&clone3, i) == BitVecGet(&bv, i));
        }

In BitVec.Memory.c:330:

    
        // Test independence - modify original
        BitVecSet(&bv, 0, !BitVecGet(&bv, 0));
        result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));

In BitVec.Memory.c:331:

        // Test independence - modify original
        BitVecSet(&bv, 0, !BitVecGet(&bv, 0));
        result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));
    
        BitVecDeinit(&clone3);

In BitVec.Memory.c:365:

            result = result && (clone.length == cycle * 10);
            if (cycle > 0) {
                result = result && (BitVecGet(&clone, 0) == true); // 0 % 2 == 0
            }

In BitVec.Convert.c:72:

        // Check result
        bool result = (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Convert.c:73:

        bool result = (bv.length == 4);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Convert.c:74:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Convert.c:75:

        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
    
        // Test with empty string

In BitVec.Convert.c:137:

    
        for (u64 i = 0; i < bv.length; i++) {
            if (BitVecGet(&bv, i)) {
                true_count++;
            } else {

In BitVec.Convert.c:205:

    
        for (u64 i = 0; i < bv.length; i++) {
            if (BitVecGet(&bv, i)) {
                true_count++;
            } else {

In BitVec.Convert.c:222:

        bool all_false = true;
        for (u64 i = 0; i < zero_bv.length; i++) {
            if (BitVecGet(&zero_bv, i)) {
                all_false = false;
                break;

In BitVec.Convert.c:281:

        BitVec bv2 = BitVecFromStr("1");
        result     = result && (bv2.length == 1);
        result     = result && (BitVecGet(&bv2, 0) == true);
        BitVecDeinit(&bv2);

In BitVec.Convert.c:293:

        BitVec bv3 = BitVecFromStr(long_str);
        result     = result && (bv3.length == 1000);
        result     = result && (BitVecGet(&bv3, 0) == true);
        result     = result && (BitVecGet(&bv3, 1) == false);
        BitVecDeinit(&bv3);

In BitVec.Convert.c:294:

        result     = result && (bv3.length == 1000);
        result     = result && (BitVecGet(&bv3, 0) == true);
        result     = result && (BitVecGet(&bv3, 1) == false);
        BitVecDeinit(&bv3);

In BitVec.Convert.c:567:

        for (u64 i = 0; i < recovered_bv.length; i++) {
            bool expected = (i % 3) == 0;
            bool actual   = BitVecGet(&recovered_bv, i);
            if (expected != actual) {
                recovered_pattern_correct = false;

In BitVec.Convert.c:592:

        for (u64 i = 0; i < large_from_str.length; i++) {
            bool expected = (i % 7) == 0;
            bool actual   = BitVecGet(&large_from_str, i);
            if (expected != actual) {
                large_pattern_correct = false;

In BitVec.BitWise.c:56:

        // Expected result: 1000 (1101 AND 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);

In BitVec.BitWise.c:57:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:58:

        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:59:

        test_result      = test_result && (BitVecGet(&result, 1) == false);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:94:

        // Expected result: 1110 (1100 OR 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);

In BitVec.BitWise.c:95:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:96:

        test_result      = test_result && (BitVecGet(&result, 0) == true);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:97:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:132:

        // Expected result: 0110 (1100 XOR 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);

In BitVec.BitWise.c:133:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:134:

        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);

In BitVec.BitWise.c:135:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == true);
        test_result      = test_result && (BitVecGet(&result, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:163:

        // Expected result: 0101 (NOT 1010)
        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);

In BitVec.BitWise.c:164:

        bool test_result = (result.length == 4);
        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);

In BitVec.BitWise.c:165:

        test_result      = test_result && (BitVecGet(&result, 0) == false);
        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);

In BitVec.BitWise.c:166:

        test_result      = test_result && (BitVecGet(&result, 1) == true);
        test_result      = test_result && (BitVecGet(&result, 2) == false);
        test_result      = test_result && (BitVecGet(&result, 3) == true);
    
        // Clean up

In BitVec.BitWise.c:205:

        // New bit[1] = 0 (filled)
        // Expected result: 0010
        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.c:206:

        // Expected result: 0010
        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:207:

        test_result = test_result && (BitVecGet(&bv, 0) == false);
        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:208:

        test_result = test_result && (BitVecGet(&bv, 1) == false);
        test_result = test_result && (BitVecGet(&bv, 2) == true);
        test_result = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:239:

    
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.c:240:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:241:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:242:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:267:

        // Expected result: 1110 (1011 rotated left by 2)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.c:268:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:269:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);

In BitVec.BitWise.c:270:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == true);
        test_result      = test_result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.BitWise.c:295:

        // Expected result: 1101 (1011 rotated right by 1)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.c:296:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.c:297:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.c:298:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);
    
        // Clean up

In BitVec.BitWise.c:323:

        // Expected result: 1101 (1011 reversed)
        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);

In BitVec.BitWise.c:324:

        bool test_result = (bv.length == 4);
        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.c:325:

        test_result      = test_result && (BitVecGet(&bv, 0) == true);
        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.c:326:

        test_result      = test_result && (BitVecGet(&bv, 1) == true);
        test_result      = test_result && (BitVecGet(&bv, 2) == false);
        test_result      = test_result && (BitVecGet(&bv, 3) == true);
    
        // Clean up

In BitVec.BitWise.c:353:

        BitVecShiftLeft(&bv, 0);
        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test shift larger than length (should clear all bits)

In BitVec.BitWise.c:384:

        BitVecPush(&bv, true);
        BitVecRotateRight(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test rotate by length (should be no-op)

In BitVec.BitWise.c:429:

        BitVecPush(&bv1, true);
        BitVecNot(&result_bv, &bv1);
        result = result && (BitVecGet(&result_bv, 0) == false);
    
        BitVecDeinit(&result_bv);

In BitVec.BitWise.c:452:

        BitVecReverse(&bv);
        result = result && (bv.length == 1);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test reverse even length

In BitVec.BitWise.c:459:

        BitVecPush(&bv, false);
        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);

In BitVec.BitWise.c:460:

        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == false);
        result = result && (BitVecGet(&bv, 1) == true);
    
        // Test double reverse (should restore original)

In BitVec.BitWise.c:464:

        // Test double reverse (should restore original)
        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);

In BitVec.BitWise.c:465:

        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.c:510:

        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (result.length == 1);
        test_result = test_result && (BitVecGet(&result, 0) == false);
    
        BitVecOr(&result, &bv1, &bv2);

In BitVec.BitWise.c:513:

    
        BitVecOr(&result, &bv1, &bv2);
        test_result = test_result && (BitVecGet(&result, 0) == true);
    
        // Test NOT on large bitvector

In BitVec.BitWise.c:526:

        // Verify NOT correctness
        for (int i = 0; i < 100; i++) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);

In BitVec.BitWise.c:527:

        for (int i = 0; i < 100; i++) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);
        }

In BitVec.BitWise.c:561:

        bool changed = false;
        for (int i = 0; i < (int)original.length; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                changed = true;
                break;

In BitVec.BitWise.c:594:

        BitVecShiftLeft(&bv, 2);
        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0

In BitVec.BitWise.c:595:

        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0

In BitVec.BitWise.c:596:

        result = result && (BitVecGet(&bv, 0) == false); // filled with 0
        result = result && (BitVecGet(&bv, 1) == false); // filled with 0
        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0
    
        BitVecDeinit(&bv);

In BitVec.BitWise.c:625:

        bool restored = true;
        for (int i = 0; i < 8; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                restored = false;
                break;

In BitVec.BitWise.c:637:

        bool unchanged = true;
        for (int i = 0; i < 8; i++) {
            if (BitVecGet(&bv, i) != BitVecGet(&original, i)) {
                unchanged = false;
                break;

In BitVec.BitWise.c:654:

        BitVecRotateLeft(&bv, 2);
        // 10101 -> 10110 (rotated left by 2)
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.BitWise.c:655:

        // 10101 -> 10110 (rotated left by 2)
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);

In BitVec.BitWise.c:656:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.BitWise.c:657:

        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.BitWise.c:658:

        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.c:683:

        bool and_identity = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                and_identity = false;
                break;

In BitVec.BitWise.c:694:

        bool or_identity = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                or_identity = false;
                break;

In BitVec.BitWise.c:705:

        test_result = test_result && (result.length == 16);
        for (int i = 0; i < 16; i++) {
            test_result = test_result && (BitVecGet(&result, i) == false);
        }

In BitVec.BitWise.c:714:

        bool double_not = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != BitVecGet(&bv1, i)) {
                double_not = false;
                break;

In BitVec.BitWise.c:730:

        bool and_zero = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != false) {
                and_zero = false;
                break;

In BitVec.BitWise.c:746:

        bool or_ones = true;
        for (int i = 0; i < 16; i++) {
            if (BitVecGet(&result, i) != true) {
                or_ones = false;
                break;

In BitVec.BitWise.c:781:

        bool and_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                and_commutative = false;
                break;

In BitVec.BitWise.c:794:

        bool or_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                or_commutative = false;
                break;

In BitVec.BitWise.c:807:

        bool xor_commutative = true;
        for (int i = 0; i < 12; i++) {
            if (BitVecGet(&result1, i) != BitVecGet(&result2, i)) {
                xor_commutative = false;
                break;

In BitVec.BitWise.c:843:

        for (int i = 0; i < 1000; i += 77) { // Check every 77th bit
            bool expected = (i % 7 == 0) && (i % 11 == 0);
            bool actual   = BitVecGet(&result, i);
            test_result   = test_result && (expected == actual);
        }

In BitVec.BitWise.c:857:

        // Verify NOT correctness on sample
        for (int i = 0; i < 1000; i += 123) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);

In BitVec.BitWise.c:858:

        for (int i = 0; i < 1000; i += 123) {
            bool original = BitVecGet(&bv1, i);
            bool inverted = BitVecGet(&result, i);
            test_result   = test_result && (original != inverted);
        }

In BitVec.BitWise.c:873:

        // First 100 bits should be 0
        for (int i = 0; i < 100; i++) {
            test_result = test_result && (BitVecGet(&result, i) == false);
        }

In BitVec.Insert.c:39:

    
        // Check each bit
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Insert.c:40:

        // Check each bit
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);

In BitVec.Insert.c:41:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:42:

        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:43:

        result = result && (BitVecGet(&bv, 2) == true);
        result = result && (BitVecGet(&bv, 3) == true);
        result = result && (BitVecGet(&bv, 4) == false);
    
        // Clean up

In BitVec.Insert.c:61:

    
        // Check first bit
        bool result = (bv.length == 1 && BitVecGet(&bv, 0) == true);
    
        // Insert at the end

In BitVec.Insert.c:68:

        // Check bits
        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);

In BitVec.Insert.c:69:

        result = result && (bv.length == 2);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
    
        // Insert in the middle

In BitVec.Insert.c:76:

        // Check all bits
        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == true);
        result = result && (BitVecGet(&bv, 2) == false);

In BitVec.Insert.c:77:

        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == true);
        result = result && (BitVecGet(&bv, 2) == false);

In BitVec.Insert.c:78:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == true);
        result = result && (BitVecGet(&bv, 2) == false);
    
        // Clean up

In BitVec.Insert.c:101:

        // Check result: false, true, true, true, false
        bool result = (bv.length == 5);
        result      = result && (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Insert.c:102:

        bool result = (bv.length == 5);
        result      = result && (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Insert.c:103:

        result      = result && (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:104:

        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:105:

        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);
    
        // Clean up

In BitVec.Insert.c:134:

        // Check result: true, true, true, true, false
        bool result = (bv.length == 5);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Insert.c:135:

        bool result = (bv.length == 5);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);

In BitVec.Insert.c:136:

        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:137:

        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);

In BitVec.Insert.c:138:

        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == true);
        result      = result && (BitVecGet(&bv, 4) == false);
    
        // Clean up

In BitVec.Insert.c:164:

        // Pattern 1011 gets inserted as individual bits
        bool result = (bv.length == 6);
        result      = result && (BitVecGet(&bv, 0) == false); // original
        result      = result && (BitVecGet(&bv, 1) == true);  // bit 0 of pattern (LSB)
        result      = result && (BitVecGet(&bv, 2) == true);  // bit 1 of pattern

In BitVec.Insert.c:165:

        bool result = (bv.length == 6);
        result      = result && (BitVecGet(&bv, 0) == false); // original
        result      = result && (BitVecGet(&bv, 1) == true);  // bit 0 of pattern (LSB)
        result      = result && (BitVecGet(&bv, 2) == true);  // bit 1 of pattern
        result      = result && (BitVecGet(&bv, 3) == false); // bit 2 of pattern

In BitVec.Insert.c:166:

        result      = result && (BitVecGet(&bv, 0) == false); // original
        result      = result && (BitVecGet(&bv, 1) == true);  // bit 0 of pattern (LSB)
        result      = result && (BitVecGet(&bv, 2) == true);  // bit 1 of pattern
        result      = result && (BitVecGet(&bv, 3) == false); // bit 2 of pattern
        result      = result && (BitVecGet(&bv, 4) == true);  // bit 3 of pattern (MSB)

In BitVec.Insert.c:167:

        result      = result && (BitVecGet(&bv, 1) == true);  // bit 0 of pattern (LSB)
        result      = result && (BitVecGet(&bv, 2) == true);  // bit 1 of pattern
        result      = result && (BitVecGet(&bv, 3) == false); // bit 2 of pattern
        result      = result && (BitVecGet(&bv, 4) == true);  // bit 3 of pattern (MSB)
        result      = result && (BitVecGet(&bv, 5) == false); // original

In BitVec.Insert.c:168:

        result      = result && (BitVecGet(&bv, 2) == true);  // bit 1 of pattern
        result      = result && (BitVecGet(&bv, 3) == false); // bit 2 of pattern
        result      = result && (BitVecGet(&bv, 4) == true);  // bit 3 of pattern (MSB)
        result      = result && (BitVecGet(&bv, 5) == false); // original

In BitVec.Insert.c:169:

        result      = result && (BitVecGet(&bv, 3) == false); // bit 2 of pattern
        result      = result && (BitVecGet(&bv, 4) == true);  // bit 3 of pattern (MSB)
        result      = result && (BitVecGet(&bv, 5) == false); // original
    
        // Test with different pattern - 0x05 (0101 in binary) using only 3 bits

In BitVec.Insert.c:180:

        // Check result: true, false, true, true (3 bits: 101)
        result = result && (bv2.length == 4);
        result = result && (BitVecGet(&bv2, 0) == true);  // bit 0 of pattern (LSB)
        result = result && (BitVecGet(&bv2, 1) == false); // bit 1 of pattern
        result = result && (BitVecGet(&bv2, 2) == true);  // bit 2 of pattern

In BitVec.Insert.c:181:

        result = result && (bv2.length == 4);
        result = result && (BitVecGet(&bv2, 0) == true);  // bit 0 of pattern (LSB)
        result = result && (BitVecGet(&bv2, 1) == false); // bit 1 of pattern
        result = result && (BitVecGet(&bv2, 2) == true);  // bit 2 of pattern
        result = result && (BitVecGet(&bv2, 3) == true);  // original

In BitVec.Insert.c:182:

        result = result && (BitVecGet(&bv2, 0) == true);  // bit 0 of pattern (LSB)
        result = result && (BitVecGet(&bv2, 1) == false); // bit 1 of pattern
        result = result && (BitVecGet(&bv2, 2) == true);  // bit 2 of pattern
        result = result && (BitVecGet(&bv2, 3) == true);  // original

In BitVec.Insert.c:183:

        result = result && (BitVecGet(&bv2, 1) == false); // bit 1 of pattern
        result = result && (BitVecGet(&bv2, 2) == true);  // bit 2 of pattern
        result = result && (BitVecGet(&bv2, 3) == true);  // original
    
        // Clean up

In BitVec.Insert.c:207:

        BitVecInsertRange(&bv, 1, 2, false);
        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == false);

In BitVec.Insert.c:208:

        result = result && (bv.length == 3);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == false);
    
        // Test large range insertion

In BitVec.Insert.c:214:

        BitVecInsertRange(&bv, 0, 1000, true);
        result = result && (bv.length == 1000);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 999) == true);

In BitVec.Insert.c:215:

        result = result && (bv.length == 1000);
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 999) == true);
    
        BitVecDeinit(&bv);

In BitVec.Insert.c:236:

        BitVecPush(&source, true);
        BitVecInsertMultiple(&bv, 0, &source);
        result = result && (bv.length == 1) && (BitVecGet(&bv, 0) == true);
    
        // Test inserting large bitvec

In BitVec.Insert.c:245:

        BitVecInsertMultiple(&bv, 1, &source);
        result = result && (bv.length == 501);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 500) == false);

In BitVec.Insert.c:246:

        result = result && (bv.length == 501);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 500) == false);
    
        BitVecDeinit(&bv);

In BitVec.Insert.c:272:

        BitVecInsertPattern(&bv, 0, 0xAA, 8);            // 10101010 pattern
        result = result && (bv.length == 8);
        result = result && (BitVecGet(&bv, 0) == false); // First bit of 0xAA
        result = result && (BitVecGet(&bv, 1) == true);  // Second bit

In BitVec.Insert.c:273:

        result = result && (bv.length == 8);
        result = result && (BitVecGet(&bv, 0) == false); // First bit of 0xAA
        result = result && (BitVecGet(&bv, 1) == true);  // Second bit
    
        BitVecDeinit(&bv);

In BitVec.Access.c:36:

    // Test BitVecGet function
    bool test_bitvec_get(void) {
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit();

In BitVec.Access.c:47:

    
        // Test getting each bit
        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.c:48:

        // Test getting each bit
        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == false);

In BitVec.Access.c:49:

        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == false);

In BitVec.Access.c:50:

        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
        result      = result && (BitVecGet(&bv, 3) == false);
    
        // Clean up

In BitVec.Access.c:74:

    
        // Verify changes
        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.c:75:

        // Verify changes
        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.c:76:

        bool result = (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == false);
        result      = result && (BitVecGet(&bv, 2) == true);
    
        // Test setting back to false

In BitVec.Access.c:80:

        // Test setting back to false
        BitVecSet(&bv, 0, false);
        result = result && (BitVecGet(&bv, 0) == false);
    
        // Clean up

In BitVec.Access.c:105:

    
        // Verify flipped values: should now be 010
        bool result = (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);

In BitVec.Access.c:106:

        // Verify flipped values: should now be 010
        bool result = (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);

In BitVec.Access.c:107:

        bool result = (BitVecGet(&bv, 0) == false);
        result      = result && (BitVecGet(&bv, 1) == true);
        result      = result && (BitVecGet(&bv, 2) == false);
    
        // Flip back

In BitVec.Access.c:115:

    
        // Should be back to original: 101
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.c:116:

        // Should be back to original: 101
        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);

In BitVec.Access.c:117:

        result = result && (BitVecGet(&bv, 0) == true);
        result = result && (BitVecGet(&bv, 1) == false);
        result = result && (BitVecGet(&bv, 2) == true);
    
        // Clean up

In BitVec.Access.c:192:

    // Edge case tests
    bool test_bitvec_get_edge_cases(void) {
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.c:199:

        // Test boundary conditions (no longer test empty bitvec - strict bounds checking now)
        BitVecPush(&bv, true);
        result = result && (BitVecGet(&bv, 0) == true); // Valid index
    
        // Test with large data set

In BitVec.Access.c:207:

        }
    
        result = result && (BitVecGet(&bv, 0) == true);             // First
        result = result && (BitVecGet(&bv, 999) == (999 % 3 == 0)); // Last

In BitVec.Access.c:208:

    
        result = result && (BitVecGet(&bv, 0) == true);             // First
        result = result && (BitVecGet(&bv, 999) == (999 % 3 == 0)); // Last
    
        BitVecDeinit(&bv);

In BitVec.Access.c:223:

        BitVecPush(&bv, false);
        BitVecSet(&bv, 0, true);
        result = result && (BitVecGet(&bv, 0) == true);
    
        // Test setting same value multiple times

In BitVec.Access.c:228:

        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 0, true);
        result = result && (BitVecGet(&bv, 0) == true);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:243:

        BitVecPush(&bv, true);
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecFlip(&bv, 0);

In BitVec.Access.c:246:

    
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == true);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:296:

            // Test access during growth
            if (cycle > 0) {
                result = result && (BitVecGet(&bv, 0) == true);
                result = result && (BitVecLen(&bv) == (size)(cycle + 1));
            }

In BitVec.Access.c:302:

            // Test setting and getting
            BitVecSet(&bv, cycle, cycle % 3 == 0);
            result = result && (BitVecGet(&bv, cycle) == (cycle % 3 == 0));
        }

In BitVec.Access.c:331:

                for (int bit = 0; bit < 8; bit++) {
                    bool expected = (pattern & (1u << bit)) != 0;
                    bool actual   = BitVecGet(&bv, base_idx + bit);
                    result        = result && (actual == expected);
                }

In BitVec.Access.c:338:

    
        // Test random access across the large dataset
        result = result && (BitVecGet(&bv, 0) == false);            // First bit of pattern
        result = result && (BitVecGet(&bv, 2) == true);             // Third bit of pattern
        result = result && (BitVecGet(&bv, bv.length - 1) == true); // Last bit

In BitVec.Access.c:339:

        // Test random access across the large dataset
        result = result && (BitVecGet(&bv, 0) == false);            // First bit of pattern
        result = result && (BitVecGet(&bv, 2) == true);             // Third bit of pattern
        result = result && (BitVecGet(&bv, bv.length - 1) == true); // Last bit

In BitVec.Access.c:340:

        result = result && (BitVecGet(&bv, 0) == false);            // First bit of pattern
        result = result && (BitVecGet(&bv, 2) == true);             // Third bit of pattern
        result = result && (BitVecGet(&bv, bv.length - 1) == true); // Last bit
    
        BitVecDeinit(&bv);

In BitVec.Access.c:400:

            u64  idx      = (test * 7 + test * 3) % size; // Pseudo-random indices
            bool expected = (idx / 7) % 2 == 0;
            bool actual   = BitVecGet(&bv, idx);
            result        = result && (actual == expected);
        }

In BitVec.Access.c:410:

        for (int i = 0; i < boundary_count; i++) {
            if (boundaries[i] < size) {
                bool original = BitVecGet(&bv, boundaries[i]);
                BitVecFlip(&bv, boundaries[i]);
                result = result && (BitVecGet(&bv, boundaries[i]) == !original);

In BitVec.Access.c:412:

                bool original = BitVecGet(&bv, boundaries[i]);
                BitVecFlip(&bv, boundaries[i]);
                result = result && (BitVecGet(&bv, boundaries[i]) == !original);
                BitVecFlip(&bv, boundaries[i]); // Flip back
                result = result && (BitVecGet(&bv, boundaries[i]) == original);

In BitVec.Access.c:414:

                result = result && (BitVecGet(&bv, boundaries[i]) == !original);
                BitVecFlip(&bv, boundaries[i]); // Flip back
                result = result && (BitVecGet(&bv, boundaries[i]) == original);
            }
        }

In BitVec.Access.c:439:

        // Verify all bits are false
        for (int i = 0; i < 100; i++) {
            result = result && (BitVecGet(&bv, i) == false);
        }

In BitVec.Access.c:462:

        for (int i = 0; i < 100; i++) {
            bool expected = (i % 2 == 0);
            result        = result && (BitVecGet(&bv, i) == expected);
        }

In BitVec.Access.c:470:

        BitVecPush(&bv, true); // F(1) = 1
        for (int i = 2; i < 50; i++) {
            bool prev1 = BitVecGet(&bv, i - 1);
            bool prev2 = BitVecGet(&bv, i - 2);
            BitVecPush(&bv, prev1 != prev2); // XOR

In BitVec.Access.c:471:

        for (int i = 2; i < 50; i++) {
            bool prev1 = BitVecGet(&bv, i - 1);
            bool prev2 = BitVecGet(&bv, i - 2);
            BitVecPush(&bv, prev1 != prev2); // XOR
        }

In BitVec.Access.c:476:

    
        // Verify first few Fibonacci bits
        result = result && (BitVecGet(&bv, 0) == true);  // F(0) = 1
        result = result && (BitVecGet(&bv, 1) == true);  // F(1) = 1
        result = result && (BitVecGet(&bv, 2) == false); // F(2) = 1 XOR 1 = 0

In BitVec.Access.c:477:

        // Verify first few Fibonacci bits
        result = result && (BitVecGet(&bv, 0) == true);  // F(0) = 1
        result = result && (BitVecGet(&bv, 1) == true);  // F(1) = 1
        result = result && (BitVecGet(&bv, 2) == false); // F(2) = 1 XOR 1 = 0
        result = result && (BitVecGet(&bv, 3) == true);  // F(3) = 1 XOR 0 = 1

In BitVec.Access.c:478:

        result = result && (BitVecGet(&bv, 0) == true);  // F(0) = 1
        result = result && (BitVecGet(&bv, 1) == true);  // F(1) = 1
        result = result && (BitVecGet(&bv, 2) == false); // F(2) = 1 XOR 1 = 0
        result = result && (BitVecGet(&bv, 3) == true);  // F(3) = 1 XOR 0 = 1
        result = result && (BitVecGet(&bv, 4) == true);  // F(4) = 0 XOR 1 = 1

In BitVec.Access.c:479:

        result = result && (BitVecGet(&bv, 1) == true);  // F(1) = 1
        result = result && (BitVecGet(&bv, 2) == false); // F(2) = 1 XOR 1 = 0
        result = result && (BitVecGet(&bv, 3) == true);  // F(3) = 1 XOR 0 = 1
        result = result && (BitVecGet(&bv, 4) == true);  // F(4) = 0 XOR 1 = 1

In BitVec.Access.c:480:

        result = result && (BitVecGet(&bv, 2) == false); // F(2) = 1 XOR 1 = 0
        result = result && (BitVecGet(&bv, 3) == true);  // F(3) = 1 XOR 0 = 1
        result = result && (BitVecGet(&bv, 4) == true);  // F(4) = 0 XOR 1 = 1
    
        BitVecDeinit(&bv);

In BitVec.Access.c:491:

    
        // Test NULL bitvec pointer - should abort
        BitVecGet(NULL, 0);
    
        return false;

In BitVec.Access.c:520:

    
        // Test get from empty bitvec - should abort
        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:560:

    
        // Test with index way beyond length (3) - should abort
        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:611:

    
        // Test with maximum possible index value - should abort
        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);

In BitVec.Pattern.c:789:

        // Check result should be: 101110
        result = result && (BitVecLen(&source) == 6);
        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);

In BitVec.Pattern.c:790:

        result = result && (BitVecLen(&source) == 6);
        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);

In BitVec.Pattern.c:791:

        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);
    
        BitVecDeinit(&source);

In BitVec.Pattern.Simple.c:673:

        // Check result should be: 101110
        result = result && (BitVecLen(&source) == 6);
        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);

In BitVec.Pattern.Simple.c:674:

        result = result && (BitVecLen(&source) == 6);
        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);

In BitVec.Pattern.Simple.c:675:

        result = result && (BitVecGet(&source, 0) == true);
        result = result && (BitVecGet(&source, 1) == false);
        result = result && (BitVecGet(&source, 2) == true);
    
        BitVecDeinit(&source);

In Foreach.h:27:

            if ((ValidateBitVec(UNPL(pbv)), 1) && UNPL(pbv)->length > 0)                                                   \
                for (u64 idx = 0, UNPL(d) = 1; UNPL(d); UNPL(d)--)                                                         \
                    for (bool var = 0; idx < UNPL(pbv)->length && (var = BitVecGet(UNPL(pbv), idx), 1); idx++)
    
    ///

In Foreach.h:44:

                for (u64 idx = UNPL(pbv)->length; idx-- > 0 && idx < UNPL(pbv)->length;)                                   \
                    for (u8 UNPL(run_once) = 1; UNPL(run_once); UNPL(run_once) = 0)                                        \
                        for (bool var = BitVecGet(UNPL(pbv), idx); UNPL(run_once); UNPL(run_once) = 0)
    
    ///

In Foreach.h:86:

                     UNPL(s) <= idx && idx < UNPL(e) && idx < UNPL(pbv)->length && UNPL(s) <= UNPL(e);                     \
                     ++idx, UNPL(d) = 1)                                                                                   \
                    for (bool var = BitVecGet(UNPL(pbv), idx); UNPL(d); UNPL(d) = 0)

Last updated on April 20, 2026

BitVecFuzzyMatch BitVecInsert