StrInitFromZstr

Documentation

API Reference

StrInitFromZstr

Description

Initializes a Str object from a null-terminated C-style string (zstr). This macro calculates the length of zstr using strlen and then calls StrInitFromCstr to create the Str object.

Parameters

Name	Direction	Description
`zstr`	in	Pointer to the null-terminated C-style string to initialize from.

Success

Returns a newly created Str object with its data field pointing to a newly allocated memory containing a copy of zstr. The length and capacity fields are set to the length of zstr. copy_init and copy_deinit are set to NULL, and alignment is set to 1.

Failure

Returns a Str object with data set to NULL if memory allocation using strndup (called internally by StrInitFromCstr) fails. In such a case, length and capacity will likely be uninitialized or zero. It’s crucial to check the data field for NULL after using this macro to handle potential memory allocation errors.

Usage example (Cross-references)

Usage examples (Cross-references)

In Str.c:64:

                    if (zstr) {
                        StrDeinit(str);
                        *str = StrInitFromZstr(zstr);
                        free(zstr);
                    }

In Sys.c:61:

        char *env_var = getenv(name);
        if (env_var) {
            *value = StrInitFromZstr(env_var);
            return value;
        }

In Sys.c:75:

        strerror_r(eno, buf, 1023);
    #endif
        *err_str = StrInitFromZstr(buf);
        return err_str;
    }

In Float.c:346:

    
        if (FloatIsZero(value)) {
            return StrInitFromZstr("0");
        }

In Int.c:517:

    
        if (IntIsZero(value)) {
            return StrInitFromZstr("0");
        }

In KvConfig.c:409:

        }
    
        lookup = StrInitFromZstr(key);
        value  = map_get_value_ptr(
            GENERIC_MAP(cfg),

In Proc.c:590:

            return NULL;
        }
        *exe_path = StrInitFromZstr(buffer);
        return exe_path;
    #else

In Proc.c:599:

        if (len != -1) {
            buffer[len] = '\0';
            *exe_path   = StrInitFromZstr(buffer);
            return exe_path;
        }

In Proc.c:608:

        u32 bsize = sizeof(buffer);
        if (_NSGetExecutablePath(buffer, &bsize) == 0) {
            *exe_path = StrInitFromZstr(buffer);
            return exe_path;
        }

In Dir.c:109:

            }
    
            direntry.name = StrInitFromZstr(findFileData.cFileName); // Copy file name
            VecPushBack(&dc, direntry);
        } while (FindNextFile(hFind, &findFileData) != 0);

