BitVecGet

Function
August 22, 2025

Table of Contents

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

Usage example (Cross-references)

In Foreach.h:37:

    if ((bv)->length > 0) {                                                                                        \
    for ((idx) = 0; (idx) < (bv)->length; ++(idx)) {                                                           \
    bool var = BitVecGet(bv, idx);                                                                         \
    { body }                                                                                               \
    if ((idx) >= (bv)->length) {                                                                           \

In Foreach.h:63:

    if ((bv)->length > 0) {                                                                                        \
    for (idx = (bv)->length - 1; (idx) < (bv)->length; --(idx)) {                                              \
    bool var = BitVecGet(bv, idx);                                                                         \
    { body }                                                                                               \
    if ((idx) >= (bv)->length) {                                                                           \

In Foreach.h:162:

    );                                                                                                 \
    }                                                                                                      \
    bool var = BitVecGet(bv, idx);                                                                         \
    { body }                                                                                               \
    }                                                                                                          \

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

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

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

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

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

In BitVec.c:1380:

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

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

In BitVec.c:1494:

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

In BitVec.c:1531:

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

In BitVec.c:1551:

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

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

    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.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.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.Access.Simple.c:34:

    // Test BitVecGet function
    bool test_bitvec_get(void) {
    printf("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) {
    printf("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.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.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.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.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.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.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 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.Access.c:36:

    // Test BitVecGet function
    bool test_bitvec_get(void) {
    printf("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) {
    printf("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);

BitVecGet

`BitVecGet`

Description

Parameters

Usage example (from documentation)

Usage example (Cross-references)

Tags :

Share :

Related Posts

BitVecSuffixMatch

BitVecReserve

BitVecClear