BitVecGet

Documentation

API Reference

BitVecGet

Description

Get the value of bit at given index in bitvector.

Parameters

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

Usage example (from documentation)

  bool flag = BitVecGet(&flags, 5);

Success

Returns true when the bit is set, false when it is clear. The bitvector is not modified.

Failure

Function cannot fail. An out-of-range idx is a caller bug and aborts via LOG_FATAL.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:240:

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

In BitVec.c:256:

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

In BitVec.c:314:

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

In BitVec.c:329:

    
        for (u64 i = bitvec->length - 1; i > idx; i--) {
            bool bit = BitVecGet(bitvec, i - 1);
            BitVecSet(bitvec, i, bit);
        }

In BitVec.c:353:

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

In BitVec.c:381:

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

In BitVec.c:386:

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

In BitVec.c:409:

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

In BitVec.c:429:

        }
    
        bool removed_bit = BitVecGet(bv, idx);
    
        for (u64 i = idx; i < bv->length - 1; i++) {

In BitVec.c:432:

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

In BitVec.c:457:

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

In BitVec.c:497:

        // a survivor, so survivors slide leftward into the gaps left by matches.
        for (u64 read_idx = 0; read_idx < bv->length; read_idx++) {
            bool bit = BitVecGet(bv, read_idx);
            if (bit != value) {
                if (write_idx != read_idx) {

In BitVec.c:519:

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

In BitVec.c:542:

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

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

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

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

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

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

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

In BitVec.c:619:

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

In BitVec.c:689:

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

In BitVec.c:690:

        for (u64 i = 0; i < len; i++) {
            bool bit1 = BitVecGet(bv1, start1 + i);
            bool bit2 = BitVecGet(bv2, start2 + i);
    
            // 1 sorts after 0; once a position differs the order is fixed

In BitVec.c:714:

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

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

        // Two's-complement: the top bit is the sign, so a set MSB means
        // negative and an unset one means non-negative.
        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:752:

        // negative and an unset one means non-negative.
        bool sign1 = bv1->length > 0 ? BitVecGet(bv1, bv1->length - 1) : false;
        bool sign2 = bv2->length > 0 ? BitVecGet(bv2, bv2->length - 1) : false;
    
        if (sign1 != sign2) {

In BitVec.c:780:

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

        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 (bit1 && !bit2) {

In BitVec.c:802:

    
        for (u64 i = 0; i < min_len; i++) {
            if (BitVecGet(bv1, i) && BitVecGet(bv2, i)) {
                return false;
            }

In BitVec.c:820:

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

In BitVec.c:848:

    
        for (u64 i = 0; i < bv->length; i++) {
            char bit_char = BitVecGet(bv, i) ? '1' : '0';
            if (!StrPushBackR(out, bit_char)) {
                StrDeinit(out);

In BitVec.c:958:

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

    
        for (u64 i = 0; i < max_bits; i++) {
            if (BitVecGet(bv, i)) {
                result |= (1ULL << i);
            }

In BitVec.c:1078:

        // by an earlier iteration writing into a higher index.
        for (u64 i = bv->length - 1; i >= positions; i--) {
            bool bit = BitVecGet(bv, i - positions);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:1099:

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

In BitVec.c:1127:

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

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

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

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

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

In BitVec.c:1196:

        // wraps to SIZE_MAX, which fails the loop condition.
        for (u64 i = bv->length - 1; i < bv->length; i--) {
            if (BitVecGet(bv, i) == value) {
                return i;
            }

In BitVec.c:1209:

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

In BitVec.c:1236:

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

In BitVec.c:1341:

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

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

In BitVec.c:1382:

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

In BitVec.c:1385:

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

In BitVec.c:1411:

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

In BitVec.c:1439:

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

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

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

In BitVec.c:1528:

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

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

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

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

In BitVec.c:1643:

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

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

In BitVec.c:1754:

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

In BitVec.c:1790:

    
            for (u64 i = 0; i < new_pattern->length; i++) {
                if (!BitVecInsert(bv, match_pos + i, BitVecGet(new_pattern, i))) {
                    return replacements;
                }

In BitVec.c:1813:

        for (u64 i = 0; i < bv->length; i++) {
            // wildcard bit clear = position is fixed; the pattern must match.
            if (!BitVecGet(wildcard, i)) {
                if (BitVecGet(bv, i) != BitVecGet(pattern, i)) {
                    return false;

In BitVec.c:1814:

            // wildcard bit clear = position is fixed; the pattern must match.
            if (!BitVecGet(wildcard, i)) {
                if (BitVecGet(bv, i) != BitVecGet(pattern, i)) {
                    return false;
                }

In BitVec.c:1834:

            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 Int.c:84:

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

In Int.c:224:

    static bool int_is_odd(const Int *value) {
        ValidateInt(value);
        return BitVecLen(INT_BITS(value)) > 0 && BitVecGet(INT_BITS(value), 0);
    }

In Int.c:229:

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

In Int.c:405:

    
        for (u64 i = 0; i < BitVecLen(INT_BITS(value)); i++) {
            if (BitVecGet(INT_BITS(value), i)) {
                return i;
            }

In Int.c:555:

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

In Int.c:609:

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

In Int.c:961:

    
        for (u64 i = a_bits; i > 0; i--) {
            bool a_bit = BitVecGet(INT_BITS(a), i - 1);
            bool b_bit = BitVecGet(INT_BITS(b), i - 1);

In Int.c:962:

        for (u64 i = a_bits; i > 0; i--) {
            bool a_bit = BitVecGet(INT_BITS(a), i - 1);
            bool b_bit = BitVecGet(INT_BITS(b), i - 1);
    
            if (a_bit != b_bit) {

In Int.c:1021:

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

In Int.c:1045:

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

In Int.c:1073:

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

In Int.c:1076:

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

In Int.c:1153:

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

In Int.c:1154:

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

In Int.c:1219:

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

In BitVec.Memory.c:53:

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

In BitVec.Memory.c:54:

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

In BitVec.Memory.c:55:

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

In BitVec.Memory.c:83:

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

In BitVec.Memory.c:84:

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

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

In BitVec.Memory.c:95:

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

In BitVec.Memory.c:135:

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

In BitVec.Memory.c:136:

        result = result && (BitVecLen(&bv1) == 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:140:

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

In BitVec.Memory.c:141:

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

In BitVec.Memory.c:142:

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

In BitVec.Memory.c:174:

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

In BitVec.Memory.c:182:

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

In BitVec.Memory.c:183:

        result = result && (BitVecLen(&clone) == 4) && (BitVecLen(&original) == 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:184:

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

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

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

In BitVec.Memory.c:192:

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

                      BitVecAllocator(&clone)->effort == BitVecAllocator(&original)->effort &&
                      BitVecAllocator(&clone)->retry_limit == BitVecAllocator(&original)->retry_limit &&
                      BitVecGet(&clone, 0) == true && BitVecGet(&clone, 1) == false && BitVecGet(&clone, 2) == true;
    
        BitVecDeinit(&original);

In BitVec.Memory.c:255:

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

In BitVec.Memory.c:296:

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

In BitVec.Memory.c:328:

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

In BitVec.Memory.c:329:

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

In BitVec.Memory.c:339:

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

In BitVec.Memory.c:340:

        result = result && (BitVecLen(&bv1) == 2) && (BitVecLen(&bv2) == 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:369:

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

In BitVec.Memory.c:383:

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

In BitVec.Memory.c:387:

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

In BitVec.Memory.c:388:

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

In BitVec.Memory.c:423:

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

In BitVec.BitWise.Simple.c:58:

        // Expected result: 1000 (1101 AND 1010)
        bool test_result = (BitVecLen(&result) == 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:59:

        bool test_result = (BitVecLen(&result) == 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:60:

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

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

        // Expected result: 1110 (1100 OR 1010)
        bool test_result = (BitVecLen(&result) == 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:101:

        bool test_result = (BitVecLen(&result) == 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:102:

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

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

        // Expected result: 0110 (1100 XOR 1010)
        bool test_result = (BitVecLen(&result) == 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:143:

        bool test_result = (BitVecLen(&result) == 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:144:

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

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

        // Expected result: 0101 (NOT 1010)
        bool test_result = (BitVecLen(&result) == 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:178:

        bool test_result = (BitVecLen(&result) == 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:179:

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

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

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

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

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

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

    
        bool test_result = (BitVecLen(&bv) == 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:262:

        bool test_result = (BitVecLen(&bv) == 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:263:

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

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

        // Expected result: 1110 (1011 rotated left by 2)
        bool test_result = (BitVecLen(&bv) == 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:294:

        bool test_result = (BitVecLen(&bv) == 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:295:

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

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

        // Expected result: 1101 (1011 rotated right by 1)
        bool test_result = (BitVecLen(&bv) == 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:326:

        bool test_result = (BitVecLen(&bv) == 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:327:

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

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

        // Expected result: 1101 (1011 reversed)
        bool test_result = (BitVecLen(&bv) == 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:358:

        bool test_result = (BitVecLen(&bv) == 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:359:

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

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

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

In BitVec.BitWise.Simple.c:425:

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

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

In BitVec.BitWise.Simple.c:499:

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

In BitVec.BitWise.Simple.c:506:

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

In BitVec.BitWise.Simple.c:507:

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

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

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

In BitVec.BitWise.Simple.c:560:

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

In BitVec.BitWise.Simple.c:563:

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

In BitVec.BitWise.Simple.c:576:

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

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

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

In BitVec.BitWise.Simple.c:647:

        BitVecShiftLeft(&bv, 2);
        result = result && (BitVecLen(&bv) == 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:648:

        result = result && (BitVecLen(&bv) == 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:649:

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

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

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

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

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

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

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

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

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

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

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

In BitVec.BitWise.Simple.c:773:

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

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

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

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

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

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

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

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

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

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

In Int.Type.c:94:

            IntAllocator(&clone)->effort == IntAllocator(&original)->effort &&
            IntAllocator(&clone)->retry_limit == IntAllocator(&original)->retry_limit &&
            BitVecGet(&clone.bits, 0) == true && BitVecGet(&clone.bits, 1) == false && BitVecGet(&clone.bits, 2) == true;
    
        IntDeinit(&original);

In BitVec.Insert.c:41:

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

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

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

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

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

In BitVec.Insert.c:67:

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

In BitVec.Insert.c:74:

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

In BitVec.Insert.c:75:

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

In BitVec.Insert.c:82:

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

In BitVec.Insert.c:83:

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

In BitVec.Insert.c:84:

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

In BitVec.Insert.c:111:

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

In BitVec.Insert.c:112:

        bool result = (BitVecLen(&bv) == 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:113:

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

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

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

In BitVec.Insert.c:148:

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

In BitVec.Insert.c:149:

        bool result = (BitVecLen(&bv) == 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:150:

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

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

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

In BitVec.Insert.c:182:

        // Pattern 1011 gets inserted as individual bits
        bool result = (BitVecLen(&bv) == 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:183:

        bool result = (BitVecLen(&bv) == 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:184:

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

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

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

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

        // Check result: true, false, true, true (3 bits: 101)
        result = result && (BitVecLen(&bv2) == 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:199:

        result = result && (BitVecLen(&bv2) == 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:200:

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

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

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

In BitVec.Insert.c:230:

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

In BitVec.Insert.c:236:

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

In BitVec.Insert.c:237:

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

In BitVec.Insert.c:261:

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

In BitVec.Insert.c:270:

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

In BitVec.Insert.c:271:

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

In BitVec.Insert.c:300:

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

In BitVec.Insert.c:301:

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

In BitVec.Pattern.Simple.c:760:

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

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

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

In BitVec.Access.Deadend.c:59:

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

In BitVec.Access.Deadend.c:90:

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

In BitVec.Access.Deadend.c:139:

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

In BitVec.Access.Deadend.c:199:

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

In BitVec.Access.Simple.c:36:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:47:

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

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

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

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

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

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

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

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

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:171:

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

In BitVec.Access.Simple.c:178:

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

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

In BitVec.Access.Simple.c:200:

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

In BitVec.Access.Simple.c:218:

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

In BitVec.Access.Simple.c:222:

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

In BitVec.Access.Simple.c:278:

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

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

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

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

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

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

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

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

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

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

In BitVec.Access.Simple.c:360:

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

In BitVec.Access.Simple.c:392:

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

In BitVec.Access.Simple.c:416:

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

In BitVec.Access.Simple.c:473:

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

In BitVec.Init.c:143:

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

In BitVec.Init.c:171:

        // Check that length was increased and new bits have the default value
        bool result = (BitVecLen(&bv) == 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:172:

        bool result = (BitVecLen(&bv) == 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:173:

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

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

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

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

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

In BitVec.Init.c:184:

        result = result && (BitVecLen(&bv) == 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:272:

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

In BitVec.Remove.c:44:

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

In BitVec.Remove.c:45:

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

In BitVec.Remove.c:50:

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

In BitVec.Remove.c:84:

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

In BitVec.Remove.c:85:

        bool result = (removed == true) && (BitVecLen(&bv) == 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:86:

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

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

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

In BitVec.Remove.c:93:

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

In BitVec.Remove.c:94:

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

In BitVec.Remove.c:125:

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

In BitVec.Remove.c:126:

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

In BitVec.Remove.c:127:

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

In BitVec.Remove.c:157:

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

In BitVec.Remove.c:158:

        bool result = (found == true) && (BitVecLen(&bv) == 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:159:

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

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

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

In BitVec.Remove.c:199:

        bool result = (found == true) && (BitVecLen(&bv) == 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:200:

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

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

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

In BitVec.Remove.c:209:

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

In BitVec.Remove.c:210:

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

In BitVec.Remove.c:241:

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

In BitVec.Remove.c:242:

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

In BitVec.Remove.c:243:

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

        // Expected result: 1000 (1101 AND 1010)
        bool test_result = (BitVecLen(&result) == 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:59:

        bool test_result = (BitVecLen(&result) == 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:60:

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

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

        // Expected result: 1110 (1100 OR 1010)
        bool test_result = (BitVecLen(&result) == 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:101:

        bool test_result = (BitVecLen(&result) == 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:102:

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

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

        // Expected result: 0110 (1100 XOR 1010)
        bool test_result = (BitVecLen(&result) == 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:143:

        bool test_result = (BitVecLen(&result) == 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:144:

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

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

        // Expected result: 0101 (NOT 1010)
        bool test_result = (BitVecLen(&result) == 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:178:

        bool test_result = (BitVecLen(&result) == 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:179:

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

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

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

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

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

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

    
        bool test_result = (BitVecLen(&bv) == 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:262:

        bool test_result = (BitVecLen(&bv) == 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:263:

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

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

        // Expected result: 1110 (1011 rotated left by 2)
        bool test_result = (BitVecLen(&bv) == 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:294:

        bool test_result = (BitVecLen(&bv) == 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:295:

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

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

        // Expected result: 1101 (1011 rotated right by 1)
        bool test_result = (BitVecLen(&bv) == 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:326:

        bool test_result = (BitVecLen(&bv) == 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:327:

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

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

        // Expected result: 1101 (1011 reversed)
        bool test_result = (BitVecLen(&bv) == 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:358:

        bool test_result = (BitVecLen(&bv) == 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:359:

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

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

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

In BitVec.BitWise.c:425:

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

In BitVec.BitWise.c:473:

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

In BitVec.BitWise.c:499:

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

In BitVec.BitWise.c:506:

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

In BitVec.BitWise.c:507:

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

In BitVec.BitWise.c:511:

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

In BitVec.BitWise.c:512:

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

In BitVec.BitWise.c:560:

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

In BitVec.BitWise.c:563:

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

In BitVec.BitWise.c:576:

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

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

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

In BitVec.BitWise.c:647:

        BitVecShiftLeft(&bv, 2);
        result = result && (BitVecLen(&bv) == 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:648:

        result = result && (BitVecLen(&bv) == 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:649:

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

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

In BitVec.BitWise.c:693:

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

In BitVec.BitWise.c:710:

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

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

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

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

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

In BitVec.BitWise.c:742:

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

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

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

In BitVec.BitWise.c:773:

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

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

In BitVec.BitWise.c:805:

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

In BitVec.BitWise.c:843:

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

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

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

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

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

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

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

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

In BitVec.Convert.c:81:

        bool result = ok && (BitVecLen(&bv) == 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:82:

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

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

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

In BitVec.Convert.c:230:

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

In BitVec.Convert.c:248:

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

In BitVec.Convert.c:339:

        BitVec bv2 = BitVecFromStr("1", ALLOCATOR_OF(&alloc));
        result     = result && (BitVecLen(&bv2) == 1);
        result     = result && (BitVecGet(&bv2, 0) == true);
        BitVecDeinit(&bv2);

In BitVec.Convert.c:351:

        BitVec bv3 = BitVecFromStr(long_str, ALLOCATOR_OF(&alloc));
        result     = result && (BitVecLen(&bv3) == 1000);
        result     = result && (BitVecGet(&bv3, 0) == true);
        result     = result && (BitVecGet(&bv3, 1) == false);
        BitVecDeinit(&bv3);

In BitVec.Convert.c:352:

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

In BitVec.Convert.c:648:

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

In BitVec.Convert.c:673:

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

In BitVec.Access.c:38:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:49:

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

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

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

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

In BitVec.Access.c:80:

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

In BitVec.Access.c:81:

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

In BitVec.Access.c:82:

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

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

In BitVec.Access.c:115:

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

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

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

In BitVec.Access.c:125:

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

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

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

In BitVec.Access.c:214:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:221:

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

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

In BitVec.Access.c:230:

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

In BitVec.Access.c:248:

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

In BitVec.Access.c:253:

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

In BitVec.Access.c:271:

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

In BitVec.Access.c:274:

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

In BitVec.Access.c:330:

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

In BitVec.Access.c:336:

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

In BitVec.Access.c:368:

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

    
        // 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, BitVecLen(&bv) - 1) == true); // Last bit

In BitVec.Access.c:376:

        // 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, BitVecLen(&bv) - 1) == true); // Last bit

In BitVec.Access.c:377:

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

In BitVec.Access.c:443:

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

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

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

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

In BitVec.Access.c:485:

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

In BitVec.Access.c:508:

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

In BitVec.Access.c:516:

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

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

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

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

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

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

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

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

In BitVec.Access.c:569:

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

In BitVec.Access.c:618:

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

In BitVec.Access.c:678:

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

In Foreach.h:32:

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

In Foreach.h:54:

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

In Foreach.h:112:

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

Last updated on June 4, 2026

BitVecFuzzyMatch BitVecInit