StrClear

Documentation

API Reference

StrClear

Description

Set string length to 0.

Parameters

Name	Direction	Description
`vec`	in,out	Str to be cleared.

Failure

NULL

Usage example (Cross-references)

Usage examples (Cross-references)

In Str.c:144:

            // Memory operations
            case STR_CLEAR : {
                StrClear(str);
                break;
            }

In Str.c:22:

        ValidateStr(str);
    
        StrClear(str);
    
        va_list args;

In Str.c:341:

        }
    
        StrClear(str);
    
        // Add prefix if requested

In Str.c:422:

        }
    
        StrClear(str);
    
        // Handle special cases

In KvConfig.c:191:

        if (key->length == 0) {
            LOG_ERROR("Expected config key");
            StrClear(key);
            return saved_si;
        }

In KvConfig.c:230:

                    if (!StrIterRemainingLength(&si)) {
                        LOG_ERROR("Unexpected end of quoted config value");
                        StrClear(value);
                        return saved_si;
                    }

In KvConfig.c:264:

    
            LOG_ERROR("Missing closing quote in config value");
            StrClear(value);
            return saved_si;
        }

In KvConfig.c:313:

        if (StrIterPeek(&si) != '=' && StrIterPeek(&si) != ':') {
            LOG_ERROR("Expected '=' or ':' after config key");
            StrClear(key);
            StrClear(value);
            return saved_si;

In KvConfig.c:314:

            LOG_ERROR("Expected '=' or ':' after config key");
            StrClear(key);
            StrClear(value);
            return saved_si;
        }

In KvConfig.c:322:

    
        if (si.pos == saved_si.pos) {
            StrClear(key);
            StrClear(value);
            return saved_si;

In KvConfig.c:323:

        if (si.pos == saved_si.pos) {
            StrClear(key);
            StrClear(value);
            return saved_si;
        }

In KvConfig.c:332:

        } else if (!kvconfig_is_line_end(StrIterPeek(&si))) {
            LOG_ERROR("Unexpected trailing characters after config value");
            StrClear(key);
            StrClear(value);
            return saved_si;

In KvConfig.c:333:

            LOG_ERROR("Unexpected trailing characters after config value");
            StrClear(key);
            StrClear(value);
            return saved_si;
        } else {

In JSON.c:200:

                        if (!StrIterRemainingLength(&si)) {
                            LOG_ERROR("Unexpected end of string.");
                            StrClear(str);
                            return saved_si;
                        }

In JSON.c:257:

                            default :
                                LOG_ERROR("Invalid JSON object key string.");
                                StrClear(str);
                                return saved_si;
                        }

In MisraEnum.c:104:

        });
    
        StrClear(&code);
    
        // Use a temporary variable for enum name

In Io.Read.c:349:

        success      = success && (StrCmp(&s, &expected) == 0);
        StrDeinit(&expected);
        StrClear(&s);
    
        // Test quoted string reading

In Io.Read.c:382:

        success      = success && (StrCmp(&name, &expected) == 0);
        StrDeinit(&expected);
        StrClear(&name);
    
        // Test with different order

In Io.Write.c:41:

        StrWriteFmt(&output, "");
        success = success && (output.length == 0);
        StrClear(&output);
    
        // Test literal text

In Io.Write.c:46:

        StrWriteFmt(&output, "Hello, world!");
        success = success && (ZstrCompare(output.data, "Hello, world!") == 0);
        StrClear(&output);
    
        // Test escaped braces

In Io.Write.c:51:

        StrWriteFmt(&output, "{{Hello}}");
        success = success && (ZstrCompare(output.data, "{Hello}") == 0);
        StrClear(&output);
    
        // Test double escaped braces

In Io.Write.c:72:

        StrWriteFmt(&output, "{}", str);
        success = success && (ZstrCompare(output.data, "Hello") == 0);
        StrClear(&output);
    
        // Test empty string

