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

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

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