ValidateBitVec(bitvec);
        if (new_size > bitvec->capacity) {
            BitVecReserve(bitvec, new_size);
        }

    }
    
    void BitVecReserve(BitVec *bitvec, u64 n) {
        ValidateBitVec(bitvec);
        if (n <= bitvec->capacity)

    
        // Reserve space for the clone
        BitVecReserve(&clone, bv->length);
        BitVecResize(&clone, bv->length);

        if (bitvec->length >= bitvec->capacity) {
            u64 new_capacity = bitvec->capacity == 0 ? 8 : bitvec->capacity * 2;
            BitVecReserve(bitvec, new_capacity);
        }

    
        u64 str_len = strlen(str);
        BitVecReserve(&result, str_len);
    
        for (u64 i = 0; i < str_len; i++) {

        }
    
        BitVecReserve(&result, bit_len);
        BitVecResize(&result, bit_len);

        }
    
        BitVecReserve(&result, bits);
        BitVecResize(&result, bits);

    
        // Reserve more space
        BitVecReserve(&bv, 100);
        result = result && (BitVecLen(&bv) == 3);
        result = result && (BitVecCapacity(&bv) >= 100);

        // Create large bitvector
        const int size = 10000;
        BitVecReserve(&bv, size);
    
        // Set alternating pattern

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

    
        // Reserve space for 50 bits
        BitVecReserve(&bv, 50);
    
        // Check that capacity was increased

        // Test reserving less than current capacity (should be no-op)
        u64 original_capacity = bv.capacity;
        BitVecReserve(&bv, 25);
        result = result && (bv.capacity == original_capacity);

    
    bool test_bitvec_reserve_edge_cases(void) {
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit();

    
        // Test reserving 0 (should be safe no-op)
        BitVecReserve(&bv, 0);
        result = result && (bv.capacity == 0) && (bv.data == NULL);

    
        // Test reserving 1 bit (minimum meaningful size)
        BitVecReserve(&bv, 1);
        result = result && (bv.capacity >= 1) && (bv.data != NULL);

    
        // Test very large but reasonable reservation
        BitVecReserve(&bv, 10000);
        result = result && (bv.capacity >= 10000);

        // Test reserving same u64 repeatedly (should be no-op)
        u64 cap_before = bv.capacity;
        BitVecReserve(&bv, bv.capacity);
        BitVecReserve(&bv, bv.capacity);
        result = result && (bv.capacity == cap_before);

        u64 cap_before = bv.capacity;
        BitVecReserve(&bv, bv.capacity);
        BitVecReserve(&bv, bv.capacity);
        result = result && (bv.capacity == cap_before);

    
        // This should trigger an abort if validation is working
        BitVecReserve(&bv, SIZE_MAX);
    
        // If we reach here, validation didn't work as expected

    
        // Force capacity to be larger than needed by reserving space
        BitVecReserve(&bv, 100);
    
        // Check that capacity is larger than length

    // Test BitVecReserve function (replacing BitVecSetCapacity)
    bool test_bitvec_set_capacity(void) {
        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit();

    
        // Set capacity to a specific value
        BitVecReserve(&bv, 50);
    
        // Check that capacity was set correctly

    
        // Try to set capacity smaller than current length (should not shrink below length)
        BitVecReserve(&bv, 1);
    
        // Capacity should still accommodate at least the current length

    
        // Test shrink after reserve and clear
        BitVecReserve(&bv, 1000);
        BitVecClear(&bv);
        BitVecShrinkToFit(&bv);

    
    bool test_bitvec_set_capacity_edge_cases(void) {
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit();

    
        // Test set capacity on empty bitvec
        BitVecReserve(&bv, 100);
        result = result && (bv.capacity >= 100) && (bv.length == 0);

    
        // Test setting very large capacity
        BitVecReserve(&bv, 10000);
        result = result && (bv.capacity >= 10000);

    
            // Reu64 operations
            BitVecReserve(&bv1, cycle * 20);
            BitVecShrinkToFit(&bv2);