In Parse.c:8:

    static bool test_kvconfig_basic_parse(void) {
        KvConfig cfg = KvConfigInit();
        Str      src = StrInitFromZstr(
            "host = localhost\n"
                 "port = 8080\n"

In Parse.c:34:

    static bool test_kvconfig_comments_quotes_and_duplicates(void) {
        KvConfig cfg = KvConfigInit();
        Str      src = StrInitFromZstr(
            "# comment line\n"
                 "path = \"/srv/my app\"   # keep spaces in quotes\n"

In Parse.c:65:

    static bool test_kvconfig_get_returns_copy(void) {
        KvConfig cfg         = KvConfigInit();
        Str      src         = StrInitFromZstr("host = localhost\n");
        StrIter  input       = StrIterFromStr(src);
        Str      host_copy   = StrInit();

In Parse.c:96:

    static bool test_kvconfig_numeric_and_bool_accessors(void) {
        KvConfig cfg = KvConfigInit();
        Str      src = StrInitFromZstr(
            "workers = 16\n"
                 "pi = 3.14159\n"

In Parse.c:127:

    static bool test_kvconfig_invalid_line_fails(void) {
        KvConfig cfg = KvConfigInit();
        Str      src = StrInitFromZstr(
            "valid = yes\n"
                 "broken line\n"

In Write.Nested.c:75:

    // Helper function to compare JSON output (removes whitespace for comparison)
    bool compare_json_output(const Str *output, const char *expected) {
        Str expected_str   = StrInitFromZstr(expected);
        Str output_clean   = StrInit();
        Str expected_clean = StrInit();

In Write.Nested.c:143:

            Str status;
        } data = {
            {123, {StrInitFromZstr("Alice"), 30}},
            StrInitFromZstr("active")
        };

In Write.Nested.c:144:

        } data = {
            {123, {StrInitFromZstr("Alice"), 30}},
            StrInitFromZstr("active")
        };

In Write.Nested.c:188:

            } company;
        } data = {
            {{{StrInitFromZstr("John"), 25, 150000.0}}, StrInitFromZstr("TechCorp")}
        };

In Write.Nested.c:224:

        Str  json    = StrInit();
    
        ApiResponse response = {true, StrInitFromZstr("Success"), VecInitWithDeepCopy(NULL, AnnSymbolDeinit)};
    
        // Add sample data

In Write.Nested.c:228:

        // Add sample data
        AnnSymbol sym             = {0};
        sym.analysis_name         = StrInitFromZstr("test_analysis");
        sym.function_name         = StrInitFromZstr("main_func");
        sym.sha256                = StrInitFromZstr("abc123");

In Write.Nested.c:229:

        AnnSymbol sym             = {0};
        sym.analysis_name         = StrInitFromZstr("test_analysis");
        sym.function_name         = StrInitFromZstr("main_func");
        sym.sha256                = StrInitFromZstr("abc123");
        sym.function_mangled_name = StrInitFromZstr("_Z4main");

In Write.Nested.c:230:

        sym.analysis_name         = StrInitFromZstr("test_analysis");
        sym.function_name         = StrInitFromZstr("main_func");
        sym.sha256                = StrInitFromZstr("abc123");
        sym.function_mangled_name = StrInitFromZstr("_Z4main");
        sym.source_function_id    = 12345;

In Write.Nested.c:231:

        sym.function_name         = StrInitFromZstr("main_func");
        sym.sha256                = StrInitFromZstr("abc123");
        sym.function_mangled_name = StrInitFromZstr("_Z4main");
        sym.source_function_id    = 12345;
        sym.target_function_id    = 67890;

In Write.Nested.c:298:

        Vec(FunctionInfo) functions = VecInitWithDeepCopy(NULL, FunctionInfoDeinit);
    
        FunctionInfo func1 = {12345, StrInitFromZstr("test_func"), 1024, 4096};
        FunctionInfo func2 = {54321, StrInitFromZstr("helper_func"), 512, 8192};
        VecPushBack(&functions, func1);

In Write.Nested.c:299:

    
        FunctionInfo func1 = {12345, StrInitFromZstr("test_func"), 1024, 4096};
        FunctionInfo func2 = {54321, StrInitFromZstr("helper_func"), 512, 8192};
        VecPushBack(&functions, func1);
        VecPushBack(&functions, func2);

In Write.Nested.c:335:

        SearchResult result = {0};
        result.binary_id    = 888;
        result.binary_name  = StrInitFromZstr("test_binary");
        result.analysis_id  = 999;
        result.sha256       = StrInitFromZstr("abc123");

In Write.Nested.c:337:

        result.binary_name  = StrInitFromZstr("test_binary");
        result.analysis_id  = 999;
        result.sha256       = StrInitFromZstr("abc123");
        result.tags         = VecInitWithDeepCopyT(result.tags, NULL, StrDeinit);

In Write.Nested.c:341:

    
        // Create strings and push them properly
        Str tag1 = StrInitFromZstr("malware");
        Str tag2 = StrInitFromZstr("x86");

In Write.Nested.c:342:

        // Create strings and push them properly
        Str tag1 = StrInitFromZstr("malware");
        Str tag2 = StrInitFromZstr("x86");
    
        VecPushBack(&result.tags, tag1);

In Write.Nested.c:347:

        VecPushBack(&result.tags, tag2);
    
        result.created_at = StrInitFromZstr("2024-04-01");
        result.model_id   = 12345;
        result.model_name = StrInitFromZstr("test_model");

In Write.Nested.c:349:

        result.created_at = StrInitFromZstr("2024-04-01");
        result.model_id   = 12345;
        result.model_name = StrInitFromZstr("test_model");
        result.owned_by   = StrInitFromZstr("user1");

In Write.Nested.c:350:

        result.model_id   = 12345;
        result.model_name = StrInitFromZstr("test_model");
        result.owned_by   = StrInitFromZstr("user1");
    
        JW_OBJ(json, {

In Write.Nested.c:387:

    
        AnnSymbol sym1             = {0};
        sym1.analysis_name         = StrInitFromZstr("analysis1");
        sym1.function_name         = StrInitFromZstr("func1");
        sym1.sha256                = StrInitFromZstr("hash1");

In Write.Nested.c:388:

        AnnSymbol sym1             = {0};
        sym1.analysis_name         = StrInitFromZstr("analysis1");
        sym1.function_name         = StrInitFromZstr("func1");
        sym1.sha256                = StrInitFromZstr("hash1");
        sym1.function_mangled_name = StrInitFromZstr("_Z5func1");

In Write.Nested.c:389:

        sym1.analysis_name         = StrInitFromZstr("analysis1");
        sym1.function_name         = StrInitFromZstr("func1");
        sym1.sha256                = StrInitFromZstr("hash1");
        sym1.function_mangled_name = StrInitFromZstr("_Z5func1");
        sym1.source_function_id    = 111;

In Write.Nested.c:390:

        sym1.function_name         = StrInitFromZstr("func1");
        sym1.sha256                = StrInitFromZstr("hash1");
        sym1.function_mangled_name = StrInitFromZstr("_Z5func1");
        sym1.source_function_id    = 111;
        sym1.target_function_id    = 222;

In Write.Nested.c:397:

    
        AnnSymbol sym2             = {0};
        sym2.analysis_name         = StrInitFromZstr("analysis2");
        sym2.function_name         = StrInitFromZstr("func2");
        sym2.sha256                = StrInitFromZstr("hash2");

In Write.Nested.c:398:

        AnnSymbol sym2             = {0};
        sym2.analysis_name         = StrInitFromZstr("analysis2");
        sym2.function_name         = StrInitFromZstr("func2");
        sym2.sha256                = StrInitFromZstr("hash2");
        sym2.function_mangled_name = StrInitFromZstr("_Z5func2");

In Write.Nested.c:399:

        sym2.analysis_name         = StrInitFromZstr("analysis2");
        sym2.function_name         = StrInitFromZstr("func2");
        sym2.sha256                = StrInitFromZstr("hash2");
        sym2.function_mangled_name = StrInitFromZstr("_Z5func2");
        sym2.source_function_id    = 333;

In Write.Nested.c:400:

        sym2.function_name         = StrInitFromZstr("func2");
        sym2.sha256                = StrInitFromZstr("hash2");
        sym2.function_mangled_name = StrInitFromZstr("_Z5func2");
        sym2.source_function_id    = 333;
        sym2.target_function_id    = 444;

In Write.Nested.c:449:

    
        // Create strings for the nested structure
        Str deep_message = StrInitFromZstr("deep");
        Str test_name    = StrInitFromZstr("test");

In Write.Nested.c:450:

        // Create strings for the nested structure
        Str deep_message = StrInitFromZstr("deep");
        Str test_name    = StrInitFromZstr("test");
    
        JW_OBJ(json, {

In Write.Nested.c:493:

    
        // Create strings and push them properly
        Str str1 = StrInitFromZstr("a");
        Str str2 = StrInitFromZstr("b");
        Str str3 = StrInitFromZstr("c");

In Write.Nested.c:494:

        // Create strings and push them properly
        Str str1 = StrInitFromZstr("a");
        Str str2 = StrInitFromZstr("b");
        Str str3 = StrInitFromZstr("c");

In Write.Nested.c:495:

        Str str1 = StrInitFromZstr("a");
        Str str2 = StrInitFromZstr("b");
        Str str3 = StrInitFromZstr("c");
    
        VecPushBack(&strings, str1);

In Read.Simple.c:62:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"name\": \"Alice\", \"city\": \"New York\"}");
        StrIter si      = StrIterFromStr(json);

In Read.Simple.c:102:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"count\": 42, \"score\": 95.5, \"year\": 2024}");
        StrIter si      = StrIterFromStr(json);

In Read.Simple.c:139:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"enabled\": true, \"visible\": false}");
        StrIter si      = StrIterFromStr(json);

In Read.Simple.c:170:

        bool success = true;
        Str  json =
            StrInitFromZstr("{\"id\": 1001, \"name\": \"Bob\", \"age\": 25, \"is_active\": true, \"salary\": 50000.0}");
        StrIter si = StrIterFromStr(json);

In Read.Simple.c:223:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"debug_mode\": false, \"timeout\": 30, \"log_level\": \"INFO\"}");
        StrIter si      = StrIterFromStr(json);

In Read.Simple.c:264:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"languages\": [\"C\", \"Python\", \"Rust\"]}");
        StrIter si      = StrIterFromStr(json);

In Read.Simple.c:326:

        bool success = true;
        Str  json =
            StrInitFromZstr("{\"user\": {\"name\": \"Charlie\", \"email\": \"charlie@example.com\"}, \"active\": true}");
        StrIter si = StrIterFromStr(json);

In Read.Simple.c:382:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"id\": 12345, \"name\": \"Laptop\", \"price\": 999.99, \"tags\": [\"electronics\", \"computers\", "
                "\"portable\"]}"

In Read.Nested.c:108:

        WriteFmt("Testing basic iterator functionality\n");
    
        Str     json = StrInitFromZstr("{\"test\": \"value\"}");
        StrIter si   = StrIterFromStr(json);

In Read.Nested.c:132:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 12345, \"name\": \"test\", \"active\": true, \"score\": 98.5}");
        StrIter si      = StrIterFromStr(json);

In Read.Nested.c:183:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"user\": {\"id\": 123, \"profile\": {\"name\": \"Alice\", \"age\": 30}}, \"status\": \"active\"}"
        );

In Read.Nested.c:252:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"company\": {\"departments\": {\"engineering\": {\"head\": \"John\", \"count\": 25, \"budget\": 150000.0}}, "
                "\"name\": \"TechCorp\"}}"

In Read.Nested.c:331:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"functions\": {\"12345\": {\"67890\": {\"distance\": 0.85, \"name\": \"main\"}}, \"54321\": {\"98765\": "
                "{\"distance\": 0.92, \"name\": \"helper\"}}}}"

In Read.Nested.c:429:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"status\": true, \"message\": \"Success\", \"data\": {\"12345\": {\"67890\": {\"distance\": 0.85, "
                "\"nearest_neighbor_analysis_id\": 999, \"nearest_neighbor_binary_id\": 888, "

In Read.Nested.c:577:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 12345, \"name\": \"test_func\", \"size\": 1024, \"vaddr\": 4096}");
        StrIter si      = StrIterFromStr(json);

In Read.Nested.c:624:

    
        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 54321, \"name\": \"test_model\"}");
        StrIter si      = StrIterFromStr(json);

In Read.Nested.c:659:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"binary_id\": 888, \"binary_name\": \"test_binary\", \"analysis_id\": 999, \"sha256\": \"abc123\", "
                "\"created_at\": \"2024-04-01\", \"model_id\": 12345, \"model_name\": \"test_model\", \"owned_by\": \"user1\"}"

In Read.Nested.c:745:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"status\": true, \"message\": \"Success\", \"data\": {\"12345\": {\"67890\": {\"distance\": 0.85, "
                "\"nearest_neighbor_analysis_id\": 999, \"nearest_neighbor_binary_id\": 888, "

In Read.Nested.c:914:

    
        bool success = true;
        Str  json    = StrInitFromZstr(
            "{\"status\": true, \"message\": \"Success\", \"data\": {\"12345\": {\"67890\": {\"distance\": 0.85, "
                "\"nearest_neighbor_analysis_id\": 999, \"nearest_neighbor_binary_id\": 888, "

In Write.EdgeCases.c:14:

    bool compare_json_output(const Str *output, const char *expected) {
        // Create a copy of expected without spaces for comparison
        Str expected_str   = StrInitFromZstr(expected);
        Str output_clean   = StrInit();
        Str expected_clean = StrInit();

In Write.EdgeCases.c:238:

    
        // Note: These are the actual characters, not escape sequences
        Str path    = StrInitFromZstr("C:\\Program Files\\App");
        Str message = StrInitFromZstr("Hello, \"World\"!");
        Str data    = StrInitFromZstr("line1\nline2\ttab");

In Write.EdgeCases.c:239:

        // Note: These are the actual characters, not escape sequences
        Str path    = StrInitFromZstr("C:\\Program Files\\App");
        Str message = StrInitFromZstr("Hello, \"World\"!");
        Str data    = StrInitFromZstr("line1\nline2\ttab");

In Write.EdgeCases.c:240:

        Str path    = StrInitFromZstr("C:\\Program Files\\App");
        Str message = StrInitFromZstr("Hello, \"World\"!");
        Str data    = StrInitFromZstr("line1\nline2\ttab");
    
        JW_OBJ(json, {

In Write.EdgeCases.c:273:

    
        // These contain actual special characters that should be escaped
        Str quotes    = StrInitFromZstr("\"quotes\"");
        Str backslash = StrInitFromZstr("\\");
        Str newline   = StrInitFromZstr("\n");

In Write.EdgeCases.c:274:

        // These contain actual special characters that should be escaped
        Str quotes    = StrInitFromZstr("\"quotes\"");
        Str backslash = StrInitFromZstr("\\");
        Str newline   = StrInitFromZstr("\n");
        Str tab       = StrInitFromZstr("\t");

In Write.EdgeCases.c:275:

        Str quotes    = StrInitFromZstr("\"quotes\"");
        Str backslash = StrInitFromZstr("\\");
        Str newline   = StrInitFromZstr("\n");
        Str tab       = StrInitFromZstr("\t");

In Write.EdgeCases.c:276:

        Str backslash = StrInitFromZstr("\\");
        Str newline   = StrInitFromZstr("\n");
        Str tab       = StrInitFromZstr("\t");
    
        JW_OBJ(json, {

In Write.EdgeCases.c:455:

    
        // Single string
        Str single_str = StrInitFromZstr("hello");
        JW_OBJ(json2, { JW_STR_KV(json2, "text", single_str); });

In Write.Simple.c:60:

    bool compare_json_output(const Str *output, const char *expected) {
        // Create a copy of expected without spaces for comparison
        Str expected_str   = StrInitFromZstr(expected);
        Str output_clean   = StrInit();
        Str expected_clean = StrInit();

In Write.Simple.c:108:

        Str  json    = StrInit();
    
        Str name = StrInitFromZstr("Alice");
        Str city = StrInitFromZstr("New York");

In Write.Simple.c:109:

    
        Str name = StrInitFromZstr("Alice");
        Str city = StrInitFromZstr("New York");
    
        JW_OBJ(json, {

In Write.Simple.c:184:

        Str  json    = StrInit();
    
        Person person = {1001, StrInitFromZstr("Bob"), 25, true, 50000.0};
    
        JW_OBJ(json, {

In Write.Simple.c:211:

        Str  json    = StrInit();
    
        Config config = {false, 30, StrInitFromZstr("INFO")};
    
        JW_OBJ(json, {

In Write.Simple.c:239:

    
        // Create strings and push them properly
        Str lang1 = StrInitFromZstr("C");
        Str lang2 = StrInitFromZstr("Python");
        Str lang3 = StrInitFromZstr("Rust");

In Write.Simple.c:240:

        // Create strings and push them properly
        Str lang1 = StrInitFromZstr("C");
        Str lang2 = StrInitFromZstr("Python");
        Str lang3 = StrInitFromZstr("Rust");

In Write.Simple.c:241:

        Str lang1 = StrInitFromZstr("C");
        Str lang2 = StrInitFromZstr("Python");
        Str lang3 = StrInitFromZstr("Rust");
    
        VecPushBack(&languages, lang1);

In Write.Simple.c:273:

            bool active;
        } data = {
            {StrInitFromZstr("Charlie"), StrInitFromZstr("charlie@example.com")},
            true
        };

In Write.Simple.c:305:

        SimpleProduct product = {0};
        product.id            = 12345;
        product.name          = StrInitFromZstr("Laptop");
        product.price         = 999.99;
        product.tags          = VecInitWithDeepCopyT(product.tags, NULL, StrDeinit);

In Write.Simple.c:310:

    
        // Create strings and push them properly
        Str tag1 = StrInitFromZstr("electronics");
        Str tag2 = StrInitFromZstr("computers");
        Str tag3 = StrInitFromZstr("portable");

In Write.Simple.c:311:

        // Create strings and push them properly
        Str tag1 = StrInitFromZstr("electronics");
        Str tag2 = StrInitFromZstr("computers");
        Str tag3 = StrInitFromZstr("portable");

In Write.Simple.c:312:

        Str tag1 = StrInitFromZstr("electronics");
        Str tag2 = StrInitFromZstr("computers");
        Str tag3 = StrInitFromZstr("portable");
    
        VecPushBack(&product.tags, tag1);

In RoundTrip.c:96:

            bool enabled;
            Str  message;
        } original = {42, 25.5, true, StrInitFromZstr("hello world")};
    
        // Write to JSON

In RoundTrip.c:292:

        } original = {
            StrInit(),
            StrInitFromZstr("hello"),
            StrInitFromZstr("hello world with spaces"),
            StrInitFromZstr("special: !@#$%^&*()")

In RoundTrip.c:293:

            StrInit(),
            StrInitFromZstr("hello"),
            StrInitFromZstr("hello world with spaces"),
            StrInitFromZstr("special: !@#$%^&*()")
        };

In RoundTrip.c:294:

            StrInitFromZstr("hello"),
            StrInitFromZstr("hello world with spaces"),
            StrInitFromZstr("special: !@#$%^&*()")
        };

In RoundTrip.c:362:

    
        // Create strings and push them properly
        Str str1 = StrInitFromZstr("first");
        Str str2 = StrInitFromZstr("second");
        Str str3 = StrInitFromZstr("");

In RoundTrip.c:363:

        // Create strings and push them properly
        Str str1 = StrInitFromZstr("first");
        Str str2 = StrInitFromZstr("second");
        Str str3 = StrInitFromZstr("");
        Str str4 = StrInitFromZstr("last");

In RoundTrip.c:364:

        Str str1 = StrInitFromZstr("first");
        Str str2 = StrInitFromZstr("second");
        Str str3 = StrInitFromZstr("");
        Str str4 = StrInitFromZstr("last");

In RoundTrip.c:365:

        Str str2 = StrInitFromZstr("second");
        Str str3 = StrInitFromZstr("");
        Str str4 = StrInitFromZstr("last");
    
        VecPushBack(&original_strings, str1);

In RoundTrip.c:455:

    
        // Original data
        TestPerson original_person = {12345, StrInitFromZstr("John Doe"), 30, true, 75000.50};
    
        // Write to JSON

In RoundTrip.c:507:

        ComplexData original    = {0};
        original.user.id        = 999;
        original.user.name      = StrInitFromZstr("Complex User");
        original.user.age       = 25;
        original.user.is_active = true;

In RoundTrip.c:514:

        original.config.debug_mode = false;
        original.config.timeout    = 30;
        original.config.log_level  = StrInitFromZstr("INFO");
        original.config.features   = VecInitWithDeepCopyT(original.config.features, NULL, StrDeinit);

In RoundTrip.c:518:

    
        // Create strings and push them properly
        Str feature1 = StrInitFromZstr("auth");
        Str feature2 = StrInitFromZstr("logging");

In RoundTrip.c:519:

        // Create strings and push them properly
        Str feature1 = StrInitFromZstr("auth");
        Str feature2 = StrInitFromZstr("logging");
    
        VecPushBack(&original.config.features, feature1);

In Read.EdgeCases.c:50:

    
        // Test completely empty object
        Str     json1 = StrInitFromZstr("{}");
        StrIter si1   = StrIterFromStr(json1);

In Read.EdgeCases.c:70:

    
        // Test empty object with whitespace
        Str     json2 = StrInitFromZstr("  {   }  ");
        StrIter si2   = StrIterFromStr(json2);

In Read.EdgeCases.c:99:

    
        // Test completely empty array
        Str     json1 = StrInitFromZstr("{\"items\":[]}");
        StrIter si1   = StrIterFromStr(json1);

In Read.EdgeCases.c:120:

    
        // Test empty array with whitespace
        Str     json2 = StrInitFromZstr("{\"data\": [  ] }");
        StrIter si2   = StrIterFromStr(json2);

In Read.EdgeCases.c:153:

        bool success = true;
    
        Str     json = StrInitFromZstr("{\"name\":\"\",\"description\":\"\"}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:189:

        bool success = true;
    
        Str     json = StrInitFromZstr("{\"temp\":-25,\"balance\":-1000.50,\"delta\":-0.001}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:231:

        bool success = true;
    
        Str json = StrInitFromZstr(
            "{\"big_int\":9223372036854775807,\"big_float\":1.7976931348623157e+308,\"small_float\":2.2250738585072014e-"
            "308}"

In Read.EdgeCases.c:274:

        bool success = true;
    
        Str     json = StrInitFromZstr("{\"int_zero\":0,\"float_zero\":0.0,\"bool_false\":false}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:317:

    
        // Test with various special characters that might be problematic
        Str json = StrInitFromZstr(
            "{\"path\":\"C:\\\\Program Files\\\\App\",\"message\":\"Hello, "
            "\\\"World\\\"!\",\"data\":\"line1\\nline2\\ttab\"}"

In Read.EdgeCases.c:361:

    
        Str json =
            StrInitFromZstr("{\"escaped\":\"\\\"quotes\\\"\",\"backslash\":\"\\\\\",\"newline\":\"\\n\",\"tab\":\"\\t\"}");
        StrIter si = StrIterFromStr(json);

In Read.EdgeCases.c:406:

    
        // Test with lots of different whitespace patterns
        Str     json = StrInitFromZstr("  {\n\t\"name\"  :  \"test\"  ,\n  \"value\": 42\t,\"flag\"\n:\ntrue\n}\t");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:449:

        bool success = true;
    
        Str     json = StrInitFromZstr("{\"outer\":{},\"list\":[],\"deep\":{\"inner\":{}}}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:495:

        bool success = true;
    
        Str     json = StrInitFromZstr("{\"empty_obj\":{},\"filled_obj\":{\"x\":1},\"empty_arr\":[],\"filled_arr\":[1,2]}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:557:

    
        // Using smaller values that are safer to work with
        Str     json = StrInitFromZstr("{\"max_int\":2147483647,\"min_int\":-2147483648,\"one\":1,\"minus_one\":-1}");
        StrIter si   = StrIterFromStr(json);

In Read.EdgeCases.c:603:

        bool success = true;
    
        Str json   = StrInitFromZstr("{\"tiny\":0.000001,\"huge\":999999.999999,\"zero\":0.0,\"negative_tiny\":-0.000001}");
        StrIter si = StrIterFromStr(json);

In Str.Insert.c:32:

        WriteFmt("Testing StrInsertCharAt\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Insert a character in the middle

In Str.Insert.c:60:

        WriteFmt("Testing StrInsertCstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Insert a string in the middle

In Str.Insert.c:76:

        WriteFmt("Testing StrInsertZstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Insert a string in the middle

In Str.Insert.c:92:

        WriteFmt("Testing StrInsert\n");
    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");

In Str.Insert.c:93:

    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");
    
        // Insert s2 into s1 in the middle

In Str.Insert.c:110:

        WriteFmt("Testing StrPushCstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Push a string at position 2

In Str.Insert.c:126:

        WriteFmt("Testing StrPushZstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Push a string at position 2

In Str.Insert.c:142:

        WriteFmt("Testing StrPushBackCstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Push a string at the back

In Str.Insert.c:158:

        WriteFmt("Testing StrPushBackZstr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Push a string at the back

In Str.Insert.c:174:

        WriteFmt("Testing StrPushFrontCstr\n");
    
        Str s = StrInitFromZstr("World");
    
        // Push a string at the front

In Str.Insert.c:190:

        WriteFmt("Testing StrPushFrontZstr\n");
    
        Str s = StrInitFromZstr("World");
    
        // Push a string at the front

In Str.Insert.c:206:

        WriteFmt("Testing StrPushBack\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Push characters at the back

In Str.Insert.c:227:

        WriteFmt("Testing StrPushFront\n");
    
        Str s = StrInitFromZstr("World");
    
        // Push characters at the front

In Str.Insert.c:248:

        WriteFmt("Testing StrMergeL\n");
    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");

In Str.Insert.c:249:

    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");
    
        // Merge s2 into s1 (L-value semantics)

In Str.Insert.c:273:

        WriteFmt("Testing StrMergeR\n");
    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");

In Str.Insert.c:274:

    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");
    
        // Merge s2 into s1 (R-value semantics)

In Str.Insert.c:294:

        WriteFmt("Testing StrMerge\n");
    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");

In Str.Insert.c:295:

    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr(" World");
    
        // Merge s2 into s1

In Str.Insert.c:315:

        WriteFmt("Testing StrAppendf\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Append formatted string

In Io.Read.c:346:

        StrReadFmt(z, "{}", s);
    
        Str expected = StrInitFromZstr("Hello");
        success      = success && (StrCmp(&s, &expected) == 0);
        StrDeinit(&expected);

In Io.Read.c:355:

        StrReadFmt(z, "{s}", s);
    
        expected = StrInitFromZstr("Hello, World!");
        success  = success && (StrCmp(&s, &expected) == 0);
        StrDeinit(&expected);

In Io.Read.c:379:

        success = success && (num == 42);
    
        Str expected = StrInitFromZstr("Alice");
        success      = success && (StrCmp(&name, &expected) == 0);
        StrDeinit(&expected);

In Io.Read.c:391:

        success = success && double_equals(val, 3.14);
    
        expected = StrInitFromZstr("Bob");
        success  = success && (StrCmp(&name, &expected) == 0);
        StrDeinit(&expected);

In Io.Read.c:591:

        z           = "Hello";
        StrReadFmt(z, "{c}", str_val);
        Str  expected = StrInitFromZstr("Hello");
        bool str_pass = (StrCmp(&str_val, &expected) == 0);
        WriteFmt("str_val test: comparing with 'Hello', pass = {}\n", str_pass ? "true" : "false");

In Io.Read.c:601:

        z       = "\"World\"";
        StrReadFmt(z, "{cs}", str_val);
        expected             = StrInitFromZstr("World");
        bool quoted_str_pass = (StrCmp(&str_val, &expected) == 0);
        WriteFmt("quoted str_val test: comparing with 'World', pass = {}\n", quoted_str_pass ? "true" : "false");

In Io.Read.c:636:

    
            // Should read "hello" (stops at first space)
            Str  expected   = StrInitFromZstr("hello world");
            bool test1_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'hello', Pass: {}\n\n", test1_pass ? "true" : "false");

In Io.Read.c:661:

    
            // Should read "hello" (stops at first space)
            Str  expected   = StrInitFromZstr("hello");
            bool test1_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'hello', Pass: {}\n\n", test1_pass ? "true" : "false");

In Io.Read.c:686:

    
            // Should read "HELLO" (stops at first space)
            Str  expected   = StrInitFromZstr("HELLO WORLD");
            bool test2_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'HELLO', Pass: {}\n\n", test2_pass ? "true" : "false");

In Io.Read.c:755:

    
            // Should read "mixed case" (converts the entire quoted string)
            Str  expected   = StrInitFromZstr("mixed case");
            bool test3_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'mixed case', Pass: {}\n\n", test3_pass ? "true" : "false");

In Io.Read.c:780:

    
            // Should read "ABC123XYZ" (only letters are converted, numbers unchanged)
            Str  expected   = StrInitFromZstr("ABC123XYZ");
            bool test4_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'ABC123XYZ', Pass: {}\n\n", test4_pass ? "true" : "false");

In Io.Read.c:805:

    
            // Should read "Hello" (stops at first space, no case conversion)
            Str  expected   = StrInitFromZstr("Hello World");
            bool test5_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'Hello World', Pass: {}\n\n", test5_pass ? "true" : "false");

In Str.Type.c:48:

    
        // Add some strings
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr("World");

In Str.Type.c:49:

        // Add some strings
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr("World");
    
        VecPushBack(&sv, s1);

In Io.Write.c:94:

    
        // Test Str object
        Str s = StrInitFromZstr("World");
        StrWriteFmt(&output, "{}", s);
        success = success && (ZstrCompare(output.data, "World") == 0);

In Io.Write.c:382:

    
        // Test with Str object
        Str s = StrInitFromZstr("MiXeD CaSe");
    
        // Test with :c (preserve case)

In Str.Foreach.c:36:

        WriteFmt("Testing StrForeachIdx\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character with its index

In Str.Foreach.c:56:

        WriteFmt("Testing StrForeachReverseIdx\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character in reverse with its index

In Str.Foreach.c:78:

        WriteFmt("Testing StrForeachPtrIdx\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character pointer with its index

In Str.Foreach.c:107:

        WriteFmt("Testing StrForeachReversePtrIdx\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character pointer in reverse with its index

In Str.Foreach.c:136:

        WriteFmt("Testing StrForeach\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character

In Str.Foreach.c:157:

        WriteFmt("Testing StrForeachReverse\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character in reverse

In Str.Foreach.c:188:

        WriteFmt("Testing StrForeachPtr\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character pointer

In Str.Foreach.c:217:

        WriteFmt("Testing StrForeachPtrReverse\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Build a new string by iterating through each character pointer in reverse

In Str.Foreach.c:256:

        WriteFmt("Testing StrForeachInRangeIdx\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Build a new string by iterating through a range of characters with indices

In Str.Foreach.c:288:

        WriteFmt("Testing StrForeachInRange\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Build a new string by iterating through a range of characters

In Str.Foreach.c:320:

        WriteFmt("Testing StrForeachPtrInRangeIdx\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Build a new string by iterating through a range of character pointers with indices

In Str.Foreach.c:349:

        WriteFmt("Testing StrForeachPtrInRange\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Build a new string by iterating through a range of character pointers

In Str.Foreach.c:378:

        WriteFmt("Testing StrForeachInRangeIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Hello World!"); // 12 characters
    
        // Use StrForeachInRangeIdx which captures the 'end' parameter at the start

In Str.Foreach.c:411:

        WriteFmt("Testing StrForeachInRangeIdx with character deletion where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Programming"); // 11 characters
    
        // Use StrForeachInRangeIdx with a fixed range that will become invalid

In Str.Foreach.c:444:

        WriteFmt("Testing StrForeachReverseIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Beautiful Weather"); // 17 characters
    
        // StrForeachReverseIdx (VecForeachReverseIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)

In Str.Foreach.c:475:

        WriteFmt("Testing StrForeachPtrIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Programming Test"); // 16 characters
    
        // StrForeachPtrIdx (VecForeachPtrIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)

In Str.Foreach.c:506:

        WriteFmt("Testing StrForeachReversePtrIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Excellent Example"); // 17 characters
    
        // StrForeachReversePtrIdx (VecForeachPtrReverseIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)

In Str.Foreach.c:536:

        WriteFmt("Testing StrForeachPtrInRangeIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Comprehensive Testing Framework"); // 31 characters
    
        // Use StrForeachPtrInRangeIdx with a fixed range that becomes invalid when we modify the string

In Str.Foreach.c:567:

        WriteFmt("Testing basic StrForeachIdx where idx goes out of bounds\n");
    
        Str s = StrInitFromZstr("Testing Basic"); // 13 characters
    
        // Basic StrForeachIdx (VecForeachIdx) now has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)

In Str.Convert.c:232:

    
        // Test decimal conversion
        Str  s       = StrInitFromZstr("12345");
        u64  value   = 0;
        bool success = StrToU64(&s, &value, NULL);

In Str.Convert.c:239:

        // Test hexadecimal conversion with explicit base
        StrDeinit(&s);
        s                     = StrInitFromZstr("ABCD"); // No 0x prefix when base is explicitly 16
        StrParseConfig config = {.base = 16};
        success               = StrToU64(&s, &value, &config);

In Str.Convert.c:246:

        // Test hexadecimal conversion (auto-detect base with 0)
        StrDeinit(&s);
        s       = StrInitFromZstr("0xABCD");
        success = StrToU64(&s, &value, NULL);
        result  = result && (success && value == 0xABCD);

In Str.Convert.c:252:

        // Test binary conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("0b101010");
        success = StrToU64(&s, &value, NULL);
        result  = result && (success && value == 42);

In Str.Convert.c:258:

        // Test octal conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("0o52");
        success = StrToU64(&s, &value, NULL);
        result  = result && (success && value == 42);

In Str.Convert.c:264:

        // Test zero
        StrDeinit(&s);
        s       = StrInitFromZstr("0");
        success = StrToU64(&s, &value, NULL);
        result  = result && (success && value == 0);

In Str.Convert.c:270:

        // Test invalid input
        StrDeinit(&s);
        s       = StrInitFromZstr("not a number");
        success = StrToU64(&s, &value, NULL);
        result  = result && (!success);

In Str.Convert.c:276:

        // Test negative number (should fail for unsigned)
        StrDeinit(&s);
        s       = StrInitFromZstr("-123");
        success = StrToU64(&s, &value, NULL);
        result  = result && (!success);

In Str.Convert.c:289:

    
        // Test positive decimal conversion
        Str  s       = StrInitFromZstr("12345");
        i64  value   = 0;
        bool success = StrToI64(&s, &value, NULL);

In Str.Convert.c:296:

        // Test negative decimal conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("-12345");
        success = StrToI64(&s, &value, NULL);
        result  = result && (success && value == -12345);

In Str.Convert.c:302:

        // Test hexadecimal conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("0xABCD");
        success = StrToI64(&s, &value, NULL);
        result  = result && (success && value == 0xABCD);

In Str.Convert.c:308:

        // Test binary conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("0b101010");
        success = StrToI64(&s, &value, NULL);
        result  = result && (success && value == 42);

In Str.Convert.c:314:

        // Test zero
        StrDeinit(&s);
        s       = StrInitFromZstr("0");
        success = StrToI64(&s, &value, NULL);
        result  = result && (success && value == 0);

In Str.Convert.c:320:

        // Test invalid input
        StrDeinit(&s);
        s       = StrInitFromZstr("not a number");
        success = StrToI64(&s, &value, NULL);
        result  = result && (!success);

In Str.Convert.c:333:

    
        // Test integer conversion
        Str  s       = StrInitFromZstr("123");
        f64  value   = 0.0;
        bool success = StrToF64(&s, &value, NULL);

In Str.Convert.c:340:

        // Test fractional conversion
        StrDeinit(&s);
        s       = StrInitFromZstr("123.456");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && fabs(value - 123.456) < 0.0001);

In Str.Convert.c:346:

        // Test negative number
        StrDeinit(&s);
        s       = StrInitFromZstr("-123.456");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && fabs(value - (-123.456)) < 0.0001);

In Str.Convert.c:352:

        // Test scientific notation
        StrDeinit(&s);
        s       = StrInitFromZstr("1.23e2");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && fabs(value - 123.0) < 0.0001);

In Str.Convert.c:358:

        // Test zero
        StrDeinit(&s);
        s       = StrInitFromZstr("0");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && fabs(value) < 0.0001);

In Str.Convert.c:364:

        // Test infinity
        StrDeinit(&s);
        s       = StrInitFromZstr("inf");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && isinf(value) && value > 0);

In Str.Convert.c:370:

        // Test negative infinity
        StrDeinit(&s);
        s       = StrInitFromZstr("-inf");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && isinf(value) && value < 0);

In Str.Convert.c:376:

        // Test NaN
        StrDeinit(&s);
        s       = StrInitFromZstr("nan");
        success = StrToF64(&s, &value, NULL);
        result  = result && (success && isnan(value));

In Str.Convert.c:382:

        // Test invalid input
        StrDeinit(&s);
        s       = StrInitFromZstr("not a number");
        success = StrToF64(&s, &value, NULL);
        result  = result && (!success);

In Str.Convert.c:543:

    
        for (size_t i = 0; i < sizeof(prefix_tests) / sizeof(prefix_tests[0]); i++) {
            Str            test_str = StrInitFromZstr(prefix_tests[i].input);
            u64            value    = 0;
            StrParseConfig config   = {.base = prefix_tests[i].base};

In Str.Convert.c:747:

        strcpy(long_number, "12345678901234567890123456789012345678901234567890");
    
        Str  long_str   = StrInitFromZstr(long_number);
        u64  long_value = 0;
        bool success    = StrToU64(&long_str, &long_value, NULL);

In Str.Memory.c:46:

        WriteFmt("Testing StrSwapCharAt\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Swap 'H' and 'o'

In Str.Memory.c:68:

        WriteFmt("Testing StrResize\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Initial length should be 5

In Str.Memory.c:119:

        WriteFmt("Testing StrClear\n");
    
        Str s = StrInitFromZstr("Hello, World!");
    
        // Initial length should be 13

In Str.Memory.c:141:

        WriteFmt("Testing StrReverse\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Reverse the string

In Str.Memory.c:151:

        // Test with an even-length string
        StrDeinit(&s);
        s = StrInitFromZstr("abcd");
    
        // Reverse the string

In Str.Memory.c:161:

        // Test with a single-character string
        StrDeinit(&s);
        s = StrInitFromZstr("a");
    
        // Reverse the string

In Str.Ops.c:23:

        WriteFmt("Testing StrCmp and StrCmpCstr\n");
    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr("Hello");
        Str s3 = StrInitFromZstr("World");

In Str.Ops.c:24:

    
        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr("Hello");
        Str s3 = StrInitFromZstr("World");
        Str s4 = StrInitFromZstr("Hello World");

In Str.Ops.c:25:

        Str s1 = StrInitFromZstr("Hello");
        Str s2 = StrInitFromZstr("Hello");
        Str s3 = StrInitFromZstr("World");
        Str s4 = StrInitFromZstr("Hello World");

In Str.Ops.c:26:

        Str s2 = StrInitFromZstr("Hello");
        Str s3 = StrInitFromZstr("World");
        Str s4 = StrInitFromZstr("Hello World");
    
        // Test StrCmp with equal strings

In Str.Ops.c:58:

        WriteFmt("Testing StrFindStr, StrFindZstr, and StrFindCstr\n");
    
        Str haystack = StrInitFromZstr("Hello World");
        Str needle1  = StrInitFromZstr("World");
        Str needle2  = StrInitFromZstr("Hello");

In Str.Ops.c:59:

    
        Str haystack = StrInitFromZstr("Hello World");
        Str needle1  = StrInitFromZstr("World");
        Str needle2  = StrInitFromZstr("Hello");
        Str needle3  = StrInitFromZstr("NotFound");

In Str.Ops.c:60:

        Str haystack = StrInitFromZstr("Hello World");
        Str needle1  = StrInitFromZstr("World");
        Str needle2  = StrInitFromZstr("Hello");
        Str needle3  = StrInitFromZstr("NotFound");

In Str.Ops.c:61:

        Str needle1  = StrInitFromZstr("World");
        Str needle2  = StrInitFromZstr("Hello");
        Str needle3  = StrInitFromZstr("NotFound");
    
        // Test StrFindStr with match at end

In Str.Ops.c:94:

        WriteFmt("Testing StrStartsWith and StrEndsWith variants\n");
    
        Str s      = StrInitFromZstr("Hello World");
        Str prefix = StrInitFromZstr("Hello");
        Str suffix = StrInitFromZstr("World");

In Str.Ops.c:95:

    
        Str s      = StrInitFromZstr("Hello World");
        Str prefix = StrInitFromZstr("Hello");
        Str suffix = StrInitFromZstr("World");

In Str.Ops.c:96:

        Str s      = StrInitFromZstr("Hello World");
        Str prefix = StrInitFromZstr("Hello");
        Str suffix = StrInitFromZstr("World");
    
        // Test StrStartsWith

In Str.Ops.c:131:

    
        // Test StrReplaceZstr
        Str s1 = StrInitFromZstr("Hello World");
        StrReplaceZstr(&s1, "World", "Universe", 1);
        bool result = (ZstrCompare(s1.data, "Hello Universe") == 0);

In Str.Ops.c:137:

        // Test multiple replacements
        StrDeinit(&s1);
        s1 = StrInitFromZstr("Hello Hello Hello");
        StrReplaceZstr(&s1, "Hello", "Hi", 2);
        result = result && (ZstrCompare(s1.data, "Hi Hi Hello") == 0);

In Str.Ops.c:143:

        // Test StrReplaceCstr - use the full "World" string instead of just "Wo"
        StrDeinit(&s1);
        s1 = StrInitFromZstr("Hello World");
        StrReplaceCstr(&s1, "World", 5, "Universe", 8, 1);
        result = result && (ZstrCompare(s1.data, "Hello Universe") == 0);

In Str.Ops.c:149:

        // Test StrReplace
        StrDeinit(&s1);
        s1          = StrInitFromZstr("Hello World");
        Str find    = StrInitFromZstr("World");
        Str replace = StrInitFromZstr("Universe");

In Str.Ops.c:150:

        StrDeinit(&s1);
        s1          = StrInitFromZstr("Hello World");
        Str find    = StrInitFromZstr("World");
        Str replace = StrInitFromZstr("Universe");
        StrReplace(&s1, &find, &replace, 1);

In Str.Ops.c:151:

        s1          = StrInitFromZstr("Hello World");
        Str find    = StrInitFromZstr("World");
        Str replace = StrInitFromZstr("Universe");
        StrReplace(&s1, &find, &replace, 1);
        result = result && (ZstrCompare(s1.data, "Hello Universe") == 0);

In Str.Ops.c:166:

    
        // Test StrSplit
        Str  s     = StrInitFromZstr("Hello,World,Test");
        Strs split = StrSplit(&s, ",");

In Str.Ops.c:212:

    
        // Test StrLStrip
        Str  s1       = StrInitFromZstr("  Hello  ");
        Str  stripped = StrLStrip(&s1, NULL);
        bool result   = (ZstrCompare(stripped.data, "Hello  ") == 0);

In Str.Ops.c:229:

        // Test with custom strip characters
        StrDeinit(&s1);
        s1 = StrInitFromZstr("***Hello***");
    
        stripped = StrLStrip(&s1, "*");

In Str.Access.c:22:

        WriteFmt("Testing StrFirst\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Get the first character

In Str.Access.c:38:

        WriteFmt("Testing StrLast\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Get the last character

In Str.Access.c:54:

        WriteFmt("Testing StrBegin\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Get a pointer to the first character using StrBegin

In Str.Access.c:70:

        WriteFmt("Testing StrEnd\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Get a pointer to one past the last character using StrEnd

In Str.Access.c:86:

        WriteFmt("Testing StrCharAt\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Access characters at different indices

In Str.Access.c:107:

        WriteFmt("Testing StrCharPtrAt\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Access character pointers at different indices

In Str.Init.c:58:

    // Test StrInitFromZstr function
    bool test_str_init_from_zstr(void) {
        WriteFmt("Testing StrInitFromZstr\n");
    
        const char *test_str = "Hello, World!";

In Str.Init.c:61:

    
        const char *test_str = "Hello, World!";
        Str         s        = StrInitFromZstr(test_str);
    
        // Validate the string

In Str.Init.c:77:

        WriteFmt("Testing StrInitFromStr\n");
    
        Str src = StrInitFromZstr("Hello, World!");
        Str dst = StrInitFromStr(&src);

In Str.Init.c:96:

        WriteFmt("Testing StrDup\n");
    
        Str src = StrInitFromZstr("Hello, World!");
        Str dst = StrDup(&src);

In Str.Init.c:166:

        WriteFmt("Testing StrInitCopy\n");
    
        Str src = StrInitFromZstr("Hello, World!");
        Str dst = StrInit();

In Str.Init.c:188:

        WriteFmt("Testing StrDeinit\n");
    
        Str s = StrInitFromZstr("Hello, World!");
    
        // Validate the string before deinit

In Str.Remove.c:23:

        WriteFmt("Testing StrPopBack\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Pop a character from the back

In Str.Remove.c:47:

        WriteFmt("Testing StrPopFront\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Pop a character from the front

In Str.Remove.c:71:

        WriteFmt("Testing StrRemove\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Remove a character from the middle

In Str.Remove.c:95:

        WriteFmt("Testing StrRemoveRange\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Create a buffer to store the removed characters

In Str.Remove.c:122:

        WriteFmt("Testing StrDeleteLastChar\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Delete the last character

In Str.Remove.c:144:

        WriteFmt("Testing StrDelete\n");
    
        Str s = StrInitFromZstr("Hello");
    
        // Delete a character from the middle

In Str.Remove.c:166:

        WriteFmt("Testing StrDeleteRange\n");
    
        Str s = StrInitFromZstr("Hello World");
    
        // Delete a range of characters

Last updated on April 20, 2026

StrInitFromStr StrInitStack