// Convert to BitVec using the null-terminated string
    *bv = BitVecFromStr(bin_str.data);
    
    StrDeinit(&bin_str);

    }
    
    BitVec BitVecFromStr(const char *str) {
    if (!str) {
    LOG_FATAL("str is NULL");

    
    // Test 1: Basic binary formatting
    BitVec bv1 = BitVecFromStr("10110");
    StrWriteFmt(&output, "{}", bv1);
    success = success && (ZstrCompare(output.data, "10110") == 0);

    // Test BitVecFromStr function
    bool test_bitvec_from_string(void) {
    WriteFmt("Testing BitVecFromStr\n");
    
    // Convert from string

    // Convert from string
    const char *str = "1011";
    BitVec      bv  = BitVecFromStr(str);
    
    // Check result

    
    // Test with empty string
    BitVec empty_bv = BitVecFromStr("");
    result          = result && (empty_bv.length == 0);

    
    bool test_bitvec_from_string_edge_cases(void) {
    WriteFmt("Testing BitVecFromStr edge cases\n");
    
    bool result = true;

    
    // Test empty string
    BitVec bv1 = BitVecFromStr("");
    result     = result && (bv1.length == 0);
    BitVecDeinit(&bv1);

    
    // Test single character
    BitVec bv2 = BitVecFromStr("1");
    result     = result && (bv2.length == 1);
    result     = result && (BitVecGet(&bv2, 0) == true);

    long_str[1000] = '\0';
    
    BitVec bv3 = BitVecFromStr(long_str);
    result     = result && (bv3.length == 1000);
    result     = result && (BitVecGet(&bv3, 0) == true);

    
    for (size_t i = 0; i < sizeof(patterns) / sizeof(patterns[0]); i++) {
    BitVec bv  = BitVecFromStr(patterns[i]);
    Str    str = BitVecToStr(&bv);

    
    for (size_t i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) {
    BitVec bv = BitVecFromStr(test_cases[i].pattern);
    
    // Test string conversion consistency

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

    large_pattern[2000] = '\0';
    
    BitVec large_from_str = BitVecFromStr(large_pattern);
    result                = result && (large_from_str.length == 2000);

    
    // Test NULL string - should abort
    BitVecFromStr(NULL);
    
    return false;