In Io.Write.c:78:

        StrWriteFmt(&output, "{}", empty);
        success = success && (output.length == 0);
        StrClear(&output);
    
        // Test string with width and alignment

In Io.Write.c:83:

        StrWriteFmt(&output, "{>10}", str);
        success = success && (ZstrCompare(output.data, "     Hello") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{<10}", str);

In Io.Write.c:87:

        StrWriteFmt(&output, "{<10}", str);
        success = success && (ZstrCompare(output.data, "Hello     ") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{^10}", str);

In Io.Write.c:91:

        StrWriteFmt(&output, "{^10}", str);
        success = success && (ZstrCompare(output.data, "  Hello   ") == 0);
        StrClear(&output);
    
        // Test Str object

In Io.Write.c:114:

        StrWriteFmt(&output, "{}", i8_val);
        success = success && (ZstrCompare(output.data, "-42") == 0);
        StrClear(&output);
    
        i16 i16_val = -1234;

In Io.Write.c:119:

        StrWriteFmt(&output, "{}", i16_val);
        success = success && (ZstrCompare(output.data, "-1234") == 0);
        StrClear(&output);
    
        i32 i32_val = -123456;

In Io.Write.c:124:

        StrWriteFmt(&output, "{}", i32_val);
        success = success && (ZstrCompare(output.data, "-123456") == 0);
        StrClear(&output);
    
        i64 i64_val = -1234567890LL;

In Io.Write.c:129:

        StrWriteFmt(&output, "{}", i64_val);
        success = success && (ZstrCompare(output.data, "-1234567890") == 0);
        StrClear(&output);
    
        // Test unsigned integers

In Io.Write.c:135:

        StrWriteFmt(&output, "{}", u8_val);
        success = success && (ZstrCompare(output.data, "42") == 0);
        StrClear(&output);
    
        u16 u16_val = 1234;

In Io.Write.c:140:

        StrWriteFmt(&output, "{}", u16_val);
        success = success && (ZstrCompare(output.data, "1234") == 0);
        StrClear(&output);
    
        u32 u32_val = 123456;

In Io.Write.c:145:

        StrWriteFmt(&output, "{}", u32_val);
        success = success && (ZstrCompare(output.data, "123456") == 0);
        StrClear(&output);
    
        u64 u64_val = 1234567890ULL;

In Io.Write.c:150:

        StrWriteFmt(&output, "{}", u64_val);
        success = success && (ZstrCompare(output.data, "1234567890") == 0);
        StrClear(&output);
    
        // Test edge cases

In Io.Write.c:156:

        StrWriteFmt(&output, "{}", i8_max);
        success = success && (ZstrCompare(output.data, "127") == 0);
        StrClear(&output);
    
        i8 i8_min = -128;

In Io.Write.c:161:

        StrWriteFmt(&output, "{}", i8_min);
        success = success && (ZstrCompare(output.data, "-128") == 0);
        StrClear(&output);
    
        u8 u8_max = 255;

In Io.Write.c:166:

        StrWriteFmt(&output, "{}", u8_max);
        success = success && (ZstrCompare(output.data, "255") == 0);
        StrClear(&output);
    
        u8 u8_min = 0;

In Io.Write.c:186:

        StrWriteFmt(&output, "{x}", val);
        success = success && (ZstrCompare(output.data, "0xdeadbeef") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{X}", val);

In Io.Write.c:235:

        StrWriteFmt(&output, "{}", f32_val);
        success = success && (ZstrCompare(output.data, "3.141590") == 0);
        StrClear(&output);
    
        f64 f64_val = 2.71828;

In Io.Write.c:257:

        StrWriteFmt(&output, "{.2}", val);
        success = success && (ZstrCompare(output.data, "3.14") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{.0}", val);

In Io.Write.c:261:

        StrWriteFmt(&output, "{.0}", val);
        success = success && (ZstrCompare(output.data, "3") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{.10}", val);

In Io.Write.c:281:

        StrWriteFmt(&output, "{}", pos_inf);
        success = success && (ZstrCompare(output.data, "inf") == 0);
        StrClear(&output);
    
        f64 neg_inf = -INFINITY;

In Io.Write.c:286:

        StrWriteFmt(&output, "{}", neg_inf);
        success = success && (ZstrCompare(output.data, "-inf") == 0);
        StrClear(&output);
    
        // Test NaN

In Io.Write.c:308:

        StrWriteFmt(&output, "{5}", val);
        success = success && (ZstrCompare(output.data, "   42") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{<5}", val);

In Io.Write.c:312:

        StrWriteFmt(&output, "{<5}", val);
        success = success && (ZstrCompare(output.data, "42   ") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{^5}", val);

In Io.Write.c:316:

        StrWriteFmt(&output, "{^5}", val);
        success = success && (ZstrCompare(output.data, " 42  ") == 0);
        StrClear(&output);
    
        // Test with strings

In Io.Write.c:322:

        StrWriteFmt(&output, "{5}", str);
        success = success && (ZstrCompare(output.data, "  abc") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{<5}", str);

In Io.Write.c:326:

        StrWriteFmt(&output, "{<5}", str);
        success = success && (ZstrCompare(output.data, "abc  ") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{^5}", str);

In Io.Write.c:348:

        StrWriteFmt(&output, "{} {} {}", hello, num, pi);
        success = success && (ZstrCompare(output.data, "Hello 42 3.140000") == 0);
        StrClear(&output);
    
        // Instead of using positional arguments, we'll just reorder the arguments themselves

In Io.Write.c:369:

        StrWriteFmt(&output, "{c}", mixed_case);
        success = success && (ZstrCompare(output.data, "MiXeD CaSe") == 0);
        StrClear(&output);
    
        // Test mixed case string with :a (lowercase)

In Io.Write.c:374:

        StrWriteFmt(&output, "{a}", mixed_case);
        success = success && (ZstrCompare(output.data, "mixed case") == 0);
        StrClear(&output);
    
        // Test mixed case string with :A (uppercase)

In Io.Write.c:379:

        StrWriteFmt(&output, "{A}", mixed_case);
        success = success && (ZstrCompare(output.data, "MIXED CASE") == 0);
        StrClear(&output);
    
        // Test with Str object

In Io.Write.c:387:

        StrWriteFmt(&output, "{c}", s);
        success = success && (ZstrCompare(output.data, "MiXeD CaSe") == 0);
        StrClear(&output);
    
        // Test with :a (lowercase)

In Io.Write.c:392:

        StrWriteFmt(&output, "{a}", s);
        success = success && (ZstrCompare(output.data, "mixed case") == 0);
        StrClear(&output);
    
        // Test with :A (uppercase)

In Io.Write.c:397:

        StrWriteFmt(&output, "{A}", s);
        success = success && (ZstrCompare(output.data, "MIXED CASE") == 0);
        StrClear(&output);
    
        // Test with character values (u8)

In Io.Write.c:406:

        StrWriteFmt(&output, "{c}", upper_char);
        success = success && (ZstrCompare(output.data, "M") == 0);
        StrClear(&output);
    
        // Test uppercase char with :a (lowercase)

In Io.Write.c:411:

        StrWriteFmt(&output, "{a}", upper_char);
        success = success && (ZstrCompare(output.data, "m") == 0);
        StrClear(&output);
    
        // Test lowercase char with :A (uppercase)

In Io.Write.c:416:

        StrWriteFmt(&output, "{A}", lower_char);
        success = success && (ZstrCompare(output.data, "M") == 0);
        StrClear(&output);
    
        // Test with u16 (containing ASCII values)

In Io.Write.c:424:

        StrWriteFmt(&output, "{c}", u16_value);
        success = success && (output.length == 2 && output.data[0] == 'A' && output.data[1] == 'B');
        StrClear(&output);
    
        // Test u16 with :a (lowercase)

In Io.Write.c:429:

        StrWriteFmt(&output, "{a}", u16_value);
        success = success && (output.length == 2 && output.data[0] == 'a' && output.data[1] == 'b');
        StrClear(&output);
    
        // Test u16 with :A (uppercase)

In Io.Write.c:434:

        StrWriteFmt(&output, "{A}", u16_value);
        success = success && (output.length == 2 && output.data[0] == 'A' && output.data[1] == 'B');
        StrClear(&output);
    
        // Test with i16 (containing ASCII values)

In Io.Write.c:442:

        StrWriteFmt(&output, "{c}", i16_value);
        success = success && (output.length == 2 && output.data[0] == 'C' && output.data[1] == 'd');
        StrClear(&output);
    
        // Test i16 with :a (lowercase)

In Io.Write.c:447:

        StrWriteFmt(&output, "{a}", i16_value);
        success = success && (output.length == 2 && output.data[0] == 'c' && output.data[1] == 'd');
        StrClear(&output);
    
        // Test i16 with :A (uppercase)

In Io.Write.c:452:

        StrWriteFmt(&output, "{A}", i16_value);
        success = success && (output.length == 2 && output.data[0] == 'C' && output.data[1] == 'D');
        StrClear(&output);
    
        // Test with u32 (containing ASCII values)

In Io.Write.c:461:

        success = success && (output.length == 4 && output.data[0] == 'E' && output.data[1] == 'f' &&
                              output.data[2] == 'G' && output.data[3] == 'h');
        StrClear(&output);
    
        // Test u32 with :a (lowercase)

In Io.Write.c:467:

        success = success && (output.length == 4 && output.data[0] == 'e' && output.data[1] == 'f' &&
                              output.data[2] == 'g' && output.data[3] == 'h');
        StrClear(&output);
    
        // Test u32 with :A (uppercase)

In Io.Write.c:473:

        success = success && (output.length == 4 && output.data[0] == 'E' && output.data[1] == 'F' &&
                              output.data[2] == 'G' && output.data[3] == 'H');
        StrClear(&output);
    
        // Test with i32 (containing ASCII values)

In Io.Write.c:482:

        success = success && (output.length == 4 && output.data[0] == 'I' && output.data[1] == 'j' &&
                              output.data[2] == 'K' && output.data[3] == 'l');
        StrClear(&output);
    
        // Test i32 with :a (lowercase)

In Io.Write.c:488:

        success = success && (output.length == 4 && output.data[0] == 'i' && output.data[1] == 'j' &&
                              output.data[2] == 'k' && output.data[3] == 'l');
        StrClear(&output);
    
        // Test i32 with :A (uppercase)

In Io.Write.c:494:

        success = success && (output.length == 4 && output.data[0] == 'I' && output.data[1] == 'J' &&
                              output.data[2] == 'K' && output.data[3] == 'L');
        StrClear(&output);
    
        // Test with u64 (containing ASCII values)

In Io.Write.c:505:

                              output.data[2] == 'O' && output.data[3] == 'p' && output.data[4] == 'Q' &&
                              output.data[5] == 'r' && output.data[6] == 'S' && output.data[7] == 't');
        StrClear(&output);
    
        // Test u64 with :a (lowercase)

In Io.Write.c:512:

                              output.data[2] == 'o' && output.data[3] == 'p' && output.data[4] == 'q' &&
                              output.data[5] == 'r' && output.data[6] == 's' && output.data[7] == 't');
        StrClear(&output);
    
        // Test u64 with :A (uppercase)

In Io.Write.c:519:

                              output.data[2] == 'O' && output.data[3] == 'P' && output.data[4] == 'Q' &&
                              output.data[5] == 'R' && output.data[6] == 'S' && output.data[7] == 'T');
        StrClear(&output);
    
        // Test with i64 (containing ASCII values)

In Io.Write.c:530:

                              output.data[2] == 'W' && output.data[3] == 'x' && output.data[4] == 'Y' &&
                              output.data[5] == 'z' && output.data[6] == '1' && output.data[7] == '2');
        StrClear(&output);
    
        // Test i64 with :a (lowercase)

In Io.Write.c:537:

                              output.data[2] == 'w' && output.data[3] == 'x' && output.data[4] == 'y' &&
                              output.data[5] == 'z' && output.data[6] == '1' && output.data[7] == '2');
        StrClear(&output);
    
        // Test i64 with :A (uppercase)

In Io.Write.c:561:

        StrWriteFmt(&output, "{}", bv1);
        success = success && (ZstrCompare(output.data, "10110") == 0);
        StrClear(&output);
    
        // Test 2: Empty BitVec

In Io.Write.c:567:

        StrWriteFmt(&output, "{}", bv_empty);
        success = success && (output.length == 0);
        StrClear(&output);
    
        // Test 3: Hex formatting

In Io.Write.c:573:

        StrWriteFmt(&output, "{x}", bv2);
        success = success && (ZstrCompare(output.data, "0xabcd") == 0);
        StrClear(&output);
    
        // Test 4: Uppercase hex formatting

In Io.Write.c:578:

        StrWriteFmt(&output, "{X}", bv2);
        success = success && (ZstrCompare(output.data, "0xABCD") == 0);
        StrClear(&output);
    
        // Test 5: Octal formatting

In Io.Write.c:584:

        StrWriteFmt(&output, "{o}", bv3);
        success = success && (ZstrCompare(output.data, "0o755") == 0);
        StrClear(&output);
    
        // Test 6: Width and alignment

In Io.Write.c:589:

        StrWriteFmt(&output, "{>10}", bv1);
        success = success && (ZstrCompare(output.data, "     10110") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{<10}", bv1);

In Io.Write.c:593:

        StrWriteFmt(&output, "{<10}", bv1);
        success = success && (ZstrCompare(output.data, "10110     ") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{^10}", bv1);

In Io.Write.c:597:

        StrWriteFmt(&output, "{^10}", bv1);
        success = success && (ZstrCompare(output.data, "  10110   ") == 0);
        StrClear(&output);
    
        // Test 7: Zero value

In Io.Write.c:603:

        StrWriteFmt(&output, "{x}", bv_zero);
        success = success && (ZstrCompare(output.data, "0x0") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{o}", bv_zero);

In Io.Write.c:607:

        StrWriteFmt(&output, "{o}", bv_zero);
        success = success && (ZstrCompare(output.data, "0o0") == 0);
        StrClear(&output);
    
        // Cleanup

In Io.Write.c:632:

        StrWriteFmt(&output, "{}", big_dec);
        success = success && (ZstrCompare(output.data, "123456789012345678901234567890") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{x}", hex_val);

In Io.Write.c:636:

        StrWriteFmt(&output, "{x}", hex_val);
        success = success && (ZstrCompare(output.data, "deadbeefcafebabe1234") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{X}", hex_val);

In Io.Write.c:640:

        StrWriteFmt(&output, "{X}", hex_val);
        success = success && (ZstrCompare(output.data, "DEADBEEFCAFEBABE1234") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{b}", bin_val);

In Io.Write.c:644:

        StrWriteFmt(&output, "{b}", bin_val);
        success = success && (ZstrCompare(output.data, "10100011") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{o}", oct_val);

In Io.Write.c:648:

        StrWriteFmt(&output, "{o}", oct_val);
        success = success && (ZstrCompare(output.data, "755") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{>34}", big_dec);

In Io.Write.c:672:

        StrWriteFmt(&output, "{}", exact);
        success = success && (ZstrCompare(output.data, "1234567890.012345") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{e}", sci);

In Io.Write.c:676:

        StrWriteFmt(&output, "{e}", sci);
        success = success && (ZstrCompare(output.data, "1.234567e+04") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{E}", sci);

In Io.Write.c:680:

        StrWriteFmt(&output, "{E}", sci);
        success = success && (ZstrCompare(output.data, "1.234567E+04") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{.3}", short_v);

In Io.Write.c:684:

        StrWriteFmt(&output, "{.3}", short_v);
        success = success && (ZstrCompare(output.data, "1.200") == 0);
        StrClear(&output);
    
        StrWriteFmt(&output, "{>18}", sci);

In Str.Convert.c:42:

    
        // Test hexadecimal conversion (lowercase)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 0xABCD, &config);

In Str.Convert.c:51:

    
        // Test hexadecimal conversion (uppercase)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = true, .use_prefix = true};
        StrFromU64(&s, 0xABCD, &config);

In Str.Convert.c:60:

    
        // Test binary conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 42, &config);

In Str.Convert.c:69:

    
        // Test octal conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 8, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 42, &config);

In Str.Convert.c:78:

    
        // Test zero
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromU64(&s, 0, &config);

In Str.Convert.c:105:

    
        // Test negative decimal conversion (only decimal supports negative sign)
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, -12345, &config);

In Str.Convert.c:114:

    
        // Test hexadecimal conversion of negative number (negative non-decimal treated as unsigned)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
        StrFromI64(&s, -0xABCD, &config);

In Str.Convert.c:125:

    
        // Test zero
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, 0, &config);

In Str.Convert.c:134:

    
        // Test binary conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true};
        StrFromI64(&s, 42, &config);

In Str.Convert.c:161:

    
        // Test fractional conversion
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 123.456, &config);

In Str.Convert.c:170:

    
        // Test negative number
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false};
        StrFromF64(&s, -123.456, &config);

In Str.Convert.c:176:

    
        // Test scientific notation (forced)
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = false};
        StrFromF64(&s, 123.456, &config);

In Str.Convert.c:182:

    
        // Test scientific notation (uppercase)
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = true};
        StrFromF64(&s, 123.456, &config);

In Str.Convert.c:188:

    
        // Test very small number (auto scientific notation)
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 0.0000123, &config);

In Str.Convert.c:194:

    
        // Test very large number (auto scientific notation)
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 1234567890123.0, &config);

In Str.Convert.c:200:

    
        // Test zero
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 0.0, &config);

In Str.Convert.c:206:

    
        // Test infinity
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false};
        StrFromF64(&s, INFINITY, &config);

In Str.Convert.c:212:

    
        // Test negative infinity
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false};
        StrFromF64(&s, -INFINITY, &config);

In Str.Convert.c:218:

    
        // Test NaN
        StrClear(&s);
        config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false};
        StrFromF64(&s, NAN, &config);

In Str.Convert.c:423:

    
            // Test hex round-trip
            StrClear(&s);
            config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
            StrFromU64(&s, u64_values[i], &config);

In Str.Convert.c:503:

    
        // Test minimum i64 (avoid INT64_MIN due to negation UB)
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, INT64_MIN + 1, &config);

In Str.Convert.c:511:

    
        // Test very small floating point
        StrClear(&s);
        StrFloatFormat fconfig = {.precision = 3, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 1e-300, &fconfig);

In Str.Convert.c:519:

    
        // Test very large floating point
        StrClear(&s);
        fconfig = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false};
        StrFromF64(&s, 1e300, &fconfig);

In Str.Convert.c:593:

    
            // Test uppercase E
            StrClear(&s);
            config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = true};
            StrFromF64(&s, sci_values[i], &config);

In Str.Memory.c:117:

    // Test StrClear function
    bool test_str_clear(void) {
        WriteFmt("Testing StrClear\n");
    
        Str s = StrInitFromZstr("Hello, World!");

In Str.Memory.c:125:

    
        // Clear the string
        StrClear(&s);
    
        // Length should now be 0, but capacity should remain

Last updated on April 20, 2026

StrCharPtrAt StrCmp