bit_len = 4; // Minimum 4 bits for hex display
    
            *bv = BitVecFromInteger(value, bit_len);
            StrDeinit(&hex_str);
            return i;

                bit_len = 3; // Minimum 3 bits for octal display
    
            *bv = BitVecFromInteger(value, bit_len);
            StrDeinit(&oct_str);
            return i;

        }
    
        return int_wrap(BitVecFromInteger(value, bits));
    }

    }
    
    BitVec BitVecFromInteger(u64 value, u64 bits) {
        BitVec result = BitVecInit();
        if (bits == 0) {

    
        // Test 3: Hex formatting
        BitVec bv2 = BitVecFromInteger(0xABCD, 16);
        StrWriteFmt(&output, "{x}", bv2);
        success = success && (ZstrCompare(output.data, "0xabcd") == 0);

    
        // Test 5: Octal formatting
        BitVec bv3 = BitVecFromInteger(0755, 10);
        StrWriteFmt(&output, "{o}", bv3);
        success = success && (ZstrCompare(output.data, "0o755") == 0);

    
        // Test 7: Zero value
        BitVec bv_zero = BitVecFromInteger(0, 1);
        StrWriteFmt(&output, "{x}", bv_zero);
        success = success && (ZstrCompare(output.data, "0x0") == 0);

    // Test BitVecFromInteger function
    bool test_bitvec_from_integer(void) {
        WriteFmt("Testing BitVecFromInteger\n");
    
        // Convert from integer

        // Convert from integer
        u64    value = 11; // 1011 in binary
        BitVec bv    = BitVecFromInteger(value, 4);
    
        // Check result

    
        // Test with zero
        BitVec zero_bv = BitVecFromInteger(0, 8);
        result         = result && (zero_bv.length == 8);

    
        // Test integer to bitvec with 0
        BitVec bv2 = BitVecFromInteger(0, 8);     // 8 bits for zero
        result     = result && (bv2.length == 8); // Should be 8 bits
        BitVecDeinit(&bv2);

    
        // Test large integer
        BitVec bv3 = BitVecFromInteger(UINT64_MAX, 64); // 64 bits for max value
        result     = result && (bv3.length == 64);
        BitVecDeinit(&bv3);

                value    &= mask;
    
                BitVec bv        = BitVecFromInteger(value, bits);
                u64    recovered = BitVecToInteger(&bv);

    
        // Test large integer conversion (should cap at 64 bits)
        BitVec large_bv = BitVecFromInteger(0xFFFFFFFFFFFFFFFF, 64);
        result          = result && (large_bv.length == 64);

        // Test cross-format validation
        BitVec bv1 = BitVecFromStr("11010110");
        BitVec bv2 = BitVecFromInteger(0xD6, 8); // Assuming MSB-first: 11010110 = 0xD6
        BitVec bv3 = BitVecFromBytes((u8[]) {0xD6}, 8);