WriteFmt

Documentation

API Reference

WriteFmt

Description

Write formatted output to the standard output stream (FileStdout()). This is a convenience macro calling FWriteFmt with FileStdout().

Parameters

Name	Direction	Description
`fmtstr`	in	Format string with `{}` placeholders.

Success

Placeholders in fmtstr are replaced by the passed arguments, and the resulting formatted string is written to standard output.

Failure

Failure might occur during memory allocation for the temporary string or during the write operation; the backend may also log an error message.

Usage example (Cross-references)

Usage examples (Cross-references)

In TestRunner.c:219:

    bool test_deadend(TestFunction test_func, bool expect_failure) {
        if (!test_func) {
            WriteFmt("[ERROR] test_deadend: NULL test function provided\n");
            return false;
        }

In TestRunner.c:231:

            bool returned = test_func();
            if (expect_failure) {
                WriteFmt("    [Unexpected success: Test completed without abort]\n");
                test_result = false;    // Expected abort, got clean return.
            } else {

In TestRunner.c:234:

                test_result = false;    // Expected abort, got clean return.
            } else {
                WriteFmt("    [Success: Test completed normally]\n");
                test_result = returned; // Caller's bool is the verdict.
            }

In TestRunner.c:240:

            // Re-entry via longjmp: the test triggered LOG_FATAL.
            if (expect_failure) {
                WriteFmt("    [Expected failure: Test aborted as expected]\n");
                test_result = true; // Abort was the contract.
            } else {

In TestRunner.c:243:

                test_result = true; // Abort was the contract.
            } else {
                WriteFmt("    [Unexpected failure: Test aborted unexpectedly]\n");
                test_result = false;
            }

In TestRunner.c:257:

    int simple_test_driver(TestFunction *tests, int count) {
        if (!tests) {
            WriteFmt("[ERROR] simple_test_driver: NULL tests array provided\n");
            return count; // All tests failed
        }

In TestRunner.c:266:

        // Run all tests and accumulate results
        for (int i = 0; i < count; i++) {
            WriteFmt("[TEST {}/{}] ", i + 1, count);
            bool result = tests[i]();
            if (result) {

In TestRunner.c:269:

            bool result = tests[i]();
            if (result) {
                WriteFmt("[PASS]\n\n");
                passed++;
            } else {

In TestRunner.c:272:

                passed++;
            } else {
                WriteFmt("[FAIL]\n\n");
                failed++;
            }

In TestRunner.c:278:

    
        // Print summary
        WriteFmt("[SUMMARY] Total: {}, Passed: {}, Failed: {}\n", count, passed, failed);
    
        return failed;

In TestRunner.c:286:

    int deadend_test_driver(TestFunction *tests, int count) {
        if (!tests) {
            WriteFmt("[ERROR] deadend_test_driver: NULL tests array provided\n");
            return count; // All tests failed
        }

In TestRunner.c:290:

        }
    
        WriteFmt("\n[INFO] Testing deadend scenarios\n\n");
    
        int passed = 0;

In TestRunner.c:297:

        // Run all deadend tests (expecting failure)
        for (int i = 0; i < count; i++) {
            WriteFmt("[TEST {}/{}] ", i + 1, count);
            bool result = test_deadend(tests[i], true); // All deadend tests expect failure
            if (result) {

In TestRunner.c:300:

            bool result = test_deadend(tests[i], true); // All deadend tests expect failure
            if (result) {
                WriteFmt("[PASS]\n\n");
                passed++;
            } else {

In TestRunner.c:303:

                passed++;
            } else {
                WriteFmt("[FAIL]\n\n");
                failed++;
            }

In TestRunner.c:309:

    
        // Print summary
        WriteFmt("[SUMMARY] Deadend tests - Total: {}, Passed: {}, Failed: {}\n", count, passed, failed);
    
        return failed;

In TestRunner.c:322:

        Zstr          test_name
    ) {
        WriteFmt("[INFO] Starting {} tests\n\n", test_name ? test_name : "Test Suite");
    
        int total_failed = 0;

In TestRunner.c:339:

    
        // Print final summary
        WriteFmt(
            "\n[FINAL SUMMARY] {} - Normal: {} tests, Deadend: {} tests, Total Failed: {}\n",
            test_name ? test_name : "Test Suite",

In Read.EdgeCases.c:158:

    // Test 3: Empty string reading
    bool test_empty_string_reading(void) {
        WriteFmt("Testing empty string reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:178:

    
        if (StrLen(&obj.name) == 0 && StrLen(&obj.description) == 0) {
            WriteFmt("[DEBUG] Empty string test passed - both strings empty\n");
        } else {
            WriteFmt(

In Read.EdgeCases.c:180:

            WriteFmt("[DEBUG] Empty string test passed - both strings empty\n");
        } else {
            WriteFmt(
                "[DEBUG] Empty string test FAILED - name len: {}, desc len: {}\n",
                StrLen(&obj.name),

In Read.EdgeCases.c:197:

    // Test 4: Negative numbers reading
    bool test_negative_numbers_reading(void) {
        WriteFmt("Testing negative numbers reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:219:

    
        if (obj.temp == -25 && obj.balance == -1000.50 && obj.delta == -0.001) {
            WriteFmt(
                "[DEBUG] Negative numbers test passed - temp: {}, balance: {}, delta: {}\n",
                obj.temp,

In Read.EdgeCases.c:226:

            );
        } else {
            WriteFmt(
                "[DEBUG] Negative numbers test FAILED - temp: {}, balance: {}, delta: {}\n",
                obj.temp,

In Read.EdgeCases.c:242:

    // Test 5: Large numbers reading
    bool test_large_numbers_reading(void) {
        WriteFmt("Testing large numbers reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:268:

    
        if (obj.big_int == 9223372036854775807LL) {
            WriteFmt("[DEBUG] Large integer test passed: {}\n", obj.big_int);
        } else {
            WriteFmt("[DEBUG] Large integer test FAILED: expected 9223372036854775807, got {}\n", obj.big_int);

In Read.EdgeCases.c:270:

            WriteFmt("[DEBUG] Large integer test passed: {}\n", obj.big_int);
        } else {
            WriteFmt("[DEBUG] Large integer test FAILED: expected 9223372036854775807, got {}\n", obj.big_int);
            success = false;
        }

In Read.EdgeCases.c:276:

        // Check if floats are in reasonable range (may not be exact due to precision)
        if (obj.big_float > 1.0e+300 && obj.small_float > 0 && obj.small_float < 1.0e-300) {
            WriteFmt("[DEBUG] Large float test passed\n");
        } else {
            WriteFmt("[DEBUG] Large float test FAILED - big: {e}, small: {e}\n", obj.big_float, obj.small_float);

In Read.EdgeCases.c:278:

            WriteFmt("[DEBUG] Large float test passed\n");
        } else {
            WriteFmt("[DEBUG] Large float test FAILED - big: {e}, small: {e}\n", obj.big_float, obj.small_float);
            success = false;
        }

In Read.EdgeCases.c:289:

    // Test 6: Zero values reading
    bool test_zero_values_reading(void) {
        WriteFmt("Testing zero values reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:311:

    
        if (obj.int_zero == 0 && obj.float_zero == 0.0 && obj.bool_false == false) {
            WriteFmt(
                "[DEBUG] Zero values test passed - int: {}, float: {}, bool: {}\n",
                obj.int_zero,

In Read.EdgeCases.c:318:

            );
        } else {
            WriteFmt(
                "[DEBUG] Zero values test FAILED - int: {}, float: {}, bool: {}\n",
                obj.int_zero,

In Read.EdgeCases.c:334:

    // Test 7: Special characters in strings
    bool test_special_characters_in_strings(void) {
        WriteFmt("Testing special characters in strings\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:360:

        });
    
        WriteFmt("[DEBUG] Special chars - path: '{}'\n", obj.path);
        WriteFmt("[DEBUG] Special chars - message: '{}'\n", obj.message);
        WriteFmt("[DEBUG] Special chars - data: '{}'\n", obj.data);

In Read.EdgeCases.c:361:

    
        WriteFmt("[DEBUG] Special chars - path: '{}'\n", obj.path);
        WriteFmt("[DEBUG] Special chars - message: '{}'\n", obj.message);
        WriteFmt("[DEBUG] Special chars - data: '{}'\n", obj.data);

In Read.EdgeCases.c:362:

        WriteFmt("[DEBUG] Special chars - path: '{}'\n", obj.path);
        WriteFmt("[DEBUG] Special chars - message: '{}'\n", obj.message);
        WriteFmt("[DEBUG] Special chars - data: '{}'\n", obj.data);
    
        // Check if strings were parsed (exact content may vary based on escape handling)

In Read.EdgeCases.c:366:

        // Check if strings were parsed (exact content may vary based on escape handling)
        if (StrLen(&obj.path) > 0 && StrLen(&obj.message) > 0 && StrLen(&obj.data) > 0) {
            WriteFmt("[DEBUG] Special characters test passed - all strings parsed\n");
        } else {
            WriteFmt("[DEBUG] Special characters test FAILED - some strings empty\n");

In Read.EdgeCases.c:368:

            WriteFmt("[DEBUG] Special characters test passed - all strings parsed\n");
        } else {
            WriteFmt("[DEBUG] Special characters test FAILED - some strings empty\n");
            success = false;
        }

In Read.EdgeCases.c:382:

    // Test 8: Escape sequences reading
    bool test_escape_sequences_reading(void) {
        WriteFmt("Testing escape sequences reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:415:

        // Basic validation that strings were parsed
        if (StrLen(&obj.escaped) > 0 && StrLen(&obj.backslash) > 0 && StrLen(&obj.newline) > 0 && StrLen(&obj.tab) > 0) {
            WriteFmt("[DEBUG] Escape sequences test passed\n");
        } else {
            WriteFmt("[DEBUG] Escape sequences test FAILED\n");

In Read.EdgeCases.c:417:

            WriteFmt("[DEBUG] Escape sequences test passed\n");
        } else {
            WriteFmt("[DEBUG] Escape sequences test FAILED\n");
            success = false;
        }

In Read.EdgeCases.c:432:

    // Test 9: Whitespace variations reading
    bool test_whitespace_variations_reading(void) {
        WriteFmt("Testing whitespace variations reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:455:

    
        if (StrCmp(&obj.name, "test", 4) == 0 && obj.value == 42 && obj.flag == true) {
            WriteFmt(
                "[DEBUG] Whitespace variations test passed - name: {}, value: {}, flag: {}\n",
                StrBegin(&obj.name),

In Read.EdgeCases.c:462:

            );
        } else {
            WriteFmt(
                "[DEBUG] Whitespace variations test FAILED - name: {}, value: {}, flag: {}\n",
                StrBegin(&obj.name),

In Read.EdgeCases.c:510:

        // found_inner should be true (empty inner object still triggers JR_OBJ_KV)
        if (!obj.found_outer && !obj.found_list && obj.found_deep && !obj.found_inner) {
            WriteFmt("[DEBUG] Nested empty containers test passed\n");
        } else {
            WriteFmt(

In Read.EdgeCases.c:512:

            WriteFmt("[DEBUG] Nested empty containers test passed\n");
        } else {
            WriteFmt(
                "[DEBUG] Nested empty containers test results - outer: {}, list: {}, deep: {}, inner: {}\n",
                obj.found_outer ? "true" : "false",

In Read.EdgeCases.c:528:

    // Test 11: Mixed empty and filled containers
    bool test_mixed_empty_and_filled(void) {
        WriteFmt("Testing mixed empty and filled containers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:568:

        if (obj.x_value == 1 && VecLen(&obj.filled_items) == 2 && VecAt(&obj.filled_items, 0) == 1 &&
            VecAt(&obj.filled_items, 1) == 2) {
            WriteFmt(
                "[DEBUG] Mixed empty and filled test passed - x: {}, items: {}\n",
                obj.x_value,

In Read.EdgeCases.c:574:

            );
        } else {
            WriteFmt(
                "[DEBUG] Mixed empty and filled test FAILED - x: {}, items: {}\n",
                obj.x_value,

In Read.EdgeCases.c:580:

            );
            if (VecLen(&obj.filled_items) > 0) {
                WriteFmt("[DEBUG] First item: {}\n", VecAt(&obj.filled_items, 0));
            }
            success = false;

In Read.EdgeCases.c:593:

    // Test 12: Boundary integers
    bool test_boundary_integers(void) {
        WriteFmt("Testing boundary integers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:618:

    
        if (obj.max_int == 2147483647LL && obj.min_int == -2147483648LL && obj.one == 1 && obj.minus_one == -1) {
            WriteFmt(
                "[DEBUG] Boundary integers test passed - max: {}, min: {}, one: {}, minus_one: {}\n",
                obj.max_int,

In Read.EdgeCases.c:626:

            );
        } else {
            WriteFmt(
                "[DEBUG] Boundary integers test FAILED - max: {}, min: {}, one: {}, minus_one: {}\n",
                obj.max_int,

In Read.EdgeCases.c:643:

    // Test 13: Boundary floats
    bool test_boundary_floats(void) {
        WriteFmt("Testing boundary floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.EdgeCases.c:669:

        if (obj.tiny > 0.0000001 && obj.tiny < 0.00001 && obj.huge > 999999.0 && obj.huge < 1000000.0 && obj.zero == 0.0 &&
            obj.negative_tiny < -0.0000001 && obj.negative_tiny > -0.00001) {
            WriteFmt(
                "[DEBUG] Boundary floats test passed - tiny: {}, huge: {}, zero: {}, neg_tiny: {}\n",
                obj.tiny,

In Read.EdgeCases.c:677:

            );
        } else {
            WriteFmt(
                "[DEBUG] Boundary floats test FAILED - tiny: {}, huge: {}, zero: {}, neg_tiny: {}\n",
                obj.tiny,

In Write.Nested.c:96:

    
        if (!result) {
            WriteFmt("[DEBUG] JSON comparison failed\n");
            WriteFmt("[DEBUG] Expected: '");
            for (u64 i = 0; i < StrLen(&expected_clean); i++) {

In Write.Nested.c:97:

        if (!result) {
            WriteFmt("[DEBUG] JSON comparison failed\n");
            WriteFmt("[DEBUG] Expected: '");
            for (u64 i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);

In Write.Nested.c:99:

            WriteFmt("[DEBUG] Expected: '");
            for (u64 i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);
            }
            WriteFmt("'\n");

In Write.Nested.c:101:

                WriteFmt("{c}", StrBegin(&expected_clean)[i]);
            }
            WriteFmt("'\n");
            WriteFmt("[DEBUG] Got: '");
            for (u64 i = 0; i < StrLen(&output_clean); i++) {

In Write.Nested.c:102:

            }
            WriteFmt("'\n");
            WriteFmt("[DEBUG] Got: '");
            for (u64 i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("%c", StrBegin(&output_clean)[i]);

In Write.Nested.c:104:

            WriteFmt("[DEBUG] Got: '");
            for (u64 i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("%c", StrBegin(&output_clean)[i]);
            }
            WriteFmt("'\n");

In Write.Nested.c:106:

                WriteFmt("%c", StrBegin(&output_clean)[i]);
            }
            WriteFmt("'\n");
        }

In Write.Nested.c:127:

    // Test 1: Two-level nesting writing
    bool test_two_level_nesting_writing(void) {
        WriteFmt("Testing two-level nesting writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:173:

    // Test 2: Three-level nesting writing
    bool test_three_level_nesting_writing(void) {
        WriteFmt("Testing three-level nesting writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:224:

    // Test 3: Complex API response writing
    bool test_complex_api_response_writing(void) {
        WriteFmt("Testing complex API response writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:303:

    // Test 4: Function info array writing
    bool test_function_info_array_writing(void) {
        WriteFmt("Testing function info array writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:343:

    // Test 5: Search results with tags writing
    bool test_search_results_with_tags_writing(void) {
        WriteFmt("Testing search results with tags writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:397:

    // Test 6: Dynamic object keys writing
    bool test_dynamic_object_keys_writing(void) {
        WriteFmt("Testing dynamic object keys writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:463:

    // Test 7: Deeply nested structure writing
    bool test_deeply_nested_structure_writing(void) {
        WriteFmt("Testing deeply nested structure writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Nested.c:502:

    // Test 8: Mixed array types writing
    bool test_mixed_array_types_writing(void) {
        WriteFmt("Testing mixed array types writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:81:

    
        if (!result) {
            WriteFmt("[DEBUG] JSON comparison failed\n");
            WriteFmt("[DEBUG] Expected: '");
            for (size i = 0; i < StrLen(&expected_clean); i++) {

In Write.Simple.c:82:

        if (!result) {
            WriteFmt("[DEBUG] JSON comparison failed\n");
            WriteFmt("[DEBUG] Expected: '");
            for (size i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);

In Write.Simple.c:84:

            WriteFmt("[DEBUG] Expected: '");
            for (size i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);
            }
            WriteFmt("'\n");

In Write.Simple.c:86:

                WriteFmt("{c}", StrBegin(&expected_clean)[i]);
            }
            WriteFmt("'\n");
            WriteFmt("[DEBUG] Got: '");
            for (size i = 0; i < StrLen(&output_clean); i++) {

In Write.Simple.c:87:

            }
            WriteFmt("'\n");
            WriteFmt("[DEBUG] Got: '");
            for (size i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("{c}", StrBegin(&output_clean)[i]);

In Write.Simple.c:89:

            WriteFmt("[DEBUG] Got: '");
            for (size i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("{c}", StrBegin(&output_clean)[i]);
            }
            WriteFmt("'\n");

In Write.Simple.c:91:

                WriteFmt("{c}", StrBegin(&output_clean)[i]);
            }
            WriteFmt("'\n");
        }

In Write.Simple.c:102:

    // Test 1: Simple string writing
    bool test_simple_string_writing(void) {
        WriteFmt("Testing simple string writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:131:

    // Test 2: Simple number writing
    bool test_simple_numbers_writing(void) {
        WriteFmt("Testing simple number writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:160:

    // Test 3: Simple boolean writing
    bool test_simple_boolean_writing(void) {
        WriteFmt("Testing simple boolean writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:187:

    // Test 4: Simple person object writing
    bool test_simple_person_object_writing(void) {
        WriteFmt("Testing simple person object writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:217:

    // Test 5: Simple config object writing
    bool test_simple_config_object_writing(void) {
        WriteFmt("Testing simple config object writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:245:

    // Test 6: Simple array of strings writing
    bool test_simple_array_of_strings_writing(void) {
        WriteFmt("Testing simple array of strings writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:278:

    // Test 7: Simple nested object writing
    bool test_simple_nested_object_writing(void) {
        WriteFmt("Testing simple nested object writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.Simple.c:318:

    // Test 8: Simple product with tags array writing
    bool test_simple_product_with_tags_writing(void) {
        WriteFmt("Testing simple product with tags array writing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Write.EdgeCases.c:36:

        if (!result) {
            WriteFmtLn("[DEBUG] JSON comparison failed");
            WriteFmt("[DEBUG] Expected: '");
            for (u64 i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);

In Write.EdgeCases.c:38:

            WriteFmt("[DEBUG] Expected: '");
            for (u64 i = 0; i < StrLen(&expected_clean); i++) {
                WriteFmt("{c}", StrBegin(&expected_clean)[i]);
            }
            WriteFmtLn("'");

In Write.EdgeCases.c:42:

            WriteFmtLn("'");
    
            WriteFmt("[DEBUG] Got: '");
            for (u64 i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("{c}", StrBegin(&output_clean)[i]);

In Write.EdgeCases.c:44:

            WriteFmt("[DEBUG] Got: '");
            for (u64 i = 0; i < StrLen(&output_clean); i++) {
                WriteFmt("{c}", StrBegin(&output_clean)[i]);
            }
            WriteFmtLn("'");

In Read.Nested.c:109:

    // Test basic iterator functionality
    bool test_basic_iterator_functionality(void) {
        WriteFmt("Testing basic iterator functionality\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:119:

    
        if (!StrIterRemainingLength(&si)) {
            WriteFmt("[DEBUG] Remaining length check failed: expected > 0, got {}\n", StrIterRemainingLength(&si));
            success = false;
        }

In Read.Nested.c:125:

        char c = '\0';
        if (!StrIterPeek(&si, &c) || c != '{') {
            WriteFmt("[DEBUG] Peek check failed: expected '{', got '{c}'\n", c);
            success = false;
        }

In Read.Nested.c:136:

    // Test simple JSON object (1 level)
    bool test_simple_json_object(void) {
        WriteFmt("Testing simple JSON object (1 level)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:159:

    
        if (data.id != 12345) {
            WriteFmt("[DEBUG] ID check failed: expected 12345, got {}\n", data.id);
            success = false;
        }

In Read.Nested.c:164:

    
        if (StrCmp(&data.name, "test", 4) != 0) {
            WriteFmt("[DEBUG] Name check failed: expected 'test', got '");
            for (size i = 0; i < StrLen(&data.name); i++) {
                WriteFmt("{c}", StrBegin(&data.name)[i]);

In Read.Nested.c:166:

            WriteFmt("[DEBUG] Name check failed: expected 'test', got '");
            for (size i = 0; i < StrLen(&data.name); i++) {
                WriteFmt("{c}", StrBegin(&data.name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:168:

                WriteFmt("{c}", StrBegin(&data.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:173:

    
        if (data.active != true) {
            WriteFmt("[DEBUG] Active check failed: expected true, got {}\n", data.active ? "true" : "false");
            success = false;
        }

In Read.Nested.c:178:

    
        if (!(data.score > 98.4 && data.score < 98.6)) {
            WriteFmt("[DEBUG] Score check failed: expected 98.4-98.6, got {}\n", data.score);
            success = false;
        }

In Read.Nested.c:190:

    // Test two-level nesting
    bool test_two_level_nesting(void) {
        WriteFmt("Testing two-level nesting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:227:

    
        if (data.user.id != 123) {
            WriteFmt("[DEBUG] User ID check failed: expected 123, got {}\n", data.user.id);
            success = false;
        }

In Read.Nested.c:232:

    
        if (StrCmp(&data.user.profile.name, "Alice", 5) != 0) {
            WriteFmt("[DEBUG] Profile name check failed: expected 'Alice', got '");
            for (u64 i = 0; i < StrLen(&data.user.profile.name); i++) {
                WriteFmt("{}", StrBegin(&data.user.profile.name)[i]);

In Read.Nested.c:234:

            WriteFmt("[DEBUG] Profile name check failed: expected 'Alice', got '");
            for (u64 i = 0; i < StrLen(&data.user.profile.name); i++) {
                WriteFmt("{}", StrBegin(&data.user.profile.name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:236:

                WriteFmt("{}", StrBegin(&data.user.profile.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:241:

    
        if (data.user.profile.age != 30) {
            WriteFmt("[DEBUG] Profile age check failed: expected 30, got {}\n", data.user.profile.age);
            success = false;
        }

In Read.Nested.c:246:

    
        if (StrCmp(&data.status, "active", 6) != 0) {
            WriteFmt("[DEBUG] Status check failed: expected 'active', got '");
            for (size i = 0; i < StrLen(&data.status); i++) {
                WriteFmt("{}", StrBegin(&data.status)[i]);

In Read.Nested.c:248:

            WriteFmt("[DEBUG] Status check failed: expected 'active', got '");
            for (size i = 0; i < StrLen(&data.status); i++) {
                WriteFmt("{}", StrBegin(&data.status)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:250:

                WriteFmt("{}", StrBegin(&data.status)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:263:

    // Test three-level nesting
    bool test_three_level_nesting(void) {
        WriteFmt("Testing three-level nesting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:304:

    
        if (StrCmp(&data.company.departments.engineering.head, "John", 4) != 0) {
            WriteFmt("[DEBUG] Engineering head check failed: expected 'John', got '");
            for (size i = 0; i < StrLen(&data.company.departments.engineering.head); i++) {
                WriteFmt("{c}", StrBegin(&data.company.departments.engineering.head)[i]);

In Read.Nested.c:306:

            WriteFmt("[DEBUG] Engineering head check failed: expected 'John', got '");
            for (size i = 0; i < StrLen(&data.company.departments.engineering.head); i++) {
                WriteFmt("{c}", StrBegin(&data.company.departments.engineering.head)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:308:

                WriteFmt("{c}", StrBegin(&data.company.departments.engineering.head)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:313:

    
        if (data.company.departments.engineering.count != 25) {
            WriteFmt(
                "[DEBUG] Engineering count check failed: expected 25, got {}\n",
                data.company.departments.engineering.count

In Read.Nested.c:321:

    
        if (data.company.departments.engineering.budget < 149999.0) {
            WriteFmt(
                "[DEBUG] Engineering budget check failed: expected > 149999.0, got {}\n",
                data.company.departments.engineering.budget

In Read.Nested.c:329:

    
        if (StrCmp(&data.company.name, "TechCorp", 8) != 0) {
            WriteFmt("[DEBUG] Company name check failed: expected 'TechCorp', got '");
            for (size i = 0; i < StrLen(&data.company.name); i++) {
                WriteFmt("{c}", StrBegin(&data.company.name)[i]);

In Read.Nested.c:331:

            WriteFmt("[DEBUG] Company name check failed: expected 'TechCorp', got '");
            for (size i = 0; i < StrLen(&data.company.name); i++) {
                WriteFmt("{c}", StrBegin(&data.company.name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:333:

                WriteFmt("{c}", StrBegin(&data.company.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:346:

    // Test dynamic key parsing (like your example) - Fixed initialization
    bool test_dynamic_key_parsing(void) {
        WriteFmt("Testing dynamic key parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:389:

    
        if (VecLen(&symbols) != 2) {
            WriteFmt("[DEBUG] Symbols length check failed: expected 2, got {}\n", VecLen(&symbols));
            success = false;
        }

In Read.Nested.c:398:

    
            if (!(sym1->source_function_id == 12345 || sym1->source_function_id == 54321)) {
                WriteFmt(
                    "[DEBUG] Sym1 source function ID check failed: expected 12345 or 54321, got {}\n",
                    sym1->source_function_id

In Read.Nested.c:406:

    
            if (!(sym1->target_function_id == 67890 || sym1->target_function_id == 98765)) {
                WriteFmt(
                    "[DEBUG] Sym1 target function ID check failed: expected 67890 or 98765, got {}\n",
                    sym1->target_function_id

In Read.Nested.c:414:

    
            if (!(sym1->distance > 0.8 && sym1->distance < 1.0)) {
                WriteFmt("[DEBUG] Sym1 distance check failed: expected 0.8-1.0, got {}\n", sym1->distance);
                success = false;
            }

In Read.Nested.c:419:

    
            if (!(sym2->source_function_id == 12345 || sym2->source_function_id == 54321)) {
                WriteFmt(
                    "[DEBUG] Sym2 source function ID check failed: expected 12345 or 54321, got {}\n",
                    sym2->source_function_id

In Read.Nested.c:427:

    
            if (!(sym2->target_function_id == 67890 || sym2->target_function_id == 98765)) {
                WriteFmt(
                    "[DEBUG] Sym2 target function ID check failed: expected 67890 or 98765, got {}\n",
                    sym2->target_function_id

In Read.Nested.c:435:

    
            if (!(sym2->distance > 0.8 && sym2->distance < 1.0)) {
                WriteFmt("[DEBUG] Sym2 distance check failed: expected 0.8-1.0, got {}\n", sym2->distance);
                success = false;
            }

In Read.Nested.c:448:

    // Test complex API response similar to your example - Fixed initialization
    bool test_complex_api_response(void) {
        WriteFmt("Testing complex API response structure\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:501:

        // Debug status check
        if (response.status != true) {
            WriteFmt("[DEBUG] Status check failed: expected true, got {}\n", response.status ? "true" : "false");
            success = false;
        }

In Read.Nested.c:507:

        // Debug message check
        if (StrCmp(&response.message, "Success", 7) != 0) {
            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);

In Read.Nested.c:509:

            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:511:

                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:517:

        // Debug data length check
        if (VecLen(&response.data) != 1) {
            WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
            success = false;
        }

In Read.Nested.c:526:

            // Debug individual symbol checks
            if (sym->source_function_id != 12345) {
                WriteFmt("[DEBUG] Source function ID check failed: expected 12345, got {}\n", sym->source_function_id);
                success = false;
            }

In Read.Nested.c:531:

    
            if (sym->target_function_id != 67890) {
                WriteFmt("[DEBUG] Target function ID check failed: expected 67890, got {}\n", sym->target_function_id);
                success = false;
            }

In Read.Nested.c:536:

    
            if (!(sym->distance > 0.84 && sym->distance < 0.86)) {
                WriteFmt("[DEBUG] Distance check failed: expected 0.84-0.86, got {}\n", sym->distance);
                success = false;
            }

In Read.Nested.c:541:

    
            if (sym->analysis_id != 999) {
                WriteFmt("[DEBUG] Analysis ID check failed: expected 999, got {}\n", sym->analysis_id);
                success = false;
            }

In Read.Nested.c:546:

    
            if (sym->binary_id != 888) {
                WriteFmt("[DEBUG] Binary ID check failed: expected 888, got {}\n", sym->binary_id);
                success = false;
            }

In Read.Nested.c:551:

    
            if (StrCmp(&sym->analysis_name, "test_analysis", 13) != 0) {
                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);

In Read.Nested.c:553:

                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:555:

                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:560:

    
            if (StrCmp(&sym->function_name, "main_func", 9) != 0) {
                WriteFmt(
                    "[DEBUG] Function name check failed: expected 'main_func', got string of length {}\n",
                    StrLen(&sym->function_name)

In Read.Nested.c:568:

    
            if (StrCmp(&sym->sha256, "abc123", 6) != 0) {
                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);

In Read.Nested.c:570:

                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:572:

                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:577:

    
            if (sym->debug != true) {
                WriteFmt("[DEBUG] Debug flag check failed: expected true, got {}\n", sym->debug ? "true" : "false");
                success = false;
            }

In Read.Nested.c:582:

    
            if (StrCmp(&sym->function_mangled_name, "_Z4main", 7) != 0) {
                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);

In Read.Nested.c:584:

                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:586:

                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:600:

    // Test function info parsing
    bool test_function_info_parsing(void) {
        WriteFmt("Testing function info parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:619:

    
        if (info.id != 12345) {
            WriteFmt("[DEBUG] Function ID check failed: expected 12345, got {}\n", info.id);
            success = false;
        }

In Read.Nested.c:624:

    
        if (StrCmp(&info.name, "test_func", 9) != 0) {
            WriteFmt("[DEBUG] Function name check failed: expected 'test_func', got '");
            for (size i = 0; i < StrLen(&info.name); i++) {
                WriteFmt("{}", StrBegin(&info.name)[i]);

In Read.Nested.c:626:

            WriteFmt("[DEBUG] Function name check failed: expected 'test_func', got '");
            for (size i = 0; i < StrLen(&info.name); i++) {
                WriteFmt("{}", StrBegin(&info.name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:628:

                WriteFmt("{}", StrBegin(&info.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:633:

    
        if (info.size != 1024) {
            WriteFmt("[DEBUG] Function size check failed: expected 1024, got {}\n", info.size);
            success = false;
        }

In Read.Nested.c:638:

    
        if (info.vaddr != 4096) {
            WriteFmt("[DEBUG] Function vaddr check failed: expected 4096, got {}\n", info.vaddr);
            success = false;
        }

In Read.Nested.c:650:

    // Test model info parsing
    bool test_model_info_parsing(void) {
        WriteFmt("Testing model info parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:667:

    
        if (info.id != 54321) {
            WriteFmt("[DEBUG] Model ID check failed: expected 54321, got {}\n", info.id);
            success = false;
        }

In Read.Nested.c:672:

    
        if (StrCmp(&info.name, "test_model", 10) != 0) {
            WriteFmt("[DEBUG] Model name check failed: expected 'test_model', got '");
            for (size i = 0; i < StrLen(&info.name); i++) {
                WriteFmt("{}", StrBegin(&info.name)[i]);

In Read.Nested.c:674:

            WriteFmt("[DEBUG] Model name check failed: expected 'test_model', got '");
            for (size i = 0; i < StrLen(&info.name); i++) {
                WriteFmt("{}", StrBegin(&info.name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:676:

                WriteFmt("{}", StrBegin(&info.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:688:

    // Test search results with tags - Fixed implementation
    bool test_search_results_with_tags(void) {
        WriteFmt("Testing search results with tags\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:720:

    
        if (result.binary_id != 888) {
            WriteFmt("[DEBUG] Binary ID check failed: expected 888, got {}\n", result.binary_id);
            success = false;
        }

In Read.Nested.c:725:

    
        if (StrCmp(&result.binary_name, "test_binary", 11) != 0) {
            WriteFmt("[DEBUG] Binary name check failed: expected 'test_binary', got '");
            for (size i = 0; i < StrLen(&result.binary_name); i++) {
                WriteFmt("{c}", StrBegin(&result.binary_name)[i]);

In Read.Nested.c:727:

            WriteFmt("[DEBUG] Binary name check failed: expected 'test_binary', got '");
            for (size i = 0; i < StrLen(&result.binary_name); i++) {
                WriteFmt("{c}", StrBegin(&result.binary_name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:729:

                WriteFmt("{c}", StrBegin(&result.binary_name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:734:

    
        if (result.analysis_id != 999) {
            WriteFmt("[DEBUG] Analysis ID check failed: expected 999, got {}\n", result.analysis_id);
            success = false;
        }

In Read.Nested.c:739:

    
        if (StrCmp(&result.sha256, "abc123", 6) != 0) {
            WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
            for (size i = 0; i < StrLen(&result.sha256); i++) {
                WriteFmt("{c}", StrBegin(&result.sha256)[i]);

In Read.Nested.c:741:

            WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
            for (size i = 0; i < StrLen(&result.sha256); i++) {
                WriteFmt("{c}", StrBegin(&result.sha256)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:743:

                WriteFmt("{c}", StrBegin(&result.sha256)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:748:

    
        if (result.model_id != 12345) {
            WriteFmt("[DEBUG] Model ID check failed: expected 12345, got {}\n", result.model_id);
            success = false;
        }

In Read.Nested.c:753:

    
        if (StrCmp(&result.model_name, "test_model", 10) != 0) {
            WriteFmt("[DEBUG] Model name check failed: expected 'test_model', got '");
            for (size i = 0; i < StrLen(&result.model_name); i++) {
                WriteFmt("{c}", StrBegin(&result.model_name)[i]);

In Read.Nested.c:755:

            WriteFmt("[DEBUG] Model name check failed: expected 'test_model', got '");
            for (size i = 0; i < StrLen(&result.model_name); i++) {
                WriteFmt("{c}", StrBegin(&result.model_name)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:757:

                WriteFmt("{c}", StrBegin(&result.model_name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:762:

    
        if (StrCmp(&result.owned_by, "user1", 5) != 0) {
            WriteFmt("[DEBUG] Owned by check failed: expected 'user1', got '");
            for (size i = 0; i < StrLen(&result.owned_by); i++) {
                WriteFmt("{c}", StrBegin(&result.owned_by)[i]);

In Read.Nested.c:764:

            WriteFmt("[DEBUG] Owned by check failed: expected 'user1', got '");
            for (size i = 0; i < StrLen(&result.owned_by); i++) {
                WriteFmt("{c}", StrBegin(&result.owned_by)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:766:

                WriteFmt("{c}", StrBegin(&result.owned_by)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:778:

    // Test conditional parsing
    bool test_conditional_parsing(void) {
        WriteFmt("Testing conditional parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:795:

        ApiResponse response = {false, StrInit(&alloc), VecInitWithDeepCopy(NULL, AnnSymbolDeinit, &alloc)};
    
        WriteFmt("[DEBUG] About to parse JSON...\n");
    
        JR_OBJ(si, {

In Read.Nested.c:801:

            JR_STR_KV(si, "message", response.message);
    
            WriteFmt("[DEBUG] Parsed status: {}, message: '", response.status ? "true" : "false");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);

In Read.Nested.c:803:

            WriteFmt("[DEBUG] Parsed status: {}, message: '", response.status ? "true" : "false");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:805:

                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");
    
            if (response.status) {

In Read.Nested.c:808:

    
            if (response.status) {
                WriteFmt("[DEBUG] Status is true, parsing data...\n");
                JR_OBJ_KV(si, "data", {
                    u64 source_function_id = (u64)ZstrToI64(StrBegin(&key), NULL);

In Read.Nested.c:811:

                JR_OBJ_KV(si, "data", {
                    u64 source_function_id = (u64)ZstrToI64(StrBegin(&key), NULL);
                    WriteFmt("[DEBUG] Source function ID from key: {}\n", source_function_id);
                    JR_OBJ(si, {
                        // Properly initialize all Str fields

In Read.Nested.c:822:

                        sym.target_function_id    = (u64)ZstrToI64(StrBegin(&key), NULL);
    
                        WriteFmt("[DEBUG] Target function ID from key: {}\n", sym.target_function_id);
    
                        JR_OBJ(si, {

In Read.Nested.c:835:

                        });
    
                        WriteFmt(
                            "[DEBUG] Parsed symbol - distance: {}, analysis_id: {}, binary_id: {}\n",
                            sym.distance,

In Read.Nested.c:843:

    
                        VecPushBack(&response.data, sym);
                        WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", VecLen(&response.data));
                    });
                });

In Read.Nested.c:847:

                });
            } else {
                WriteFmt("[DEBUG] Status is false, skipping data parsing\n");
            }
        });

In Read.Nested.c:851:

        });
    
        WriteFmt("[DEBUG] Finished parsing, response.data length = {}\n", VecLen(&response.data));
    
        // Debug checks

In Read.Nested.c:855:

        // Debug checks
        if (response.status != true) {
            WriteFmt("[DEBUG] Status check failed: expected true, got {}\n", response.status ? "true" : "false");
            success = false;
        }

In Read.Nested.c:860:

    
        if (StrCmp(&response.message, "Success", 7) != 0) {
            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);

In Read.Nested.c:862:

            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:864:

                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:869:

    
        if (VecLen(&response.data) != 1) {
            WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
            success = false;
        }

In Read.Nested.c:877:

    
            if (sym->source_function_id != 12345) {
                WriteFmt("[DEBUG] Source function ID check failed: expected 12345, got {}\n", sym->source_function_id);
                success = false;
            }

In Read.Nested.c:882:

    
            if (sym->target_function_id != 67890) {
                WriteFmt("[DEBUG] Target function ID check failed: expected 67890, got {}\n", sym->target_function_id);
                success = false;
            }

In Read.Nested.c:887:

    
            if (!(sym->distance > 0.84 && sym->distance < 0.86)) {
                WriteFmt("[DEBUG] Distance check failed: expected 0.84-0.86, got {}\n", sym->distance);
                success = false;
            }

In Read.Nested.c:892:

    
            if (sym->analysis_id != 999) {
                WriteFmt("[DEBUG] Analysis ID check failed: expected 999, got {}\n", sym->analysis_id);
                success = false;
            }

In Read.Nested.c:897:

    
            if (sym->binary_id != 888) {
                WriteFmt("[DEBUG] Binary ID check failed: expected 888, got {}\n", sym->binary_id);
                success = false;
            }

In Read.Nested.c:902:

    
            if (StrCmp(&sym->analysis_name, "test_analysis", 13) != 0) {
                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);

In Read.Nested.c:904:

                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:906:

                    WriteFmt("{c}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:911:

    
            if (StrCmp(&sym->function_name, "main_func", 9) != 0) {
                WriteFmt(
                    "[DEBUG] Function name check failed: expected 'main_func', got string of length {}\n",
                    StrLen(&sym->function_name)

In Read.Nested.c:919:

    
            if (StrCmp(&sym->sha256, "abc123", 6) != 0) {
                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);

In Read.Nested.c:921:

                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:923:

                    WriteFmt("{c}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:928:

    
            if (sym->debug != true) {
                WriteFmt("[DEBUG] Debug flag check failed: expected true, got {}\n", sym->debug ? "true" : "false");
                success = false;
            }

In Read.Nested.c:933:

    
            if (StrCmp(&sym->function_mangled_name, "_Z4main", 7) != 0) {
                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);

In Read.Nested.c:935:

                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:937:

                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:951:

    // Test status response pattern
    bool test_status_response_pattern(void) {
        WriteFmt("Testing status response pattern\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Nested.c:968:

        ApiResponse response = {false, StrInit(&alloc), VecInitWithDeepCopy(NULL, AnnSymbolDeinit, &alloc)};
    
        WriteFmt("[DEBUG] About to parse JSON...\n");
    
        JR_OBJ(si, {

In Read.Nested.c:974:

            JR_STR_KV(si, "message", response.message);
    
            WriteFmt("[DEBUG] Parsed status: {}, message: '", response.status ? "true" : "false");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);

In Read.Nested.c:976:

            WriteFmt("[DEBUG] Parsed status: {}, message: '", response.status ? "true" : "false");
            for (size i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:978:

                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");
    
            if (response.status) {

In Read.Nested.c:981:

    
            if (response.status) {
                WriteFmt("[DEBUG] Status is true, parsing data...\n");
                JR_OBJ_KV(si, "data", {
                    u64 source_function_id = (u64)ZstrToI64(StrBegin(&key), NULL);

In Read.Nested.c:984:

                JR_OBJ_KV(si, "data", {
                    u64 source_function_id = (u64)ZstrToI64(StrBegin(&key), NULL);
                    WriteFmt("[DEBUG] Source function ID from key: {}\n", source_function_id);
                    JR_OBJ(si, {
                        // Properly initialize all Str fields

In Read.Nested.c:995:

                        sym.target_function_id    = (u64)ZstrToI64(StrBegin(&key), NULL);
    
                        WriteFmt("[DEBUG] Target function ID from key: {}\n", sym.target_function_id);
    
                        JR_OBJ(si, {

In Read.Nested.c:1008:

                        });
    
                        WriteFmt(
                            "[DEBUG] Parsed symbol - distance: {}, analysis_id: {}, binary_id: {}\n",
                            sym.distance,

In Read.Nested.c:1016:

    
                        VecPushBack(&response.data, sym);
                        WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", VecLen(&response.data));
                    });
                });

In Read.Nested.c:1020:

                });
            } else {
                WriteFmt("[DEBUG] Status is false, skipping data parsing\n");
            }
        });

In Read.Nested.c:1024:

        });
    
        WriteFmt("[DEBUG] Finished parsing, response.data length = {}\n", VecLen(&response.data));
    
        // Debug checks

In Read.Nested.c:1028:

        // Debug checks
        if (response.status != true) {
            WriteFmt("[DEBUG] Status check failed: expected true, got {}\n", response.status ? "true" : "false");
            success = false;
        }

In Read.Nested.c:1033:

    
        if (StrCmp(&response.message, "Success", 7) != 0) {
            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (u64 i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);

In Read.Nested.c:1035:

            WriteFmt("[DEBUG] Message check failed: expected 'Success', got '");
            for (u64 i = 0; i < StrLen(&response.message); i++) {
                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");

In Read.Nested.c:1037:

                WriteFmt("{c}", StrBegin(&response.message)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Nested.c:1042:

    
        if (VecLen(&response.data) != 1) {
            WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
            success = false;
        }

In Read.Nested.c:1050:

    
            if (sym->source_function_id != 12345) {
                WriteFmt("[DEBUG] Source function ID check failed: expected 12345, got {}\n", sym->source_function_id);
                success = false;
            }

In Read.Nested.c:1055:

    
            if (sym->target_function_id != 67890) {
                WriteFmt("[DEBUG] Target function ID check failed: expected 67890, got {}\n", sym->target_function_id);
                success = false;
            }

In Read.Nested.c:1060:

    
            if (!(sym->distance > 0.84 && sym->distance < 0.86)) {
                WriteFmt("[DEBUG] Distance check failed: expected 0.84-0.86, got {}\n", sym->distance);
                success = false;
            }

In Read.Nested.c:1065:

    
            if (sym->analysis_id != 999) {
                WriteFmt("[DEBUG] Analysis ID check failed: expected 999, got {}\n", sym->analysis_id);
                success = false;
            }

In Read.Nested.c:1070:

    
            if (sym->binary_id != 888) {
                WriteFmt("[DEBUG] Binary ID check failed: expected 888, got {}\n", sym->binary_id);
                success = false;
            }

In Read.Nested.c:1075:

    
            if (StrCmp(&sym->analysis_name, "test_analysis", 13) != 0) {
                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{}", StrBegin(&sym->analysis_name)[i]);

In Read.Nested.c:1077:

                WriteFmt("[DEBUG] Analysis name check failed: expected 'test_analysis', got '");
                for (size i = 0; i < StrLen(&sym->analysis_name); i++) {
                    WriteFmt("{}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:1079:

                    WriteFmt("{}", StrBegin(&sym->analysis_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:1084:

    
            if (StrCmp(&sym->function_name, "main_func", 9) != 0) {
                WriteFmt("[DEBUG] Function name check failed: expected 'main_func', got '");
                for (size i = 0; i < StrLen(&sym->function_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_name)[i]);

In Read.Nested.c:1086:

                WriteFmt("[DEBUG] Function name check failed: expected 'main_func', got '");
                for (size i = 0; i < StrLen(&sym->function_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:1088:

                    WriteFmt("{c}", StrBegin(&sym->function_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:1093:

    
            if (StrCmp(&sym->sha256, "abc123", 6) != 0) {
                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{}", StrBegin(&sym->sha256)[i]);

In Read.Nested.c:1095:

                WriteFmt("[DEBUG] SHA256 check failed: expected 'abc123', got '");
                for (size i = 0; i < StrLen(&sym->sha256); i++) {
                    WriteFmt("{}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:1097:

                    WriteFmt("{}", StrBegin(&sym->sha256)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Nested.c:1102:

    
            if (sym->debug != true) {
                WriteFmt("[DEBUG] Debug flag check failed: expected true, got {}\n", sym->debug ? "true" : "false");
                success = false;
            }

In Read.Nested.c:1107:

    
            if (StrCmp(&sym->function_mangled_name, "_Z4main", 7) != 0) {
                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);

In Read.Nested.c:1109:

                WriteFmt("[DEBUG] Mangled name check failed: expected '_Z4main', got '");
                for (size i = 0; i < StrLen(&sym->function_mangled_name); i++) {
                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");

In Read.Nested.c:1111:

                    WriteFmt("{c}", StrBegin(&sym->function_mangled_name)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:62:

    // Test 1: Simple string parsing
    bool test_simple_string_parsing(void) {
        WriteFmt("Testing simple string parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:79:

    
        if (StrCmp(&name, "Alice", 5) != 0) {
            WriteFmt("[DEBUG] Name check failed: expected 'Alice', got '");
            for (size i = 0; i < StrLen(&name); i++) {
                WriteFmt("{c}", StrBegin(&name)[i]);

In Read.Simple.c:81:

            WriteFmt("[DEBUG] Name check failed: expected 'Alice', got '");
            for (size i = 0; i < StrLen(&name); i++) {
                WriteFmt("{c}", StrBegin(&name)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:83:

                WriteFmt("{c}", StrBegin(&name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:88:

    
        if (StrCmp(&city, "New York", 8) != 0) {
            WriteFmt("[DEBUG] City check failed: expected 'New York', got '");
            for (size i = 0; i < StrLen(&city); i++) {
                WriteFmt("{c}", StrBegin(&city)[i]);

In Read.Simple.c:90:

            WriteFmt("[DEBUG] City check failed: expected 'New York', got '");
            for (size i = 0; i < StrLen(&city); i++) {
                WriteFmt("{c}", StrBegin(&city)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:92:

                WriteFmt("{c}", StrBegin(&city)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:105:

    // Test 2: Simple number parsing
    bool test_simple_numbers(void) {
        WriteFmt("Testing simple number parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:124:

    
        if (count != 42) {
            WriteFmt("[DEBUG] Count check failed: expected 42, got {}\n", count);
            success = false;
        }

In Read.Simple.c:129:

    
        if (!(score > 95.4 && score < 95.6)) {
            WriteFmt("[DEBUG] Score check failed: expected ~95.5, got {}\n", score);
            success = false;
        }

In Read.Simple.c:134:

    
        if (year != 2024) {
            WriteFmt("[DEBUG] Year check failed: expected 2024, got {}\n", year);
            success = false;
        }

In Read.Simple.c:145:

    // Test 3: Simple boolean parsing
    bool test_simple_boolean(void) {
        WriteFmt("Testing simple boolean parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:162:

    
        if (enabled != true) {
            WriteFmt("[DEBUG] Enabled check failed: expected true, got {}\n", enabled ? "true" : "false");
            success = false;
        }

In Read.Simple.c:167:

    
        if (visible != false) {
            WriteFmt("[DEBUG] Visible check failed: expected false, got {}\n", visible ? "true" : "false");
            success = false;
        }

In Read.Simple.c:178:

    // Test 4: Simple person object
    bool test_simple_person_object(void) {
        WriteFmt("Testing simple person object\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:201:

    
        if (person.id != 1001) {
            WriteFmt("[DEBUG] Person ID check failed: expected 1001, got {}\n", person.id);
            success = false;
        }

In Read.Simple.c:206:

    
        if (StrCmp(&person.name, "Bob", 3) != 0) {
            WriteFmt("[DEBUG] Person name check failed: expected 'Bob', got '");
            for (size i = 0; i < StrLen(&person.name); i++) {
                WriteFmt("{c}", StrBegin(&person.name)[i]);

In Read.Simple.c:208:

            WriteFmt("[DEBUG] Person name check failed: expected 'Bob', got '");
            for (size i = 0; i < StrLen(&person.name); i++) {
                WriteFmt("{c}", StrBegin(&person.name)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:210:

                WriteFmt("{c}", StrBegin(&person.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:215:

    
        if (person.age != 25) {
            WriteFmt("[DEBUG] Person age check failed: expected 25, got {}\n", person.age);
            success = false;
        }

In Read.Simple.c:220:

    
        if (person.is_active != true) {
            WriteFmt("[DEBUG] Person is_active check failed: expected true, got {}\n", person.is_active ? "true" : "false");
            success = false;
        }

In Read.Simple.c:225:

    
        if (!(person.salary > 49999.0 && person.salary < 50001.0)) {
            WriteFmt("[DEBUG] Person salary check failed: expected ~50000.0, got {}\n", person.salary);
            success = false;
        }

In Read.Simple.c:237:

    // Test 5: Simple config object
    bool test_simple_config_object(void) {
        WriteFmt("Testing simple config object\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:255:

    
        if (config.debug_mode != false) {
            WriteFmt("[DEBUG] Debug mode check failed: expected false, got {}\n", config.debug_mode ? "true" : "false");
            success = false;
        }

In Read.Simple.c:260:

    
        if (config.timeout != 30) {
            WriteFmt("[DEBUG] Timeout check failed: expected 30, got {}\n", config.timeout);
            success = false;
        }

In Read.Simple.c:265:

    
        if (StrCmp(&config.log_level, "INFO", 4) != 0) {
            WriteFmt("[DEBUG] Log level check failed: expected 'INFO', got '");
            for (size i = 0; i < StrLen(&config.log_level); i++) {
                WriteFmt("{c}", StrBegin(&config.log_level)[i]);

In Read.Simple.c:267:

            WriteFmt("[DEBUG] Log level check failed: expected 'INFO', got '");
            for (size i = 0; i < StrLen(&config.log_level); i++) {
                WriteFmt("{c}", StrBegin(&config.log_level)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:269:

                WriteFmt("{c}", StrBegin(&config.log_level)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:281:

    // Test 6: Simple array of strings
    bool test_simple_array_of_strings(void) {
        WriteFmt("Testing simple array of strings\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:300:

    
        if (VecLen(&languages) != 3) {
            WriteFmt("[DEBUG] Languages length check failed: expected 3, got {}\n", VecLen(&languages));
            success = false;
        }

In Read.Simple.c:310:

    
            if (StrCmp(lang1, "C", 1) != 0) {
                WriteFmt("[DEBUG] Language 1 check failed: expected 'C', got '");
                for (size i = 0; i < StrLen(lang1); i++) {
                    WriteFmt("{c}", StrBegin(lang1)[i]);

In Read.Simple.c:312:

                WriteFmt("[DEBUG] Language 1 check failed: expected 'C', got '");
                for (size i = 0; i < StrLen(lang1); i++) {
                    WriteFmt("{c}", StrBegin(lang1)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:314:

                    WriteFmt("{c}", StrBegin(lang1)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:319:

    
            if (StrCmp(lang2, "Python", 6) != 0) {
                WriteFmt("[DEBUG] Language 2 check failed: expected 'Python', got '");
                for (size i = 0; i < StrLen(lang2); i++) {
                    WriteFmt("{c}", StrBegin(lang2)[i]);

In Read.Simple.c:321:

                WriteFmt("[DEBUG] Language 2 check failed: expected 'Python', got '");
                for (size i = 0; i < StrLen(lang2); i++) {
                    WriteFmt("{c}", StrBegin(lang2)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:323:

                    WriteFmt("{c}", StrBegin(lang2)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:328:

    
            if (StrCmp(lang3, "Rust", 4) != 0) {
                WriteFmt("[DEBUG] Language 3 check failed: expected 'Rust', got '");
                for (size i = 0; i < StrLen(lang3); i++) {
                    WriteFmt("{c}", StrBegin(lang3)[i]);

In Read.Simple.c:330:

                WriteFmt("[DEBUG] Language 3 check failed: expected 'Rust', got '");
                for (size i = 0; i < StrLen(lang3); i++) {
                    WriteFmt("{c}", StrBegin(lang3)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:332:

                    WriteFmt("{c}", StrBegin(lang3)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:345:

    // Test 7: Simple nested object (1 level)
    bool test_simple_nested_object(void) {
        WriteFmt("Testing simple nested object\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:376:

    
        if (StrCmp(&data.user.name, "Charlie", 7) != 0) {
            WriteFmt("[DEBUG] User name check failed: expected 'Charlie', got '");
            for (size i = 0; i < StrLen(&data.user.name); i++) {
                WriteFmt("{c}", StrBegin(&data.user.name)[i]);

In Read.Simple.c:378:

            WriteFmt("[DEBUG] User name check failed: expected 'Charlie', got '");
            for (size i = 0; i < StrLen(&data.user.name); i++) {
                WriteFmt("{c}", StrBegin(&data.user.name)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:380:

                WriteFmt("{c}", StrBegin(&data.user.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:385:

    
        if (StrCmp(&data.user.email, "charlie@example.com", 19) != 0) {
            WriteFmt("[DEBUG] User email check failed: expected 'charlie@example.com', got '");
            for (size i = 0; i < StrLen(&data.user.email); i++) {
                WriteFmt("{c}", StrBegin(&data.user.email)[i]);

In Read.Simple.c:387:

            WriteFmt("[DEBUG] User email check failed: expected 'charlie@example.com', got '");
            for (size i = 0; i < StrLen(&data.user.email); i++) {
                WriteFmt("{c}", StrBegin(&data.user.email)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:389:

                WriteFmt("{c}", StrBegin(&data.user.email)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:394:

    
        if (data.active != true) {
            WriteFmt("[DEBUG] Active check failed: expected true, got {}\n", data.active ? "true" : "false");
            success = false;
        }

In Read.Simple.c:407:

    // Test 8: Simple product with tags array
    bool test_simple_product_with_tags(void) {
        WriteFmt("Testing simple product with tags array\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Read.Simple.c:435:

    
        if (product.id != 12345) {
            WriteFmt("[DEBUG] Product ID check failed: expected 12345, got {}\n", product.id);
            success = false;
        }

In Read.Simple.c:440:

    
        if (StrCmp(&product.name, "Laptop", 6) != 0) {
            WriteFmt("[DEBUG] Product name check failed: expected 'Laptop', got '");
            for (size i = 0; i < StrLen(&product.name); i++) {
                WriteFmt("{c}", StrBegin(&product.name)[i]);

In Read.Simple.c:442:

            WriteFmt("[DEBUG] Product name check failed: expected 'Laptop', got '");
            for (size i = 0; i < StrLen(&product.name); i++) {
                WriteFmt("{c}", StrBegin(&product.name)[i]);
            }
            WriteFmt("'\n");

In Read.Simple.c:444:

                WriteFmt("{c}", StrBegin(&product.name)[i]);
            }
            WriteFmt("'\n");
            success = false;
        }

In Read.Simple.c:449:

    
        if (!(product.price > 999.98 && product.price < 1000.0)) {
            WriteFmt("[DEBUG] Product price check failed: expected ~999.99, got {}\n", product.price);
            success = false;
        }

In Read.Simple.c:454:

    
        if (VecLen(&product.tags) != 3) {
            WriteFmt("[DEBUG] Product tags length check failed: expected 3, got {}\n", VecLen(&product.tags));
            success = false;
        }

In Read.Simple.c:464:

    
            if (StrCmp(tag1, "electronics", 11) != 0) {
                WriteFmt("[DEBUG] Tag 1 check failed: expected 'electronics', got '");
                for (size i = 0; i < StrLen(tag1); i++) {
                    WriteFmt("{c}", StrBegin(tag1)[i]);

In Read.Simple.c:466:

                WriteFmt("[DEBUG] Tag 1 check failed: expected 'electronics', got '");
                for (size i = 0; i < StrLen(tag1); i++) {
                    WriteFmt("{c}", StrBegin(tag1)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:468:

                    WriteFmt("{c}", StrBegin(tag1)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:473:

    
            if (StrCmp(tag2, "computers", 9) != 0) {
                WriteFmt("[DEBUG] Tag 2 check failed: expected 'computers', got '");
                for (size i = 0; i < StrLen(tag2); i++) {
                    WriteFmt("{c}", StrBegin(tag2)[i]);

In Read.Simple.c:475:

                WriteFmt("[DEBUG] Tag 2 check failed: expected 'computers', got '");
                for (size i = 0; i < StrLen(tag2); i++) {
                    WriteFmt("{c}", StrBegin(tag2)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:477:

                    WriteFmt("{c}", StrBegin(tag2)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Read.Simple.c:482:

    
            if (StrCmp(tag3, "portable", 8) != 0) {
                WriteFmt("[DEBUG] Tag 3 check failed: expected 'portable', got '");
                for (size i = 0; i < StrLen(tag3); i++) {
                    WriteFmt("{c}", StrBegin(tag3)[i]);

In Read.Simple.c:484:

                WriteFmt("[DEBUG] Tag 3 check failed: expected 'portable', got '");
                for (size i = 0; i < StrLen(tag3); i++) {
                    WriteFmt("{c}", StrBegin(tag3)[i]);
                }
                WriteFmt("'\n");

In Read.Simple.c:486:

                    WriteFmt("{c}", StrBegin(tag3)[i]);
                }
                WriteFmt("'\n");
                success = false;
            }

In Parse.c:170:

        };
    
        WriteFmt("[INFO] Starting KvConfig.Parse tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "KvConfig.Parse");
    }

In Str.Remove.c:22:

    // Test StrPopBack function
    bool test_str_pop_back(void) {
        WriteFmt("Testing StrPopBack\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:49:

    // Test StrPopFront function
    bool test_str_pop_front(void) {
        WriteFmt("Testing StrPopFront\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:76:

    // Test StrRemove function
    bool test_str_remove(void) {
        WriteFmt("Testing StrRemove\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:103:

    // Test StrRemoveRange function
    bool test_str_remove_range(void) {
        WriteFmt("Testing StrRemoveRange\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:133:

    // Test StrDeleteLastChar function
    bool test_str_delete_last_char(void) {
        WriteFmt("Testing StrDeleteLastChar\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:158:

    // Test StrDelete function
    bool test_str_delete(void) {
        WriteFmt("Testing StrDelete\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:183:

    // Test StrDeleteRange function
    bool test_str_delete_range(void) {
        WriteFmt("Testing StrDeleteRange\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Remove.c:208:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Remove tests\n\n");
    
        // Array of test functions

In Http.c:64:

    
    int main(void) {
        WriteFmt("[INFO] Starting Http tests\n\n");
    
        TestFunction tests[] = {

In Map.Insert.c:148:

        };
    
        WriteFmt("[INFO] Starting Map.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Insert");
    }

In BitVec.Memory.c:28:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecShrinkToFit\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:68:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:109:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSwap\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:157:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecClone\n");
    
        BitVec original = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:204:

    
    bool test_bitvec_clone_inherits_allocator_config(void) {
        WriteFmt("Testing BitVecClone allocator inheritance\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Memory.c:242:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecShrinkToFit edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:276:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:311:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSwap edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:355:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecClone edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:399:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec memory stress test\n");
    
        bool result = true;

In BitVec.Memory.c:438:

    // Deadend tests
    bool test_bitvec_memory_null_failures(void) {
        WriteFmt("Testing BitVec memory NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Memory.c:449:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec swap NULL handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:462:

    
    bool test_bitvec_clone_null_failures(void) {
        WriteFmt("Testing BitVec clone NULL handling\n");
    
        // Test NULL pointer - should abort

In BitVec.Memory.c:472:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Memory tests\n\n");
    
        // Array of normal test functions

In Int.Access.c:20:

    
    bool test_int_bit_length(void) {
        WriteFmt("Testing IntBitLength\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:34:

    
    bool test_int_byte_length(void) {
        WriteFmt("Testing IntByteLength\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:48:

    
    bool test_int_is_zero(void) {
        WriteFmt("Testing IntIsZero\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:65:

    
    bool test_int_is_one(void) {
        WriteFmt("Testing IntIsOne\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:82:

    
    bool test_int_parity(void) {
        WriteFmt("Testing Int parity helpers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:101:

    
    bool test_int_fits_u64(void) {
        WriteFmt("Testing IntFitsU64\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:120:

    
    bool test_int_log2(void) {
        WriteFmt("Testing IntLog2\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:136:

    
    bool test_int_trailing_zero_count(void) {
        WriteFmt("Testing IntTrailingZeroCount\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:153:

    
    bool test_int_is_power_of_two(void) {
        WriteFmt("Testing IntIsPowerOfTwo\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:178:

    
    bool test_int_log2_zero(void) {
        WriteFmt("Testing IntLog2 zero handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Access.c:194:

    
    int main(void) {
        WriteFmt("[INFO] Starting Int.Access tests\n\n");
    
        TestFunction tests[] = {

In BitVec.BitWise.Simple.c:35:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAnd\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:77:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecOr\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:119:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecXor\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:161:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecNot\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:195:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecShiftLeft\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:240:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecShiftRight\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:278:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRotateLeft\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:310:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRotateRight\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:342:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReverse\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:374:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec shift edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:413:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec rotate edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:444:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bitwise operations edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:486:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReverse edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:523:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive bitwise operations\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:592:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive shift operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:661:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive rotate operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:726:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bitwise identity operations\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:823:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bitwise commutative properties\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:888:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bitwise operations with large patterns\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:959:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.BitWise tests\n\n");
    
        // Array of normal test functions

In Str.Memory.c:19:

    // Test StrTryReduceSpace function
    bool test_str_try_reduce_space(void) {
        WriteFmt("Testing StrTryReduceSpace\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:47:

    // Test StrSwapCharAt function
    bool test_str_swap_char_at(void) {
        WriteFmt("Testing StrSwapCharAt\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:72:

    // Test StrResize function
    bool test_str_resize(void) {
        WriteFmt("Testing StrResize\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:101:

    // Test StrReserve function
    bool test_str_reserve(void) {
        WriteFmt("Testing StrReserve\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:129:

    // Test StrClear function
    bool test_str_clear(void) {
        WriteFmt("Testing StrClear\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:154:

    // Test StrReverse function
    bool test_str_reverse(void) {
        WriteFmt("Testing StrReverse\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Memory.c:203:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Memory tests\n\n");
    
        // Array of test functions

In Graph.Access.c:9:

    
    static bool test_graph_access_helpers(void) {
        WriteFmt("Testing Graph access helpers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Access.c:51:

    
    static bool test_graph_has_edge_query(void) {
        WriteFmt("Testing GraphHasEdge\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Access.c:77:

    
    static bool test_graph_cross_graph_node_handle_deadend(void) {
        WriteFmt("Testing GraphNodeData rejects foreign graph node handles (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Access.c:95:

    
    static bool test_graph_predecessor_access_oob_deadend(void) {
        WriteFmt("Testing GraphPredecessorAt out-of-bounds access (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Access.c:114:

    
    static bool test_graph_neighbor_access_oob_deadend(void) {
        WriteFmt("Testing GraphNeighborAt out-of-bounds access (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Access.c:143:

        };
    
        WriteFmt("[INFO] Starting Graph.Access tests\n\n");
        return run_test_suite(
            tests,

In Graph.Type.c:9:

    
    static bool test_graph_type_defaults(void) {
        WriteFmt("Testing Graph defaults\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Type.c:35:

    
    static bool test_graph_aligned_init_and_id_layout(void) {
        WriteFmt("Testing Graph aligned init and node id layout\n");
    
        HeapAllocator alloc = HeapAllocatorInitAligned(32);

In Graph.Type.c:62:

        };
    
        WriteFmt("[INFO] Starting Graph.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Graph.Type");
    }

In Str.Ops.c:23:

    // Test string comparison functions
    bool test_str_cmp(void) {
        WriteFmt("Testing StrCmp variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:61:

    // Test string find functions
    bool test_str_find(void) {
        WriteFmt("Testing StrFind variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:100:

    // Test string contains/index functions
    bool test_str_contains_index(void) {
        WriteFmt("Testing StrContains and StrIndexOf variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:126:

    // Test string starts/ends with functions
    bool test_str_starts_ends_with(void) {
        WriteFmt("Testing StrStartsWith and StrEndsWith variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:165:

    // Test string replace functions
    bool test_str_replace(void) {
        WriteFmt("Testing StrReplace variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:203:

    // Test string split functions
    bool test_str_split(void) {
        WriteFmt("Testing StrSplit and StrSplitToIters\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:252:

    // Test string strip functions
    bool test_str_strip(void) {
        WriteFmt("Testing StrStrip variants\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Ops.c:339:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Ops tests\n\n");
    
        // Array of test functions

In Int.Convert.c:40:

    
    bool test_int_from_unsigned_integer(void) {
        WriteFmt("Testing IntFrom with unsigned integer\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:58:

    
    bool test_int_bytes_le_round_trip(void) {
        WriteFmt("Testing Int little-endian byte conversion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:79:

    
    bool test_int_bytes_be_round_trip(void) {
        WriteFmt("Testing Int big-endian byte conversion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:100:

    
    bool test_int_binary_round_trip(void) {
        WriteFmt("Testing Int binary round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:117:

    
    bool test_int_decimal_round_trip(void) {
        WriteFmt("Testing Int decimal round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:134:

    
    bool test_int_radix_round_trip(void) {
        WriteFmt("Testing Int radix conversion round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:151:

    
    bool test_int_upper_hex_radix(void) {
        WriteFmt("Testing Int uppercase radix conversion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:167:

    
    bool test_int_try_to_str_allocator_inheritance(void) {
        WriteFmt("Testing IntTryToStr allocator behavior\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:194:

    
    bool test_int_compare_ignores_leading_zeros(void) {
        WriteFmt("Testing IntCompare leading-zero normalization\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:211:

    
    bool test_int_zero_binary(void) {
        WriteFmt("Testing Int zero binary conversion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:232:

    
    bool test_int_binary_prefix_and_separators(void) {
        WriteFmt("Testing Int binary prefix and separators\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:247:

    
    bool test_int_octal_round_trip(void) {
        WriteFmt("Testing Int octal round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:264:

    
    bool test_int_hex_round_trip(void) {
        WriteFmt("Testing Int hex round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:281:

    
    bool test_int_from_binary_invalid_digit(void) {
        WriteFmt("Testing IntFromBinary invalid digit handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:299:

    
    bool test_int_from_decimal_invalid_digit(void) {
        WriteFmt("Testing IntFromStr invalid digit handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:317:

    
    bool test_int_from_hex_invalid_digit(void) {
        WriteFmt("Testing IntFromHexStr invalid digit handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:335:

    
    bool test_int_from_radix_invalid_digit(void) {
        WriteFmt("Testing IntFromStrRadix invalid digit handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:353:

    
    bool test_int_from_radix_invalid_radix(void) {
        WriteFmt("Testing IntFromStrRadix invalid radix handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:371:

    
    bool test_int_to_u64_overflow(void) {
        WriteFmt("Testing IntToU64 overflow handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:392:

    
    bool test_int_to_str_radix_invalid_radix(void) {
        WriteFmt("Testing IntToStrRadix invalid radix handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:408:

    
    bool test_int_from_binary_null(void) {
        WriteFmt("Testing IntFromBinary NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:426:

    
    bool test_int_from_decimal_null(void) {
        WriteFmt("Testing IntFromStr NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:444:

    
    bool test_int_from_radix_null(void) {
        WriteFmt("Testing IntFromStrRadix NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:462:

    
    bool test_int_from_octal_null(void) {
        WriteFmt("Testing IntFromOctStr NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:480:

    
    bool test_int_from_hex_null(void) {
        WriteFmt("Testing IntFromHexStr NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:498:

    
    bool test_int_from_bytes_le_null(void) {
        WriteFmt("Testing IntFromBytesLE NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:508:

    
    bool test_int_to_bytes_le_null(void) {
        WriteFmt("Testing IntToBytesLE NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:519:

    
    bool test_int_to_bytes_be_zero_max_len(void) {
        WriteFmt("Testing IntToBytesBE zero max_len handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Convert.c:532:

    
    int main(void) {
        WriteFmt("[INFO] Starting Int.Convert tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Foreach.Deadend.c:20:

    
    bool test_bitvec_run_lengths_null_bv(void) {
        WriteFmt("Testing BitVecRunLengths with NULL bitvector\n");
    
        u64  runs[5];

In BitVec.Foreach.Deadend.c:34:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with NULL runs array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Deadend.c:51:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with NULL values array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Deadend.c:68:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with zero max_runs\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Deadend.c:90:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach with invalid bitvec\n");
    
        // Test foreach with invalid bitvec (length > 0 but data is NULL)

In BitVec.Foreach.Deadend.c:116:

    // Main function that runs all deadend tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Foreach.Deadend tests\n\n");
    
        // Array of deadend test functions

In List.Init.c:29:

    
    static bool test_list_init_variants(void) {
        WriteFmt("Testing List init variants\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Init.c:58:

    
    static bool test_list_init_optional_allocator(void) {
        WriteFmt("Testing List init optional allocator\n");
    
        typedef List(int) IntList;

In List.Init.c:90:

    
    static bool test_list_deinit_with_deep_copy(void) {
        WriteFmt("Testing ListDeinit with deep copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Init.c:122:

        };
    
        WriteFmt("[INFO] Starting List.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Init");
    }

In PdbCache.c:331:

    
    int main(void) {
        WriteFmt("[INFO] Starting PdbCache tests\n\n");
    
        TestFunction tests[] = {

In List.Insert.c:45:

    
    static bool test_list_insert_and_push_aliases(void) {
        WriteFmt("Testing List insert and push aliases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:81:

    
    static bool test_list_push_arr_l_zeroes_all_items(void) {
        WriteFmt("Testing ListPushArrL zeroes all transferred items\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:100:

    
    static bool test_list_push_arr_zero_count_is_noop(void) {
        WriteFmt("Testing ListPushArrL zero-count contract\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:120:

    
    static bool test_list_insert_with_deep_copy(void) {
        WriteFmt("Testing List insert with deep copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:146:

    
    static bool test_list_merge_l_preserves_source_hooks_for_reuse(void) {
        WriteFmt("Testing ListMergeL preserves source hooks for reuse\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:176:

    
    static bool test_list_merge_variants(void) {
        WriteFmt("Testing List merge variants\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:222:

    
    static bool test_list_merge_edge_cases(void) {
        WriteFmt("Testing List merge edge cases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Insert.c:264:

        };
    
        WriteFmt("[INFO] Starting List.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Insert");
    }

In Backtrace.c:224:

    
    int main(void) {
        WriteFmt("[INFO] Starting Backtrace tests\n\n");
    
        TestFunction tests[] = {

In Int.Type.c:15:

    
    bool test_int_init(void) {
        WriteFmt("Testing IntInit\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Type.c:30:

    
    bool test_int_clear(void) {
        WriteFmt("Testing IntClear\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Type.c:47:

    
    bool test_int_clone(void) {
        WriteFmt("Testing IntClone\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Type.c:70:

    
    bool test_int_clone_inherits_allocator_config(void) {
        WriteFmt("Testing IntClone allocator inheritance\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Type.c:103:

    
    int main(void) {
        WriteFmt("[INFO] Starting Int.Type tests\n\n");
    
        TestFunction tests[] = {

In SymbolResolver.c:62:

    
    int main(void) {
        WriteFmt("[INFO] Starting SymbolResolver tests\n\n");
    
        TestFunction tests[] = {

In Allocator.Page.c:17:

        bool ok = (ps >= 4096) && ((ps & (ps - 1)) == 0);
        if (!ok) {
            WriteFmt("page size invalid: {}\n", ps);
        }
        return ok;

In Allocator.Page.c:116:

    
        if (PageAllocatorEntryCount(&alloc) != 0) {
            WriteFmt("init EntryCount != 0\n");
            ok = false;
        }

In Allocator.Page.c:120:

        }
        if (AllocatorFootprintBytes(&alloc) != 0) {
            WriteFmt("init Footprint != 0\n");
            ok = false;
        }

In Allocator.Page.c:127:

        void *p2 = AllocatorAlloc(alloc_base, page * 2, true);
        if (!p1 || !p2) {
            WriteFmt("alloc failed\n");
            ok = false;
        }

In Allocator.Page.c:131:

        }
        if (PageAllocatorEntryCount(&alloc) != 2) {
            WriteFmt("after 2 allocs EntryCount={} want 2\n", (u64)PageAllocatorEntryCount(&alloc));
            ok = false;
        }

In Allocator.Page.c:137:

        size foot_with_two = AllocatorFootprintBytes(&alloc);
        if (foot_with_two < page + page * 2) {
            WriteFmt("foot_with_two={} want >= {}\n", (u64)foot_with_two, (u64)(page + page * 2));
            ok = false;
        }

In Allocator.Page.c:146:

        // EntryCount drops to 1 (p1 moved to free_entries[]).
        if (PageAllocatorEntryCount(&alloc) != 1) {
            WriteFmt("after free p1 EntryCount={} want 1\n", (u64)PageAllocatorEntryCount(&alloc));
            ok = false;
        }

In Allocator.Page.c:153:

        size foot_after_free_p1 = AllocatorFootprintBytes(&alloc);
        if (foot_after_free_p1 < foot_with_two) {
            WriteFmt("foot shrank after retention: {} < {}\n", (u64)foot_after_free_p1, (u64)foot_with_two);
            ok = false;
        }

In Allocator.Page.c:161:

        }
        if (PageAllocatorEntryCount(&alloc) != 0) {
            WriteFmt("after free p2 EntryCount={} want 0\n", (u64)PageAllocatorEntryCount(&alloc));
            ok = false;
        }

In Allocator.Page.c:165:

        }
        if (AllocatorFootprintBytes(&alloc) < foot_with_two) {
            WriteFmt("foot shrank after all-free\n");
            ok = false;
        }

In Allocator.Page.c:172:

        // Post-deinit the struct is zeroed: both accessors return 0.
        if (PageAllocatorEntryCount(&alloc) != 0) {
            WriteFmt("post-deinit EntryCount != 0\n");
            ok = false;
        }

In Allocator.Page.c:176:

        }
        if (AllocatorFootprintBytes(&alloc) != 0) {
            WriteFmt("post-deinit Footprint != 0\n");
            ok = false;
        }

In List.Foreach.c:32:

    
    static bool test_list_foreach_basic(void) {
        WriteFmt("Testing basic List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:72:

    
    static bool test_list_foreach_ranges(void) {
        WriteFmt("Testing ranged List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:109:

    
    static bool test_list_foreach_range_edge_cases(void) {
        WriteFmt("Testing List ranged foreach edge cases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:158:

    
    static bool test_list_foreach_index_variants(void) {
        WriteFmt("Testing indexed List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:202:

    
    static bool test_list_foreach_index_jump_contract(void) {
        WriteFmt("Testing indexed List foreach jump contract\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:262:

    
    static bool test_list_foreach_empty_lists(void) {
        WriteFmt("Testing List foreach macros on empty list\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Foreach.c:349:

        };
    
        WriteFmt("[INFO] Starting List.Foreach tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Foreach");
    }

In List.Ops.c:50:

    
    static bool test_list_clear_and_reuse(void) {
        WriteFmt("Testing ListClear and reuse\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Ops.c:74:

    
    static bool test_list_sort_and_reverse(void) {
        WriteFmt("Testing ListSort and ListReverse\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Ops.c:99:

    
    static bool test_list_sort_and_reverse_edge_cases(void) {
        WriteFmt("Testing ListSort and ListReverse edge cases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Ops.c:123:

    
    static bool test_list_clear_with_deep_copy(void) {
        WriteFmt("Testing ListClear with deep copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Ops.c:158:

        };
    
        WriteFmt("[INFO] Starting List.Ops tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Ops");
    }

In Str.Convert.c:30:

    // Test StrFromU64 function
    bool test_str_from_u64(void) {
        WriteFmt("Testing StrFromU64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:41:

        bool result = (ZstrCompare(StrBegin(&s), "12345") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '12345', got '{}'\n", s);
        }

In Str.Convert.c:50:

        result = result && (ZstrCompare(StrBegin(&s), "0xabcd") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0xabcd', got '{}'\n", s);
        }

In Str.Convert.c:59:

        result = result && (ZstrCompare(StrBegin(&s), "0xABCD") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0xABCD', got '{}'\n", s);
        }

In Str.Convert.c:68:

        result = result && (ZstrCompare(StrBegin(&s), "0b101010") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0b101010', got '{}'\n", s);
        }

In Str.Convert.c:77:

        result = result && (ZstrCompare(StrBegin(&s), "0o52") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0o52', got '{}'\n", s);
        }

In Str.Convert.c:86:

        result = result && (ZstrCompare(StrBegin(&s), "0") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0', got '{}'\n", s);
        }

In Str.Convert.c:96:

    // Test StrFromI64 function
    bool test_str_from_i64(void) {
        WriteFmt("Testing StrFromI64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:107:

        bool result = (ZstrCompare(StrBegin(&s), "12345") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '12345', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:116:

        result = result && (ZstrCompare(StrBegin(&s), "-12345") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '-12345', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:127:

        result = result && (ZstrCompareN(StrBegin(&s), "0x", 2) == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected hex prefix '0x', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:136:

        result = result && (ZstrCompare(StrBegin(&s), "0") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:145:

        result = result && (ZstrCompare(StrBegin(&s), "0b101010") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '0b101010', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:155:

    // Test StrFromF64 function
    bool test_str_from_f64(void) {
        WriteFmt("Testing StrFromF64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:166:

        bool result = (ZstrCompare(StrBegin(&s), "123.00") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '123.00', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:175:

        result = result && (ZstrCompare(StrBegin(&s), "123.456") == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected '123.456', got '{}'\n", StrBegin(&s));
        }

In Str.Convert.c:239:

    // Test StrToU64 function
    bool test_str_to_u64(void) {
        WriteFmt("Testing StrToU64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:299:

    // Test StrToI64 function
    bool test_str_to_i64(void) {
        WriteFmt("Testing StrToI64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:346:

    // Test StrToF64 function
    bool test_str_to_f64(void) {
        WriteFmt("Testing StrToF64\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:411:

    // Round-trip conversion tests
    bool test_str_round_trip_conversions(void) {
        WriteFmt("Testing Str round-trip conversions\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:493:

    // Edge case conversion tests
    bool test_str_edge_case_conversions(void) {
        WriteFmt("Testing Str edge case conversions\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:581:

    // Precision limits testing
    bool test_str_precision_limits(void) {
        WriteFmt("Testing Str precision limits\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:651:

    // Large-scale conversion tests
    bool test_str_all_base_support(void) {
        WriteFmt("Testing Str all bases 2-36 support\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:724:

    
    bool test_str_large_scale_conversions(void) {
        WriteFmt("Testing Str large-scale conversions\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Convert.c:794:

    // Deadend tests for NULL pointer handling
    bool test_str_conversion_null_failures(void) {
        WriteFmt("Testing Str conversion NULL pointer handling\n");
    
        // Test NULL string pointer - should abort

In Str.Convert.c:804:

    
    bool test_str_conversion_bounds_failures(void) {
        WriteFmt("Testing Str conversion bounds failures\n");
    
        // Test StrFromI64 with NULL pointer - should abort

In Str.Convert.c:814:

    
    bool test_str_conversion_invalid_input_failures(void) {
        WriteFmt("Testing Str conversion invalid input failures\n");
    
        // Test StrFromF64 with NULL pointer - should abort

In Str.Convert.c:825:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Convert tests\n\n");
    
        // Array of normal test functions

In Graph.Ops.c:8:

    
    static bool test_graph_node_visit_scratch_state(void) {
        WriteFmt("Testing Graph node scratch visit state\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:34:

    
    static bool test_graph_mark_delete_commit_and_reuse(void) {
        WriteFmt("Testing GraphMarkNodeForDeletion and GraphCommitChanges\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:81:

    
    static bool test_graph_query_and_unmark_node_deletion(void) {
        WriteFmt("Testing Graph node mark query and unmark\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:108:

    
    static bool test_graph_mark_edge_for_removal(void) {
        WriteFmt("Testing GraphMarkEdgeForRemoval and deferred edge commit\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:157:

    
    static bool test_graph_query_and_unmark_edge_removal(void) {
        WriteFmt("Testing Graph edge mark query and unmark\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:186:

    
    static bool test_graph_partial_unmark_of_multiple_edge_removals(void) {
        WriteFmt("Testing partial unmark of multiple pending edge removals\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:220:

    
    static bool test_graph_self_loop_edge_removal(void) {
        WriteFmt("Testing deferred removal of self-loop edge\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:246:

    
    static bool test_graph_edge_removal_and_node_deletion_overlap(void) {
        WriteFmt("Testing overlap between pending edge removal and node deletion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:282:

    
    static bool test_graph_external_indexed_state_requires_reset_on_reuse(void) {
        WriteFmt("Testing external slot-indexed state across delete and reuse\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:317:

    
    static bool test_graph_stale_node_handle_after_commit_deadend(void) {
        WriteFmt("Testing stale GraphNode handle after commit (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:352:

        };
    
        WriteFmt("[INFO] Starting Graph.Ops tests\n\n");
        return run_test_suite(
            tests,

In Float.Compare.c:20:

    
    bool test_float_compare_small_small(void) {
        WriteFmt("Testing FloatCompare with small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:41:

    
    bool test_float_compare_very_large_large(void) {
        WriteFmt("Testing FloatCompare with very large floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:62:

    
    bool test_float_compare_very_large_small(void) {
        WriteFmt("Testing FloatCompare with very large and small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:82:

    
    bool test_float_compare_wrappers(void) {
        WriteFmt("Testing Float compare macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:105:

    
    bool test_float_compare_generic(void) {
        WriteFmt("Testing FloatCompare generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:138:

    // Two construction paths for the same value must hash to the same bucket.
    bool test_float_hash_determinism(void) {
        WriteFmt("Testing float_hash determinism\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:161:

    // +1.5e3 / -1.5e3 / 1.5e2 all land in distinct buckets.
    bool test_float_hash_distinguishes(void) {
        WriteFmt("Testing float_hash sensitivity to sign / exponent / magnitude\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:195:

    // the GenericHash / GenericCompare-shaped helpers wire in directly.
    bool test_float_hash_as_map_key(void) {
        WriteFmt("Testing float_hash as Map<Float, u64> key\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Compare.c:225:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Compare tests\n\n");
    
        TestFunction tests[] = {

In Str.Access.c:20:

    // Test StrLen and StrEmpty functions
    bool test_str_len_empty(void) {
        WriteFmt("Testing StrLen and StrEmpty\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:46:

    // Test StrFirst function
    bool test_str_first(void) {
        WriteFmt("Testing StrFirst\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:65:

    // Test StrLast function
    bool test_str_last(void) {
        WriteFmt("Testing StrLast\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:84:

    // Test StrBegin function
    bool test_str_begin(void) {
        WriteFmt("Testing StrBegin\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:103:

    // Test StrEnd function
    bool test_str_end(void) {
        WriteFmt("Testing StrEnd\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:123:

    // Test StrCharAt function
    bool test_str_char_at(void) {
        WriteFmt("Testing StrCharAt\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:147:

    // Test StrCharPtrAt function
    bool test_str_char_ptr_at(void) {
        WriteFmt("Testing StrCharPtrAt\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Access.c:171:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Access tests\n\n");
    
        // Array of test functions

In Socket.c:122:

    
    int main(void) {
        WriteFmt("[INFO] Starting Socket tests\n\n");
    
        TestFunction tests[] = {

In Vec.Ops.c:32:

    
    bool test_vec_swap_items(void) {
        WriteFmt("Testing VecSwapItems\n");
    
        // Create a vector of integers

In Vec.Ops.c:67:

    // Test VecReverse function
    bool test_vec_reverse(void) {
        WriteFmt("Testing VecReverse\n");
    
        // Create a vector of integers

In Vec.Ops.c:119:

    // Test VecSort function
    bool test_vec_sort(void) {
        WriteFmt("Testing VecSort\n");
    
        // Create a vector of integers

In Vec.Ops.c:159:

    int main(void) {
        alloc = DefaultAllocatorInit();
        WriteFmt("[INFO] Starting Vec.Ops tests\n\n");
    
        // Array of test functions

In MachO.c:274:

    
    int main(void) {
        WriteFmt("[INFO] Starting MachO tests\n\n");
    
        TestFunction tests[] = {

In Elf.c:94:

    
    int main(void) {
        WriteFmt("[INFO] Starting Elf tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Insert.c:26:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecPush\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:59:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsert (single bit)\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:98:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertRange\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:129:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertMultiple\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:167:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertPattern\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:216:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertRange edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:247:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertMultiple edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:283:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInsertPattern edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:310:

    // Deadend tests
    bool test_bitvec_insert_null_failures(void) {
        WriteFmt("Testing BitVec insert NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Insert.c:321:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec insert invalid range handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:334:

    
    bool test_bitvec_insert_pattern_null_failures(void) {
        WriteFmt("Testing BitVec insert pattern NULL handling\n");
    
        // Test NULL bitvec - should abort

In BitVec.Insert.c:344:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Insert tests\n\n");
    
        // Array of normal test functions

In Io.UserTypes.c:128:

    
    bool test_user_type_write_basic(void) {
        WriteFmt("Testing user-type write through IOFMT_USER_CASE_\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:143:

    
    bool test_user_type_write_mixed_args(void) {
        WriteFmt("Testing user-type mixed with in-tree types\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:159:

    
    bool test_user_type_read_basic(void) {
        WriteFmt("Testing user-type read through IOFMT_USER_CASE_\n");
    
        Zstr    in = "(42, -9)";

In Io.UserTypes.c:170:

    
    bool test_user_type_round_trip(void) {
        WriteFmt("Testing user-type write/read round-trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:189:

    
    bool test_nested_user_type_write(void) {
        WriteFmt("Testing user-type-in-user-type writer (Bounds embeds Point2D)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:207:

    
    bool test_nested_user_type_round_trip(void) {
        WriteFmt("Testing nested user-type round-trip (Bounds)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:231:

    
    bool test_deep_nested_user_type_write(void) {
        WriteFmt("Testing 3-level nested user-type writer (Region -> Bounds -> Point2D)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:250:

    
    bool test_deep_nested_user_type_round_trip(void) {
        WriteFmt("Testing 3-level nested user-type round-trip (Region)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:277:

    
    bool test_nested_user_type_mixed_with_builtins(void) {
        WriteFmt("Testing nested user types mixed with built-ins in one call\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.UserTypes.c:304:

    
    int main(void) {
        WriteFmt("[INFO] Starting Io.UserTypes tests\n\n");
    
        TestFunction tests[] = {

In SysDns.c:222:

    
    int main(void) {
        WriteFmt("[INFO] Starting SysDns tests\n\n");
    
        TestFunction tests[] = {

In AllocDebug.c:317:

    
    int main(void) {
        WriteFmt("[INFO] Starting AllocDebug tests\n\n");
    
        TestFunction normal[] = {

In Vec.Foreach.c:32:

    
    bool test_vec_foreach(void) {
        WriteFmt("Testing VecForeach\n");
    
        // Create a vector of integers

In Vec.Foreach.c:71:

    // Test VecForeachIdx macro
    bool test_vec_foreach_idx(void) {
        WriteFmt("Testing VecForeachIdx\n");
    
        // Create a vector of integers

In Vec.Foreach.c:107:

    // Test VecForeachPtr macro
    bool test_vec_foreach_ptr(void) {
        WriteFmt("Testing VecForeachPtr\n");
    
        // Create a vector of integers

In Vec.Foreach.c:148:

    // Test VecForeachPtrIdx macro
    bool test_vec_foreach_ptr_idx(void) {
        WriteFmt("Testing VecForeachPtrIdx\n");
    
        // Create a vector of integers

In Vec.Foreach.c:179:

    // Test VecForeachReverse macro
    bool test_vec_foreach_reverse(void) {
        WriteFmt("Testing VecForeachReverse\n");
    
        // Create a vector of integers

In Vec.Foreach.c:212:

    // Test VecForeachReverseIdx macro
    bool test_vec_foreach_reverse_idx(void) {
        WriteFmt("Testing VecForeachReverseIdx\n");
    
        // Create a vector of integers

In Vec.Foreach.c:239:

    // Test VecForeachPtrReverse macro
    bool test_vec_foreach_ptr_reverse(void) {
        WriteFmt("Testing VecForeachPtrReverse\n");
    
        // Create a vector of integers

In Vec.Foreach.c:273:

    // Test VecForeachPtrReverseIdx macro
    bool test_vec_foreach_ptr_reverse_idx(void) {
        WriteFmt("Testing VecForeachPtrReverseIdx\n");
    
        // Create a vector of integers

In Vec.Foreach.c:308:

    // Make idx go out of bounds during VecForeach by modifying vector during iteration
    bool test_vec_foreach_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeach where modification causes out of bounds access (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:321:

        int iteration_count = 0;
        VecForeach(&vec, val) {
            WriteFmt("Iteration {} (vec.length={}): {}\n", iteration_count, VecLen(&vec), val);
    
            // After 2nd iteration, shrink the vector dramatically

In Vec.Foreach.c:326:

            if (iteration_count == 2) {
                VecResize(&vec, 2); // Shrink to only 2 elements
                WriteFmt("Vector resized to length {} during foreach iteration...\n", VecLen(&vec));
            }

In Vec.Foreach.c:348:

    // Make idx go out of bounds in VecForeachIdx by modifying vector during iteration
    bool test_vec_foreach_idx_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeachIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:360:

        // VecForeachIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        VecForeachIdx(&vec, val, idx) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
    
            // When we reach idx=2, drastically shrink the vector to make the current idx invalid

In Vec.Foreach.c:366:

            if (idx == 2) {
                VecResize(&vec, 2); // Shrink so that idx=2 becomes out of bounds (valid indices: 0,1)
                WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
            }

In Vec.Foreach.c:386:

    // Make idx go out of bounds in VecForeachReverseIdx by modifying vector during iteration
    bool test_vec_foreach_reverse_idx_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeachReverseIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:398:

        // VecForeachReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        VecForeachReverseIdx(&vec, val, idx) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
    
            // When we reach idx=4, drastically shrink the vector

In Vec.Foreach.c:405:

            if (idx == 4) {
                VecResize(&vec, 2); // Shrink to only 2 elements
                WriteFmt("Vector resized to length {} during reverse iteration...\n", VecLen(&vec));
            }

In Vec.Foreach.c:425:

    // Make idx go out of bounds in VecForeachPtrIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_idx_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeachPtrIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:437:

        // VecForeachPtrIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        VecForeachPtrIdx(&vec, val_ptr, idx) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
    
            // When we reach idx=3, shrink the vector to make the CURRENT idx invalid

In Vec.Foreach.c:443:

            if (idx == 3) {
                VecResize(&vec, 3); // Shrink so that idx=3 becomes out of bounds (valid indices: 0,1,2)
                WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
            }

In Vec.Foreach.c:463:

    // Make idx go out of bounds in VecForeachPtrReverseIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_reverse_idx_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeachPtrReverseIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:475:

        // VecForeachPtrReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        VecForeachPtrReverseIdx(&vec, val_ptr, idx) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
    
            // When we reach idx=5, shrink the vector significantly

In Vec.Foreach.c:480:

            if (idx == 5) {
                VecResize(&vec, 3); // Shrink to only 3 elements
                WriteFmt("Vector resized to length {} during reverse ptr iteration...\n", VecLen(&vec));
            }

In Vec.Foreach.c:500:

    // Make idx go out of bounds in VecForeachPtrInRangeIdx by modifying vector during iteration
    bool test_vec_foreach_ptr_in_range_idx_out_of_bounds_access(void) {
        WriteFmt("Testing VecForeachPtrInRangeIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:513:

        size original_length = VecLen(&vec); // Capture this as 9
        VecForeachPtrInRangeIdx(&vec, val_ptr, idx, 0, original_length) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
    
            // When we reach idx=3, delete several elements

In Vec.Foreach.c:518:

            if (idx == 3) {
                VecDeleteRange(&vec, 0, 6); // Remove first 6 elements
                WriteFmt("Deleted first 6 elements, new length={}, idx = {}\n", VecLen(&vec), original_length, idx);
            }

In Vec.Foreach.c:538:

    // Make idx go out of bounds in basic VecForeachIdx by modifying vector during iteration
    bool test_vec_foreach_idx_basic_out_of_bounds_access(void) {
        WriteFmt("Testing basic VecForeachIdx where idx goes out of bounds (should crash)\n");
    
        typedef Vec(int) IntVec;

In Vec.Foreach.c:550:

        // Basic VecForeachIdx now has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        VecForeachIdx(&vec, val, idx) {
            WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
    
            // When we reach idx=2, drastically shrink the vector

In Vec.Foreach.c:556:

            if (idx == 2) {
                VecResize(&vec, 1); // Shrink to only 1 element
                WriteFmt("Vector resized to length {}, current index={}\n", VecLen(&vec), idx);
            }

In Vec.Foreach.c:577:

    int main(void) {
        alloc = DefaultAllocatorInit();
        WriteFmt("[INFO] Starting Vec.Foreach.Simple tests\n\n");
    
        // Array of normal test functions

In Map.Foreach.c:90:

        };
    
        WriteFmt("[INFO] Starting Map.Foreach tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Foreach");
    }

In Buf.c:263:

    
    int main(void) {
        WriteFmt("[INFO] Starting Buf tests\n\n");
        TestFunction tests[] = {
            test_buf_init_clear,

In BitVec.Type.c:16:

    // Test basic BitVec type functionality
    bool test_bitvec_type_basic(void) {
        WriteFmt("Testing basic BitVec type functionality\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Type.c:37:

    // Test ValidateBitVec macro
    bool test_bitvec_validate(void) {
        WriteFmt("Testing ValidateBitVec macro\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Type.c:59:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Type tests\n\n");
    
        // Array of test functions

In BitVec.Pattern.Simple.c:60:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing basic BitVec pattern functions\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:98:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:148:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindLastPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:196:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindAllPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:261:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        WriteFmt("Testing BitVecFindAllPattern Vec form\n");
    
        BitVec source  = BitVecInit(base);

In BitVec.Pattern.Simple.c:297:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec pattern edge cases\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:369:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec pattern stress tests\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:415:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecStartsWith basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:453:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecStartsWith edge cases\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:488:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEndsWith basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:526:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEndsWith edge cases\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:552:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:592:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:625:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:652:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCountPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:690:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:730:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReplace basic functionality\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:775:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReplaceAll basic functionality\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:815:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecMatches basic functionality\n");
    
        BitVec source   = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:853:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:892:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRegexMatch basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:918:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecPrefixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:970:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSuffixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:1020:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Pattern.Simple tests\n\n");
    
        // Array of test functions

In Io.Read.c:42:

    
    bool test_integer_decimal_reading(void) {
        WriteFmt("Testing integer decimal reading\n");
    
        Zstr z = NULL;

In Io.Read.c:137:

    
    bool test_integer_hex_reading(void) {
        WriteFmt("Testing integer hexadecimal reading\n");
    
        Zstr z = NULL;

In Io.Read.c:172:

    
    bool test_integer_binary_reading(void) {
        WriteFmt("Testing integer binary reading\n");
    
        Zstr z = NULL;

In Io.Read.c:197:

    
    bool test_integer_octal_reading(void) {
        WriteFmt("Testing integer octal reading\n");
    
        Zstr z = NULL;

In Io.Read.c:227:

    
    bool test_float_basic_reading(void) {
        WriteFmt("Testing basic float reading\n");
    
        Zstr z = NULL;

In Io.Read.c:269:

    
    bool test_float_scientific_reading(void) {
        WriteFmt("Testing scientific notation reading\n");
    
        Zstr z = NULL;

In Io.Read.c:314:

    
    bool test_string_reading(void) {
        WriteFmt("Testing string reading\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Read.c:359:

    
    bool test_multiple_arguments_reading(void) {
        WriteFmt("Testing multiple arguments reading\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Read.c:398:

    // destination variable is left at its pre-read value on parse failure.
    bool test_error_handling_reading(void) {
        WriteFmt("Testing error handling for reading\n");
    
        Zstr z = NULL;

In Io.Read.c:423:

    
    bool test_character_ordinal_reading(void) {
        WriteFmt("Testing character ordinal reading with :c format specifier\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Read.c:434:

        z         = "A";
        StrReadFmt(z, "{c}", u8_val);
        WriteFmt("u8_val = {}, expected = {}, pass = {}\n", u8_val, 'A', (u8_val == 'A') ? "true" : "false");
        success = success && (u8_val == 'A');

In Io.Read.c:440:

        z      = "z";
        StrReadFmt(z, "{c}", u8_val);
        WriteFmt("u8_val = {}, expected = {}, pass = {}\n", u8_val, 'z', (u8_val == 'z') ? "true" : "false");
        success = success && (u8_val == 'z');

In Io.Read.c:446:

        z         = "B";
        StrReadFmt(z, "{c}", i8_val);
        WriteFmt("i8_val = {}, expected = {}, pass = {}\n", i8_val, 'B', (i8_val == 'B') ? "true" : "false");
        success = success && (i8_val == 'B');

In Io.Read.c:452:

        z           = "C";
        StrReadFmt(z, "{c}", i16_val);
        WriteFmt("i16_val = {}, expected = {}, pass = {}\n", i16_val, 'C', (i16_val == 'C') ? "true" : "false");
        success = success && (i16_val == 'C');

In Io.Read.c:458:

        z           = "D";
        StrReadFmt(z, "{c}", i32_val);
        WriteFmt("i32_val = {}, expected = {}, pass = {}\n", i32_val, 'D', (i32_val == 'D') ? "true" : "false");
        success = success && (i32_val == 'D');

In Io.Read.c:464:

        z           = "E";
        StrReadFmt(z, "{c}", i64_val);
        WriteFmt("i64_val = {}, expected = {}, pass = {}\n", i64_val, 'E', (i64_val == 'E') ? "true" : "false");
        success = success && (i64_val == 'E');

In Io.Read.c:470:

        z           = "F";
        StrReadFmt(z, "{c}", u16_val);
        WriteFmt("u16_val = {}, expected = {}, pass = {}\n", u16_val, 'F', (u16_val == 'F') ? "true" : "false");
        success = success && (u16_val == 'F');

In Io.Read.c:476:

        z           = "G";
        StrReadFmt(z, "{c}", u32_val);
        WriteFmt("u32_val = {}, expected = {}, pass = {}\n", u32_val, 'G', (u32_val == 'G') ? "true" : "false");
        success = success && (u32_val == 'G');

In Io.Read.c:482:

        z           = "H";
        StrReadFmt(z, "{c}", u64_val);
        WriteFmt("u64_val = {}, expected = {}, pass = {}\n", u64_val, 'H', (u64_val == 'H') ? "true" : "false");
        success = success && (u64_val == 'H');

In Io.Read.c:489:

        StrReadFmt(z, "{c}", u16_val);
        bool u16_multi_pass = (ZstrCompareN((Zstr)&u16_val, "AB", 2) == 0);
        WriteFmt("u16_val multi-char test: comparing memory with 'AB', pass = {}\n", u16_multi_pass ? "true" : "false");
        WriteFmt(
            "DEBUG: u16_val bytes: [{}, {}], expected 'AB' bytes: [{}, {}]\n",

In Io.Read.c:490:

        bool u16_multi_pass = (ZstrCompareN((Zstr)&u16_val, "AB", 2) == 0);
        WriteFmt("u16_val multi-char test: comparing memory with 'AB', pass = {}\n", u16_multi_pass ? "true" : "false");
        WriteFmt(
            "DEBUG: u16_val bytes: [{}, {}], expected 'AB' bytes: [{}, {}]\n",
            (int)((u8 *)&u16_val)[0],

In Io.Read.c:503:

        StrReadFmt(z, "{c}", i16_val);
        bool i16_multi_pass = (ZstrCompareN((Zstr)&i16_val, "CD", 2) == 0);
        WriteFmt("i16_val multi-char test: comparing memory with 'CD', pass = {}\n", i16_multi_pass ? "true" : "false");
        success = success && i16_multi_pass;

In Io.Read.c:510:

        StrReadFmt(z, "{c}", u32_val);
        bool u32_multi_pass = (ZstrCompareN((Zstr)&u32_val, "EFGH", 4) == 0);
        WriteFmt("u32_val multi-char test: comparing memory with 'EFGH', pass = {}\n", u32_multi_pass ? "true" : "false");
        success = success && u32_multi_pass;

In Io.Read.c:517:

        StrReadFmt(z, "{c}", i32_val);
        bool i32_multi_pass = (ZstrCompareN((Zstr)&i32_val, "IJKL", 4) == 0);
        WriteFmt("i32_val multi-char test: comparing memory with 'IJKL', pass = {}\n", i32_multi_pass ? "true" : "false");
        success = success && i32_multi_pass;

In Io.Read.c:524:

        StrReadFmt(z, "{c}", u64_val);
        bool u64_multi_pass = (ZstrCompareN((Zstr)&u64_val, "MNOPQRST", 8) == 0);
        WriteFmt(
            "u64_val multi-char test: comparing memory with 'MNOPQRST', pass = {}\n",
            u64_multi_pass ? "true" : "false"

In Io.Read.c:534:

        StrReadFmt(z, "{c}", i64_val);
        bool i64_multi_pass = (ZstrCompareN((Zstr)&i64_val, "UVWXYZab", 8) == 0);
        WriteFmt(
            "i64_val multi-char test: comparing memory with 'UVWXYZab', pass = {}\n",
            i64_multi_pass ? "true" : "false"

In Io.Read.c:544:

        StrReadFmt(z, "{c}", f32_val);
        bool f32_pass = (f32_val == (f32)'A');
        WriteFmt("f32_val = {}, expected = {}, pass = {}\n", f32_val, (f32)'A', f32_pass ? "true" : "false");
        success = success && f32_pass;

In Io.Read.c:551:

        StrReadFmt(z, "{c}", f64_val);
        bool f64_pass = (f64_val == (f64)'B');
        WriteFmt("f64_val = {}, expected = {}, pass = {}\n", f64_val, (f64)'B', f64_pass ? "true" : "false");
        success = success && f64_pass;

In Io.Read.c:558:

        StrReadFmt(z, "{c}", u8_val);
        bool tilde_pass = (u8_val == '~');
        WriteFmt("u8_val = {}, expected = {} (~), pass = {}\n", u8_val, '~', tilde_pass ? "true" : "false");
        success = success && tilde_pass;

In Io.Read.c:565:

        StrReadFmt(z, "{c}", u32_val);
        bool xy_pass = (ZstrCompareN((Zstr)&u32_val, "XY", 2) == 0);
        WriteFmt("u32_val partial test: comparing memory with 'XY', pass = {}\n", xy_pass ? "true" : "false");
        success = success && xy_pass;

In Io.Read.c:572:

        StrReadFmt(z, "{c}", u64_val);
        bool abc_pass = (ZstrCompareN((Zstr)&u64_val, "abc", 3) == 0);
        WriteFmt("u64_val partial test: comparing memory with 'abc', pass = {}\n", abc_pass ? "true" : "false");
        success = success && abc_pass;

In Io.Read.c:580:

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

In Io.Read.c:590:

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

In Io.Read.c:595:

        StrDeinit(&str_val);
    
        WriteFmt("Overall success: {}\n", success ? "true" : "false");
        DefaultAllocatorDeinit(&alloc);
        return success;

In Io.Read.c:601:

    
    bool test_string_case_conversion_reading(void) {
        WriteFmt("Testing string case conversion with :a and :A format specifiers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Read.c:617:

            StrReadFmt(z, "{a}", result);
    
            WriteFmt("Test 1 - :a (lowercase)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:618:

    
            WriteFmt("Test 1 - :a (lowercase)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:620:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:622:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "hello" (stops at first space)

In Io.Read.c:627:

            Str  expected   = StrInitFromZstr("hello world", &alloc);
            bool test1_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'hello', Pass: {}\n\n", test1_pass ? "true" : "false");
            success = success && test1_pass;

In Io.Read.c:642:

            StrReadFmt(z, "{as}", result);
    
            WriteFmt("Test 1.1 - :as (lowercase string single word)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:643:

    
            WriteFmt("Test 1.1 - :as (lowercase string single word)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:645:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:647:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "hello" (stops at first space)

In Io.Read.c:652:

            Str  expected   = StrInitFromZstr("hello", &alloc);
            bool test1_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'hello', Pass: {}\n\n", test1_pass ? "true" : "false");
            success = success && test1_pass;

In Io.Read.c:667:

            StrReadFmt(z, "{A}", result);
    
            WriteFmt("Test 2 - :A (uppercase)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:668:

    
            WriteFmt("Test 2 - :A (uppercase)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:670:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:672:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "HELLO" (stops at first space)

In Io.Read.c:677:

            Str  expected   = StrInitFromZstr("HELLO WORLD", &alloc);
            bool test2_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'HELLO', Pass: {}\n\n", test2_pass ? "true" : "false");
            success = success && test2_pass;

In Io.Read.c:693:

            StrReadFmt(z, "{A} {A}", result1, result2);
    
            WriteFmt("Test 2 - :A (uppercase with split format)\n");
            WriteFmt("Input: '{}', Output: '{} {}'", in, result1, result2);

In Io.Read.c:694:

    
            WriteFmt("Test 2 - :A (uppercase with split format)\n");
            WriteFmt("Input: '{}', Output: '{} {}'", in, result1, result2);
    
            bool test2_pass  = (StrCmp(&result1, "HELLO") == 0);

In Io.Read.c:698:

            bool test2_pass  = (StrCmp(&result1, "HELLO") == 0);
            test2_pass      &= (StrCmp(&result2, "WORLD") == 0);
            WriteFmt("Expected: 'HELLO WORLD', Pass: {}\n\n", test2_pass ? "true" : "false");
            success = success && test2_pass;

In Io.Read.c:716:

            // result2 must consume the space after hello and then everything after it
    
            WriteFmt("Test 2 - :A (uppercase with split format)\n");
            WriteFmt("Input: '{}', Output: '{}{}'", in, result1, result2);

In Io.Read.c:717:

    
            WriteFmt("Test 2 - :A (uppercase with split format)\n");
            WriteFmt("Input: '{}', Output: '{}{}'", in, result1, result2);
    
            bool test2_pass  = (StrCmp(&result1, "HELLO") == 0);

In Io.Read.c:721:

            bool test2_pass  = (StrCmp(&result1, "HELLO") == 0);
            test2_pass      &= (StrCmp(&result2, " WORLD MIGHTY MISRA") == 0); // notice the extra space
            WriteFmt("Expected: 'HELLO WORLD MIGHTY MISRA', Pass: {}\n\n", test2_pass ? "true" : "false");
            success = success && test2_pass;

In Io.Read.c:736:

            StrReadFmt(z, "{as}", result);
    
            WriteFmt("Test 3 - :a with quoted string\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:737:

    
            WriteFmt("Test 3 - :a with quoted string\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:739:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:741:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "mixed case" (converts the entire quoted string)

In Io.Read.c:746:

            Str  expected   = StrInitFromZstr("mixed case", &alloc);
            bool test3_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'mixed case', Pass: {}\n\n", test3_pass ? "true" : "false");
            success = success && test3_pass;

In Io.Read.c:761:

            StrReadFmt(z, "{As}", result);
    
            WriteFmt("Test 4 - :A with mixed alphanumeric\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:762:

    
            WriteFmt("Test 4 - :A with mixed alphanumeric\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:764:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:766:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "ABC123XYZ" (only letters are converted, numbers unchanged)

In Io.Read.c:771:

            Str  expected   = StrInitFromZstr("ABC123XYZ", &alloc);
            bool test4_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'ABC123XYZ', Pass: {}\n\n", test4_pass ? "true" : "false");
            success = success && test4_pass;

In Io.Read.c:786:

            StrReadFmt(z, "{c}", result);
    
            WriteFmt("Test 5 - :c (no case conversion)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {

In Io.Read.c:787:

    
            WriteFmt("Test 5 - :c (no case conversion)\n");
            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);

In Io.Read.c:789:

            WriteFmt("Input: '{}', Output: '", in);
            for (size i = 0; i < StrLen(&result); i++) {
                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");

In Io.Read.c:791:

                WriteFmt("{c}", StrBegin(&result)[i]);
            }
            WriteFmt("'\n");
    
            // Should read "Hello" (stops at first space, no case conversion)

In Io.Read.c:796:

            Str  expected   = StrInitFromZstr("Hello World", &alloc);
            bool test5_pass = (StrCmp(&result, &expected) == 0);
            WriteFmt("Expected: 'Hello World', Pass: {}\n\n", test5_pass ? "true" : "false");
            success = success && test5_pass;

In Io.Read.c:803:

        }
    
        WriteFmt("Overall case conversion success: {}\n", success ? "true" : "false");
        DefaultAllocatorDeinit(&alloc);
        return success;

In Io.Read.c:809:

    
    bool test_bitvec_reading(void) {
        WriteFmt("Testing BitVec reading\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Read.c:823:

        Str result1 = BitVecToStr(&bv1);
        success     = success && (ZstrCompare(StrBegin(&result1), "10110") == 0);
        WriteFmt(
            "Test 1 - Binary: {}, Success: {}\n",
            result1,

In Io.Read.c:836:

        u64 value2 = BitVecToInteger(&bv2);
        success    = success && (value2 == 0xDEAD);
        WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");
        BitVecDeinit(&bv2);

In Io.Read.c:844:

        u64 value3 = BitVecToInteger(&bv3);
        success    = success && (value3 == 0755);
        WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
        BitVecDeinit(&bv3);

In Io.Read.c:852:

        Str result4 = BitVecToStr(&bv4);
        success     = success && (ZstrCompare(StrBegin(&result4), "1101") == 0);
        WriteFmt(
            "Test 4 - Whitespace: {}, Success: {}\n",
            result4,

In Io.Read.c:865:

        Str result5 = BitVecToStr(&bv5);
        success     = success && (ZstrCompare(StrBegin(&result5), "0") == 0);
        WriteFmt(
            "Test 5 - Zero: {}, Success: {}\n",
            result5,

In Io.Read.c:873:

        BitVecDeinit(&bv5);
    
        WriteFmt("Overall BitVec reading success: {}\n", success ? "true" : "false");
        DefaultAllocatorDeinit(&alloc);
        return success;

In Io.Read.c:879:

    
    bool test_int_reading(void) {
        WriteFmt("Testing Int reading\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Read.c:931:

    
    bool test_float_reading(void) {
        WriteFmt("Testing Float reading\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Read.c:974:

    
    int main(void) {
        WriteFmt("[INFO] Starting format reader tests\n\n");
    
        TestFunction tests[] = {

In Dwarf.c:184:

    
    int main(void) {
        WriteFmt("[INFO] Starting Dwarf tests\n\n");
    
        TestFunction tests[] = {

In ProcMaps.c:57:

    
    int main(void) {
        WriteFmt("[INFO] Starting ProcMaps tests\n\n");
    
        TestFunction tests[] = {

In Map.Deadend.c:23:

    
    static bool test_validate_uninitialized_map_fails(void) {
        WriteFmt("Testing ValidateMap on uninitialized map\n");
    
        Map(int, int) map = {0};

In Map.Deadend.c:32:

    
    static bool test_map_contains_pair_without_value_compare_fails(void) {
        WriteFmt("Testing MapContainsPair without value comparator\n");
    
        typedef Map(int, int) IntIntMap;

In Map.Deadend.c:46:

    
    static bool test_map_remove_pair_without_value_compare_fails(void) {
        WriteFmt("Testing MapRemovePair without value comparator\n");
    
        typedef Map(int, int) IntIntMap;

In Map.Deadend.c:60:

    
    static bool test_map_remove_if_without_predicate_fails(void) {
        WriteFmt("Testing MapRemoveIf without predicate\n");
    
        typedef Map(int, int) IntIntMap;

In Map.Deadend.c:74:

    
    static bool test_map_retain_if_without_predicate_fails(void) {
        WriteFmt("Testing MapRetainIf without predicate\n");
    
        typedef Map(int, int) IntIntMap;

In Map.Deadend.c:115:

    
    static bool test_validate_map_policy_without_name_fails(void) {
        WriteFmt("Testing ValidateMapPolicy without name\n");
    
        MapPolicy policy = {

In Map.Deadend.c:131:

    
    static bool test_validate_map_policy_without_probe_limit_fails(void) {
        WriteFmt("Testing ValidateMapPolicy without probe limit\n");
    
        MapPolicy policy = {

In Map.Deadend.c:157:

        };
    
        WriteFmt("[INFO] Starting Map.Deadend tests\n\n");
        return run_test_suite(
            NULL,

In Graph.Init.c:11:

    
    static bool test_graph_reserve_clear(void) {
        WriteFmt("Testing GraphReserve and GraphClear\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Init.c:74:

    
    static bool test_graph_node_deep_copy(void) {
        WriteFmt("Testing Graph node deep-copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Init.c:99:

    
    static bool test_graph_node_owned_str_rvalue(void) {
        WriteFmt("Testing Graph node owned Str r-value insertion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Init.c:122:

    
    static bool test_graph_init_optional_allocator(void) {
        WriteFmt("Testing Graph init optional allocator\n");
    
        typedef Graph(Str) StrGraph;

In Graph.Init.c:192:

        };
    
        WriteFmt("[INFO] Starting Graph.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Graph.Init");
    }

In Float.Type.c:14:

    
    bool test_float_init(void) {
        WriteFmt("Testing FloatInit\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Type.c:30:

    
    bool test_float_clear(void) {
        WriteFmt("Testing FloatClear\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Type.c:48:

    
    bool test_float_clone(void) {
        WriteFmt("Testing FloatClone\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Type.c:72:

    
    bool test_float_clone_inherits_allocator_config(void) {
        WriteFmt("Testing FloatClone allocator inheritance\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Type.c:102:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Type tests\n\n");
    
        TestFunction tests[] = {

In Float.Convert.c:24:

    
    bool test_float_from_unsigned_integer(void) {
        WriteFmt("Testing FloatFrom with unsigned integer\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:41:

    
    bool test_float_from_signed_integer(void) {
        WriteFmt("Testing FloatFrom with signed integer\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:58:

    
    bool test_float_from_int_container(void) {
        WriteFmt("Testing FloatFrom with Int container\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:76:

    
    bool test_float_to_int_exact(void) {
        WriteFmt("Testing FloatToInt exact conversion\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:96:

    
    bool test_float_to_int_fractional_failure(void) {
        WriteFmt("Testing FloatToInt fractional failure handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:113:

    
    bool test_float_to_int_negative_failure(void) {
        WriteFmt("Testing FloatToInt negative failure handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:130:

    
    bool test_float_string_round_trip(void) {
        WriteFmt("Testing Float string round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:146:

    
    bool test_float_try_to_str_allocator_inheritance(void) {
        WriteFmt("Testing FloatTryToStr allocator behavior\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:173:

    
    bool test_float_very_large_string_round_trip(void) {
        WriteFmt("Testing Float very large string round trip\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:189:

    
    bool test_float_scientific_parse(void) {
        WriteFmt("Testing Float scientific parsing\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:205:

    
    bool test_float_from_str_invalid(void) {
        WriteFmt("Testing FloatFromStr invalid format handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:223:

    
    bool test_float_from_str_null(void) {
        WriteFmt("Testing FloatFromStr NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Convert.c:241:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Convert tests\n\n");
    
        TestFunction tests[] = {

In Io.Write.c:31:

    
    bool test_basic_formatting(void) {
        WriteFmt("Testing basic formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:59:

    
    bool test_string_formatting(void) {
        WriteFmt("Testing string formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:99:

    
    bool test_integer_decimal_formatting(void) {
        WriteFmt("Testing integer decimal formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:171:

    
    bool test_integer_hex_formatting(void) {
        WriteFmt("Testing integer hexadecimal formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:192:

    
    bool test_integer_binary_formatting(void) {
        WriteFmt("Testing integer binary formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:209:

    
    bool test_integer_octal_formatting(void) {
        WriteFmt("Testing integer octal formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:226:

    
    bool test_float_basic_formatting(void) {
        WriteFmt("Testing basic floating point formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:248:

    
    bool test_float_precision_formatting(void) {
        WriteFmt("Testing floating point precision formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:274:

    
    bool test_float_special_values(void) {
        WriteFmt("Testing special floating point values\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:301:

    
    bool test_width_alignment_formatting(void) {
        WriteFmt("Testing width and alignment formatting\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:339:

    
    bool test_multiple_arguments(void) {
        WriteFmt("Testing multiple arguments\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:363:

    
    bool test_char_formatting(void) {
        WriteFmt("Testing character formatting specifiers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Io.Write.c:522:

    
    bool test_bitvec_formatting(void) {
        WriteFmt("Testing BitVec formatting\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Write.c:586:

    
    bool test_int_formatting(void) {
        WriteFmt("Testing Int formatting\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Write.c:632:

    
    bool test_float_formatting(void) {
        WriteFmt("Testing Float formatting\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In Io.Write.c:710:

    
    int main(void) {
        WriteFmt("[INFO] Starting format writer tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Math.c:54:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecHammingDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:99:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecHammingDistance edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:132:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecJaccardSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:184:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecJaccardSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:213:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCosineSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:251:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCosineSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:284:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDotProduct basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:324:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDotProduct edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:354:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEditDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:401:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEditDistance edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:432:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCorrelation basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:471:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCorrelation edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:502:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEntropy basic functionality\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:534:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEntropy edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:557:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAlignmentScore basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:593:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAlignmentScore edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:623:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecBestAlignment basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:656:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecBestAlignment edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:684:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec Math stress tests\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:739:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecHammingDistance(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:751:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecHammingDistance(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:763:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecJaccardSimilarity(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:775:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecJaccardSimilarity(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:787:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCosineSimilarity(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:799:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCosineSimilarity(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:811:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDotProduct(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:823:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDotProduct(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:835:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEditDistance(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:847:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEditDistance(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:859:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCorrelation(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:871:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCorrelation(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:881:

    
    bool test_bitvec_entropy_null(void) {
        WriteFmt("Testing BitVecEntropy(NULL) - should fatal\n");
        BitVecEntropy(NULL);
        return true;

In BitVec.Math.c:889:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAlignmentScore(NULL, bv2, 1, -1) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:901:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAlignmentScore(bv1, NULL, 1, -1) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:913:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecBestAlignment(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Math.c:925:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecBestAlignment(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.Math.c:936:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Math tests\n\n");
    
        // Array of normal test functions

In StrippedResolve.c:75:

            // The static marker shouldn't be in .dynsym; if we got a name,
            // either the toolchain exported it or the strip didn't take.
            WriteFmt("[INFO] unexpected ELF symbol hit for static helper: {}\n", sym->name);
        }

In StrippedResolve.c:102:

    int main(int argc, char **argv) {
        if (argc < 2) {
            WriteFmt("usage: {} <path-to-stripped-binary>\n", argv[0]);
            return 1;
        }

In StrippedResolve.c:107:

        stripped_path_arg = argv[1];
    
        WriteFmt("[INFO] Stripped-binary resolve test against: {}\n\n", stripped_path_arg);
    
        TestFunction tests[] = {

In List.Access.c:30:

    
    static bool test_list_len_empty(void) {
        WriteFmt("Testing ListLen and ListEmpty\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Access.c:60:

    
    static bool test_list_value_access_and_swap(void) {
        WriteFmt("Testing List accessors and swap\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Access.c:90:

    
    static bool test_list_node_access_and_navigation(void) {
        WriteFmt("Testing List node access and navigation\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Access.c:134:

    
    static bool test_list_find_contains(void) {
        WriteFmt("Testing ListFind and ListContains\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Access.c:169:

        };
    
        WriteFmt("[INFO] Starting List.Access tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Access");
    }

In BitVec.Access.Deadend.c:28:

    // Deadend tests - testing NULL pointers and invalid conditions that should cause fatal errors
    bool test_bitvec_find_deadend_tests(void) {
        WriteFmt("Testing BitVecFind deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.Deadend.c:37:

    
    bool test_bitvec_predicate_deadend_tests(void) {
        WriteFmt("Testing BitVec predicate deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.Deadend.c:46:

    
    bool test_bitvec_longest_run_deadend_tests(void) {
        WriteFmt("Testing BitVecLongestRun deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.Deadend.c:56:

    // Deadend tests
    bool test_bitvec_access_null_failures(void) {
        WriteFmt("Testing BitVec access NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.Deadend.c:65:

    
    bool test_bitvec_set_null_failures(void) {
        WriteFmt("Testing BitVec set NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.Deadend.c:74:

    
    bool test_bitvec_flip_null_failures(void) {
        WriteFmt("Testing BitVec flip NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.Deadend.c:85:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:100:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:115:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec flip bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:131:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:149:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:166:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:182:

    
    bool test_bitvec_count_null_failures(void) {
        WriteFmt("Testing BitVec count operations with NULL pointer\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.Deadend.c:193:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get with maximum index value\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Deadend.c:208:

    // Main function that runs all deadend tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Access.Deadend tests\n\n");
    
        // Deadend tests that would cause program termination

In Str.Insert.c:29:

    // Test StrInsertR function
    bool test_str_insert_char_at(void) {
        WriteFmt("Testing StrInsertR\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:60:

    // Test StrInsertMany 4-arg (Cstr) form
    bool test_str_insert_cstr(void) {
        WriteFmt("Testing StrInsertMany (Cstr form)\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:79:

    // Test StrInsertMany 3-arg Zstr form
    bool test_str_insert_zstr(void) {
        WriteFmt("Testing StrInsertMany (Zstr form)\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:99:

    // Test StrInsertMany function
    bool test_str_push_cstr(void) {
        WriteFmt("Testing StrInsertMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:118:

    // Test StrInsertMany function
    bool test_str_push_zstr(void) {
        WriteFmt("Testing StrInsertMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:137:

    // Test StrPushBackMany function
    bool test_str_push_back_cstr(void) {
        WriteFmt("Testing StrPushBackMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:156:

    // Test StrPushBackMany function
    bool test_str_push_back_zstr(void) {
        WriteFmt("Testing StrPushBackMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:175:

    // Test StrPushFrontMany function
    bool test_str_push_front_cstr(void) {
        WriteFmt("Testing StrPushFrontMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:194:

    // Test StrPushFrontMany function
    bool test_str_push_front_zstr(void) {
        WriteFmt("Testing StrPushFrontMany\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:213:

    // Test StrPushBack function
    bool test_str_push_back(void) {
        WriteFmt("Testing StrPushBack\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:237:

    // Test StrPushFront function
    bool test_str_push_front(void) {
        WriteFmt("Testing StrPushFront\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:261:

    // Test StrMergeL function
    bool test_str_merge_l(void) {
        WriteFmt("Testing StrMergeL\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:289:

    // Test StrMergeR function
    bool test_str_merge_r(void) {
        WriteFmt("Testing StrMergeR\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:313:

    // Test StrMerge function (unsuffixed = L-form per convention; src zeroed).
    bool test_str_merge(void) {
        WriteFmt("Testing StrMerge\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:338:

    // StrAppendf formatter.
    bool test_str_write_fmt_append(void) {
        WriteFmt("Testing StrAppendFmt append\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Insert.c:357:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Insert tests\n\n");
    
        // Array of test functions

In Float.Math.c:26:

    
    bool test_float_negate_abs(void) {
        WriteFmt("Testing FloatNegate and FloatAbs\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:50:

    
    bool test_float_add_small_small(void) {
        WriteFmt("Testing FloatAdd with small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:73:

    
    bool test_float_add_very_large_large(void) {
        WriteFmt("Testing FloatAdd with very large floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:96:

    
    bool test_float_add_generic(void) {
        WriteFmt("Testing FloatAdd generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:145:

    
    bool test_float_sub_small_small(void) {
        WriteFmt("Testing FloatSub with small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:168:

    
    bool test_float_sub_very_large_large(void) {
        WriteFmt("Testing FloatSub with very large floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:191:

    
    bool test_float_sub_generic(void) {
        WriteFmt("Testing FloatSub generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:235:

    
    bool test_float_mul_small_small(void) {
        WriteFmt("Testing FloatMul with small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:258:

    
    bool test_float_mul_very_large_small(void) {
        WriteFmt("Testing FloatMul with very large and small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:281:

    
    bool test_float_mul_generic(void) {
        WriteFmt("Testing FloatMul generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:325:

    
    bool test_float_div_small_small(void) {
        WriteFmt("Testing FloatDiv with small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:348:

    
    bool test_float_div_very_large_small(void) {
        WriteFmt("Testing FloatDiv with very large and small floats\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:371:

    
    bool test_float_div_generic(void) {
        WriteFmt("Testing FloatDiv generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:420:

    
    bool test_float_div_by_zero(void) {
        WriteFmt("Testing FloatDiv divide-by-zero handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Math.c:440:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Math tests\n\n");
    
        TestFunction tests[] = {

In Vec.Init.c:45:

    // Test basic vector initialization
    bool test_vec_init_basic(void) {
        WriteFmt("Testing VecInit\n");
    
        // Test with int type

In Vec.Init.c:76:

    // Test aligned vector initialization
    bool test_vec_init_aligned(void) {
        WriteFmt("Testing VecInit with aligned allocator\n");
    
        HeapAllocator aligned4  = HeapAllocatorInitAligned(4);

In Vec.Init.c:112:

    // Test vector initialization with deep copy functions
    bool test_vec_init_with_deep_copy(void) {
        WriteFmt("Testing VecInitWithDeepCopy\n");
    
        // Test with struct type and custom copy/deinit functions

In Vec.Init.c:132:

    // Test vector initialization with alignment and deep copy functions
    bool test_vec_init_aligned_with_deep_copy(void) {
        WriteFmt("Testing VecInit with aligned allocator and deep copy\n");
    
        HeapAllocator aligned8 = HeapAllocatorInitAligned(8);

In Vec.Init.c:155:

    // Test vector initialization variants with an explicit optional allocator
    bool test_vec_init_optional_allocator(void) {
        WriteFmt("Testing VecInit optional allocator\n");
    
        typedef Vec(TestItem) TestVec;

In Vec.Init.c:211:

    // Test vector stack initialization
    bool test_vec_init_stack(void) {
        WriteFmt("Testing VecInitStack\n");
    
        bool result = true;

In Vec.Init.c:283:

    // Test vector clone initialization
    bool test_vec_init_clone(void) {
        WriteFmt("Testing vector cloning\n");
    
        // Create a source vector

In Vec.Init.c:324:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Vec.Init tests\n\n");
    
        alloc = DefaultAllocatorInit();

In Vec.Memory.c:17:

    // Test VecTryReduceSpace function
    bool test_vec_try_reduce_space(void) {
        WriteFmt("Testing VecTryReduceSpace\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Memory.c:57:

    // Test VecResize function
    bool test_vec_resize(void) {
        WriteFmt("Testing VecResize\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Memory.c:105:

    // Test VecReserve function
    bool test_vec_reserve(void) {
        WriteFmt("Testing VecReserve\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Memory.c:152:

    // Test VecClear function
    bool test_vec_clear(void) {
        WriteFmt("Testing VecClear\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Memory.c:193:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Vec.Memory tests\n\n");
    
        // Array of test functions

In BitVec.BitWise.Deadend.c:23:

    // Deadend tests
    bool test_bitvec_bitwise_null_failures(void) {
        WriteFmt("Testing BitVec bitwise NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.BitWise.Deadend.c:34:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bitwise operations NULL handling\n");
    
        BitVec bv  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:49:

    
    bool test_bitvec_reverse_null_failures(void) {
        WriteFmt("Testing BitVec reverse NULL handling\n");
    
        // Test NULL pointer - should abort

In BitVec.BitWise.Deadend.c:59:

    // NEW: Additional deadend tests
    bool test_bitvec_shift_ops_null_failures(void) {
        WriteFmt("Testing BitVec shift operations NULL handling\n");
    
        // Test NULL pointer for shift right - should abort

In BitVec.BitWise.Deadend.c:68:

    
    bool test_bitvec_rotate_ops_null_failures(void) {
        WriteFmt("Testing BitVec rotate operations NULL handling\n");
    
        // Test NULL pointer for rotate - should abort

In BitVec.BitWise.Deadend.c:79:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec AND with NULL result handling\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:98:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec OR with NULL operand handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:115:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec XOR with NULL second operand handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:132:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec NOT with NULL handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:146:

    // Main function that runs all deadend tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.BitWise.Deadend tests\n\n");
    
        // Array of deadend test functions

In Map.Remove.c:140:

        };
    
        WriteFmt("[INFO] Starting Map.Remove tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Remove");
    }

In Int.Compare.c:17:

    
    bool test_int_compare(void) {
        WriteFmt("Testing IntCompare\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:37:

    
    bool test_int_compare_wrappers(void) {
        WriteFmt("Testing Int compare wrappers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:62:

    
    bool test_int_compare_generic(void) {
        WriteFmt("Testing IntCompare generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:93:

    // Same magnitude built two ways must hash to the same bucket.
    bool test_int_hash_determinism(void) {
        WriteFmt("Testing int_hash determinism\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:117:

    // over a handful of small distinct inputs should not clash here.
    bool test_int_hash_distinguishes(void) {
        WriteFmt("Testing int_hash distinguishes distinct values\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:152:

    // GenericHash / GenericCompare-shaped helpers wire in directly.
    bool test_int_hash_as_map_key(void) {
        WriteFmt("Testing int_hash as Map<Int,u64> key\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Compare.c:185:

    
    int main(void) {
        WriteFmt("[INFO] Starting Int.Compare tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Access.Simple.c:36:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:59:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:83:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:112:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLength and BitVecCapacity\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:141:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCount operations\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:164:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:189:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:211:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:233:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCount edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:264:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec multiple access operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:304:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec access with large patterns\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:342:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec macro functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:375:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec access stress test\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:428:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive bit patterns\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:485:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFind functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:522:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec predicate functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:572:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:612:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFind edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:647:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec predicate edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:690:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:724:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Access.Simple tests\n\n");
    
        // Array of test functions

In Vec.Remove.c:264:

    
        // Print before state
        WriteFmt("Before fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:266:

        WriteFmt("Before fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:268:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Test VecDeleteRangeFast - delete 3 elements starting at index 2

In Vec.Remove.c:283:

    
        // Print after state
        WriteFmt("After fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:285:

        WriteFmt("After fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:287:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Check length after deletion

In Vec.Remove.c:457:

    
        // Print before state
        WriteFmt("Before L-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:459:

        WriteFmt("Before L-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:461:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Test L-value fast delete operation

In Vec.Remove.c:470:

    
        // Print after state
        WriteFmt("After L-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:472:

        WriteFmt("After L-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:474:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Check vector after L-value fast deletion

In Vec.Remove.c:538:

    
        // Print before state
        WriteFmt("Before R-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:540:

        WriteFmt("Before R-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:542:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Remember the value to be deleted and the last value

In Vec.Remove.c:552:

    
        // Print after state
        WriteFmt("After R-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:554:

        WriteFmt("After R-value fast delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:556:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Check length

In Vec.Remove.c:687:

    
        // Print before state
        WriteFmt("Before L-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:689:

        WriteFmt("Before L-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:691:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Values that should be deleted (30, 40, 50)

In Vec.Remove.c:702:

    
        // Print after state
        WriteFmt("After L-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:704:

        WriteFmt("After L-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:706:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Check vector after L-value fast range deletion

In Vec.Remove.c:766:

    
        // Print before state
        WriteFmt("Before R-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:768:

        WriteFmt("Before R-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:770:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Values that should be deleted (30, 40, 50)

In Vec.Remove.c:779:

    
        // Print after state
        WriteFmt("After R-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));

In Vec.Remove.c:781:

        WriteFmt("After R-value fast range delete: ");
        for (u64 i = 0; i < VecLen(&vec); i++) {
            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");

In Vec.Remove.c:783:

            WriteFmt("{} ", VecAt(&vec, i));
        }
        WriteFmt("\n");
    
        // Check vector after R-value fast range deletion

In List.Remove.c:45:

    
    static bool test_list_remove_and_pop(void) {
        WriteFmt("Testing ListRemove and pop helpers\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:78:

    
    static bool test_list_remove_range_and_delete_aliases(void) {
        WriteFmt("Testing ListRemoveRange and delete aliases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:112:

    
    static bool test_list_remove_range_prefix_suffix_edges(void) {
        WriteFmt("Testing ListRemoveRange prefix/suffix edges\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:144:

    
    static bool test_list_remove_range_whole_list_to_buffer(void) {
        WriteFmt("Testing ListRemoveRange whole-list buffered removal\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:166:

    
    static bool test_list_remove_zero_count_and_deep_copy_delete(void) {
        WriteFmt("Testing ListRemoveRange zero-count and deep-copy delete\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:205:

    
    static bool test_list_remove_range_with_deep_copy_buffer(void) {
        WriteFmt("Testing ListRemoveRange buffer semantics with deep copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Remove.c:241:

        };
    
        WriteFmt("[INFO] Starting List.Remove tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Remove");
    }

In Float.Access.c:12:

    
    bool test_float_is_zero(void) {
        WriteFmt("Testing FloatIsZero\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Access.c:29:

    
    bool test_float_is_negative(void) {
        WriteFmt("Testing FloatIsNegative\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Access.c:49:

    
    bool test_float_exponent(void) {
        WriteFmt("Testing FloatExponent\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Float.Access.c:63:

    
    int main(void) {
        WriteFmt("[INFO] Starting Float.Access tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Init.c:26:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInit\n");
    
        // Test basic initialization

In BitVec.Init.c:49:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDeinit\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:81:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:118:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecClear\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:157:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecResize\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:202:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInit edge cases\n");
    
        // Test multiple initializations

In BitVec.Init.c:225:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:256:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReu64 edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:295:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecClear edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:329:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec multiple init/deinit cycles\n");
    
        bool result = true;

In BitVec.Init.c:353:

    // Deadend tests - verify expected failures occur gracefully
    bool test_bitvec_null_pointer_failures(void) {
        WriteFmt("Testing BitVec NULL pointer handling\n");
    
        // Test NULL pointer passed to functions that should validate

In BitVec.Init.c:368:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec invalid operations\n");
    
        // BitVecReserve is now a fallible API that returns bool on allocation

In BitVec.Init.c:386:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set operations on invalid indices\n");
    
        // BitVecResize is now a fallible API that returns bool on allocation

In BitVec.Init.c:403:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Init tests\n\n");
    
        // Array of normal test functions

In BitVec.Foreach.Simple.c:39:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:76:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeach macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:111:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachReverseIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:146:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachReverse macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:180:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachInRangeIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:220:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachInRange macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:259:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:302:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach idx edge cases\n");
    
        BitVec bv       = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:344:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach reverse edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:385:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach range edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:435:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach stress test\n");
    
        bool result = true;

In BitVec.Foreach.Simple.c:485:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths basic functionality\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:527:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        WriteFmt("Testing BitVecRunLengths Vec form\n");
    
        BitVec bv = BitVecInit(base);

In BitVec.Foreach.Simple.c:559:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths edge cases\n");
    
        bool result = true;

In BitVec.Foreach.Simple.c:621:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths boundary conditions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.Simple.c:661:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths stress test\n");
    
        bool result = true;

In BitVec.Foreach.Simple.c:725:

    // Main function that runs all simple tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Foreach.Simple tests\n\n");
    
        // Array of normal test functions

In Int.Math.c:63:

    
    bool test_int_shift_left_grows(void) {
        WriteFmt("Testing IntShiftLeft\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:80:

    
    bool test_int_shift_right_shrinks(void) {
        WriteFmt("Testing IntShiftRight\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:97:

    
    bool test_int_add(void) {
        WriteFmt("Testing IntAdd\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:121:

    
    bool test_int_add_generic(void) {
        WriteFmt("Testing IntAdd generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:154:

    
    bool test_int_sub(void) {
        WriteFmt("Testing IntSub\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:173:

    
    bool test_int_sub_generic(void) {
        WriteFmt("Testing IntSub generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:211:

    
    bool test_int_sub_underflow_preserves_result(void) {
        WriteFmt("Testing IntSub underflow handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:230:

    
    bool test_int_mul(void) {
        WriteFmt("Testing IntMul\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:250:

    
    bool test_int_mul_scalar(void) {
        WriteFmt("Testing IntMul generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:271:

    
    bool test_int_mul_zero(void) {
        WriteFmt("Testing IntMul with zero\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:292:

    
    bool test_int_square(void) {
        WriteFmt("Testing IntSquare\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:310:

    
    bool test_int_pow_generic(void) {
        WriteFmt("Testing IntPow generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:337:

    
    bool test_int_div_mod(void) {
        WriteFmt("Testing IntDivMod generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:361:

    
    bool test_int_div(void) {
        WriteFmt("Testing IntDiv generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:379:

    
    bool test_int_div_exact(void) {
        WriteFmt("Testing IntDivExact generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:399:

    
    bool test_int_div_exact_failure_preserves_result(void) {
        WriteFmt("Testing IntDivExact failure handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:418:

    
    bool test_int_div_mod_scalar(void) {
        WriteFmt("Testing IntDivMod scalar-divisor dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:442:

    
    bool test_int_mod(void) {
        WriteFmt("Testing IntMod generic dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:460:

    
    bool test_int_mod_scalar(void) {
        WriteFmt("Testing IntMod scalar-divisor dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:477:

    
    bool test_int_gcd(void) {
        WriteFmt("Testing IntGCD\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:497:

    
    bool test_int_lcm(void) {
        WriteFmt("Testing IntLCM\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:517:

    
    bool test_int_root(void) {
        WriteFmt("Testing IntRoot\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:535:

    
    bool test_int_root_rem(void) {
        WriteFmt("Testing IntRootRem\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:556:

    
    bool test_int_sqrt(void) {
        WriteFmt("Testing IntSqrt\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:574:

    
    bool test_int_sqrt_rem(void) {
        WriteFmt("Testing IntSqrtRem\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:595:

    
    bool test_int_is_perfect_square(void) {
        WriteFmt("Testing IntIsPerfectSquare\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:612:

    
    bool test_int_is_perfect_power(void) {
        WriteFmt("Testing IntIsPerfectPower\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:632:

    
    bool test_int_jacobi(void) {
        WriteFmt("Testing IntJacobi\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:653:

    
    bool test_int_square_mod(void) {
        WriteFmt("Testing IntSquareMod\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:673:

    
    bool test_int_mod_add(void) {
        WriteFmt("Testing IntModAdd\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:695:

    
    bool test_int_mod_sub(void) {
        WriteFmt("Testing IntModSub\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:717:

    
    bool test_int_mod_mul(void) {
        WriteFmt("Testing IntModMul\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:739:

    
    bool test_int_mod_div(void) {
        WriteFmt("Testing IntModDiv\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:765:

    
    bool test_int_pow_mod_scalar(void) {
        WriteFmt("Testing IntPowMod scalar-exponent dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:785:

    
    bool test_int_pow_mod_integer_exponent(void) {
        WriteFmt("Testing IntPowMod Int-exponent dispatch\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:807:

    
    bool test_int_mod_inv(void) {
        WriteFmt("Testing IntModInv\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:831:

    
    bool test_int_mod_sqrt(void) {
        WriteFmt("Testing IntModSqrt\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:853:

    
    bool test_int_mod_sqrt_no_solution(void) {
        WriteFmt("Testing IntModSqrt no-solution case\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:872:

    
    bool test_int_is_probable_prime(void) {
        WriteFmt("Testing IntIsProbablePrime\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:889:

    
    bool test_int_next_prime(void) {
        WriteFmt("Testing IntNextPrime\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:910:

    
    bool test_int_mod_inv_no_solution(void) {
        WriteFmt("Testing IntModInv no-solution case\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:929:

    
    bool test_int_mod_div_no_solution(void) {
        WriteFmt("Testing IntModDiv no-solution case\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:950:

    
    bool test_int_add_null_result(void) {
        WriteFmt("Testing IntAdd NULL result handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:963:

    
    bool test_int_shift_left_null(void) {
        WriteFmt("Testing IntShiftLeft NULL handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:973:

    
    bool test_int_div_by_zero(void) {
        WriteFmt("Testing Int division by zero handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:996:

    
    bool test_int_root_zero_degree(void) {
        WriteFmt("Testing IntRoot zero-degree handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1016:

    
    bool test_int_div_scalar_zero_divisor(void) {
        WriteFmt("Testing IntDiv scalar zero-divisor handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1033:

    
    bool test_int_mod_scalar_zero_modulus(void) {
        WriteFmt("Testing IntMod scalar zero-modulus handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1050:

    
    bool test_int_mod_div_zero_modulus(void) {
        WriteFmt("Testing IntModDiv zero modulus handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1071:

    
    bool test_int_jacobi_even_denominator(void) {
        WriteFmt("Testing IntJacobi even denominator handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1092:

    
    bool test_int_pow_mod_scalar_zero_modulus(void) {
        WriteFmt("Testing IntPowMod scalar-exponent zero modulus handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1106:

    
    bool test_int_pow_mod_integer_zero_modulus(void) {
        WriteFmt("Testing IntPowMod Int-exponent zero modulus handling\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Int.Math.c:1127:

    
    int main(void) {
        WriteFmt("[INFO] Starting Int.Math tests\n\n");
    
        TestFunction tests[] = {

In Map.Access.c:172:

        };
    
        WriteFmt("[INFO] Starting Map.Access tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Access");
    }

In File.c:31:

    
    bool test_file_read_into_str(void) {
        WriteFmt("Testing FileRead into Str (whole-file load)\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In File.c:65:

    
    bool test_file_read_grows_str(void) {
        WriteFmt("Testing FileRead grows the Str backing buffer\n");
    
        DefaultAllocator alloc      = DefaultAllocatorInit();

In File.c:100:

    
    int main(void) {
        WriteFmt("[INFO] Starting File tests\n\n");
    
        TestFunction tests[] = {

In Str.Type.c:22:

    // Test Str type definition
    bool test_str_type(void) {
        WriteFmt("Testing Str type definition\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:45:

    // Test Strs type definition
    bool test_strs_type(void) {
        WriteFmt("Testing Strs type definition\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:78:

    // Test ValidateStr macro
    bool test_validate_str(void) {
        WriteFmt("Testing ValidateStr macro\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:101:

    // Test ValidateStrs macro
    bool test_validate_strs(void) {
        WriteFmt("Testing ValidateStrs macro\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:123:

    // Deadend test: Test ValidateStr with invalid string (should crash/abort)
    bool test_validate_invalid_str(void) {
        WriteFmt("Testing ValidateStr with invalid string (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:151:

    // Deadend test: Test ValidateStrs with invalid Strs (should crash/abort)
    bool test_validate_invalid_strs(void) {
        WriteFmt("Testing ValidateStrs with invalid Strs (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Type.c:178:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Type tests\n\n");
    
        // Array of normal test functions

In BitVec.Remove.c:30:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecPop\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:68:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemove (single bit)\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:108:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveRange\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:141:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveFirst\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:182:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveLast\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:224:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveAll\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:265:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecPop edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:293:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemove edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:321:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveRange edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:354:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveFirst/Last edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:393:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRemoveAll edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:430:

    // Deadend tests
    bool test_bitvec_remove_null_failures(void) {
        WriteFmt("Testing BitVec remove NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Remove.c:439:

    
    bool test_bitvec_remove_range_null_failures(void) {
        WriteFmt("Testing BitVec remove range NULL handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Remove.c:450:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec remove invalid range handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:465:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec pop bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:480:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec remove bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:495:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec remove range bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Remove.c:509:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Remove tests\n\n");
    
        // Array of normal test functions

In Graph.Insert.c:8:

    
    static bool test_graph_add_node_semantics(void) {
        WriteFmt("Testing GraphAddNode semantics\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Insert.c:31:

    
    static bool test_graph_add_edge_dedup(void) {
        WriteFmt("Testing GraphAddEdge deduplication\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Insert.c:61:

    
    static bool test_graph_self_loop_and_predecessor_order(void) {
        WriteFmt("Testing Graph self-loop handling and predecessor order\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Insert.c:96:

        };
    
        WriteFmt("[INFO] Starting Graph.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Graph.Insert");
    }

In Iter.Deadend.c:54:

    
    int main(void) {
        WriteFmt("[INFO] Starting Iter.Deadend tests\n\n");
        TestFunction tests[] = {
            deadend_must_read_eof,

In Vec.Complex.c:179:

    
    bool test_complex_vec_init(void) {
        WriteFmt("Testing vector initialization with complex structure\n");
    
        // Create a vector of ComplexItem with deep copy functions

In Vec.Complex.c:222:

    // Test push operations with complex structure
    bool test_complex_vec_push(void) {
        WriteFmt("Testing push operations with complex structure\n");
    
        // Create a vector of ComplexItem with deep copy functions

In Vec.Complex.c:266:

    // Test insert operations with complex structure
    bool test_complex_vec_insert(void) {
        WriteFmt("Testing insert operations with complex structure\n");
    
        // Create a vector of ComplexItem with deep copy functions

In Vec.Complex.c:309:

    // Test merge operations with complex structure
    bool test_complex_vec_merge(void) {
        WriteFmt("Testing merge operations with complex structure\n");
    
        // Create two vectors of ComplexItem with deep copy functions

In Vec.Complex.c:387:

    // Test L-value operations
    bool test_lvalue_operations(void) {
        WriteFmt("Testing L-value operations\n");
    
        // Create a vector of integers

In Vec.Complex.c:435:

    // Test fast operations
    bool test_fast_operations(void) {
        WriteFmt("Testing fast operations\n");
    
        // Create a vector of integers

In Vec.Complex.c:512:

    // Test delete operations
    bool test_delete_operations(void) {
        WriteFmt("Testing delete operations\n");
    
        // Create a vector of integers

In Vec.Complex.c:603:

    // Test edge cases
    bool test_edge_cases(void) {
        WriteFmt("Testing edge cases\n");
    
        // Create a vector of integers

In Vec.Complex.c:665:

    // Test VecPushBackL zero-on-take behavior with complex structures
    bool test_lvalue_zero_on_take_pushback(void) {
        WriteFmt("Testing VecPushBackL zero-on-take with complex structures\n");
    
        // Create a test item

In Vec.Complex.c:691:

    // Test VecInsertL zero-on-take behavior with complex structures
    bool test_lvalue_zero_on_take_insert(void) {
        WriteFmt("Testing VecInsertL zero-on-take with complex structures\n");
    
        // Create a test item

In Vec.Complex.c:726:

    // Test VecInsertFastL zero-on-take behavior with complex structures
    bool test_lvalue_zero_on_take_fast_insert(void) {
        WriteFmt("Testing VecInsertFastL zero-on-take with complex structures\n");
        bool result = true;

In Vec.Complex.c:792:

    // Test VecPushFrontL zero-on-take behavior with complex structures
    bool test_lvalue_zero_on_take_pushfront(void) {
        WriteFmt("Testing VecPushFrontL zero-on-take with complex structures\n");
    
        // Create a test item

In Vec.Complex.c:823:

    // Test VecMergeL zero-on-take behavior with complex structures
    bool test_lvalue_zero_on_take_merge(void) {
        WriteFmt("Testing VecMergeL zero-on-take with complex structures\n");
    
        // Create a vector with no copy_init but with copy_deinit for proper cleanup

In Vec.Complex.c:861:

    // Test array operations with L-value semantics
    bool test_lvalue_zero_on_take_array_ops(void) {
        WriteFmt("Testing array operations with L-value semantics\n");
    
        // Create a vector with no copy_init but with copy_deinit for proper cleanup

In Vec.Complex.c:899:

    int main(void) {
        alloc = DefaultAllocatorInit();
        WriteFmt("[INFO] Starting Vec.Complex tests\n\n");
    
        // Array of test functions

In BitVec.Convert.c:37:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecToStr\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:71:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFromStr\n");
    
        // Convert from string

In BitVec.Convert.c:102:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecToBytes\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:138:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFromBytes\n");
    
        // Create byte array

In BitVec.Convert.c:175:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecToInteger\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:215:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFromInteger\n");
    
        // Convert from integer

In BitVec.Convert.c:264:

    
    bool test_bitvec_try_conversion_allocators(void) {
        WriteFmt("Testing BitVec try conversion allocator behavior\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Convert.c:293:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec convert edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:327:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFromStr edge cases\n");
    
        bool result = true;

In BitVec.Convert.c:363:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bytes conversion edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:393:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec integer conversion edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:421:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec round-trip conversions\n");
    
        bool result = true;

In BitVec.Convert.c:484:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec conversion bounds checking\n");
    
        bool result = true;

In BitVec.Convert.c:533:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive conversion validation\n");
    
        bool result = true;

In BitVec.Convert.c:605:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec large-scale conversions\n");
    
        bool result = true;

In BitVec.Convert.c:692:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bytes bounds failures\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Convert.c:717:

    
    bool test_bitvec_integer_bounds_failures(void) {
        WriteFmt("Testing BitVec integer bounds failures\n");
    
        // Test BitVecToInteger with NULL pointer - should abort

In BitVec.Convert.c:730:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec convert NULL pointer handling\n");
    
        // Use the explicit-allocator form so the NULL bitvec reaches the

In BitVec.Convert.c:745:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec from string NULL handling\n");
    
        // Test NULL string - should abort

In BitVec.Convert.c:758:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec bytes NULL handling\n");
    
        // Test NULL bytes - should abort

In BitVec.Convert.c:770:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Convert tests\n\n");
    
        // Array of normal test functions

In BitVec.Foreach.c:38:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:75:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeach macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:110:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachReverseIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:145:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachReverse macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:179:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachInRangeIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:219:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecForeachInRange macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:258:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:301:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach idx edge cases\n");
    
        BitVec bv       = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:343:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach reverse edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:384:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach range edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:434:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec foreach stress test\n");
    
        bool result = true;

In BitVec.Foreach.c:484:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths basic functionality\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:523:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths edge cases\n");
    
        bool result = true;

In BitVec.Foreach.c:585:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths boundary conditions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:625:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths stress test\n");
    
        bool result = true;

In BitVec.Foreach.c:690:

    
    bool test_bitvec_run_lengths_null_bv(void) {
        WriteFmt("Testing BitVecRunLengths with NULL bitvector\n");
    
        u64  runs[5];

In BitVec.Foreach.c:704:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with NULL runs array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:721:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with NULL values array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:738:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRunLengths with zero max_runs\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Foreach.c:758:

    
    bool test_bitvec_foreach_invalid_usage(void) {
        WriteFmt("Testing BitVec foreach with invalid bitvec\n");
    
        // Test foreach with invalid bitvec (length > 0 but data is NULL)

In BitVec.Foreach.c:778:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Foreach tests\n\n");
    
        // Array of normal test functions

In Map.Init.c:144:

        };
    
        WriteFmt("[INFO] Starting Map.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Init");
    }

In Graph.Foreach.c:78:

    
    static bool test_graph_city_reachability(void) {
        WriteFmt("Testing GraphForeachNode and GraphNodeForeachNeighbor for reachability\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:131:

    
    static bool test_graph_foreach_with_external_map_counts(void) {
        WriteFmt("Testing nested foreach with external count tracking map\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:171:

    
    static bool test_graph_foreach_predecessors(void) {
        WriteFmt("Testing GraphNodeForeachPredecessor\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:207:

    
    static bool test_graph_node_iteration_rejects_structural_mutation_deadend(void) {
        WriteFmt("Testing GraphForeachNode rejects structural mutation (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:228:

    
    static bool test_graph_neighbor_iteration_rejects_structural_mutation_deadend(void) {
        WriteFmt("Testing GraphNodeForeachNeighbor rejects structural mutation (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:252:

    
    static bool test_graph_predecessor_iteration_rejects_structural_mutation_deadend(void) {
        WriteFmt("Testing GraphNodeForeachPredecessor rejects structural mutation (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Foreach.c:289:

        };
    
        WriteFmt("[INFO] Starting Graph.Foreach tests\n\n");
        return run_test_suite(
            tests,

In Vec.Access.c:26:

    // Test VecAt function
    bool test_vec_at(void) {
        WriteFmt("Testing VecAt\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Access.c:61:

    // Test VecPtrAt function
    bool test_vec_ptr_at(void) {
        WriteFmt("Testing VecPtrAt\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Access.c:101:

    // Test VecFirst and VecLast functions
    bool test_vec_first_last(void) {
        WriteFmt("Testing VecFirst and VecLast\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Access.c:135:

    // Test VecBegin and VecEnd functions
    bool test_vec_begin_end(void) {
        WriteFmt("Testing VecBegin and VecEnd\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Access.c:168:

    // Test VecSize and VecLen functions
    bool test_vec_size_len(void) {
        WriteFmt("Testing VecSize and VecLen\n");
    
        DefaultAllocator alloc    = DefaultAllocatorInit();

In Vec.Access.c:223:

    // Test VecAlignedOffsetAt function
    bool test_vec_aligned_offset_at(void) {
        WriteFmt("Testing VecAlignedOffsetAt\n");
    
        DefaultAllocator alloc    = DefaultAllocatorInit();

In Vec.Access.c:262:

    // Test VecEmpty, VecFind, and VecContains functions
    bool test_vec_empty_find_contains(void) {
        WriteFmt("Testing VecEmpty, VecFind, and VecContains\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Access.c:293:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Vec.Access tests\n\n");
    
        // Array of test functions

In Pdb.c:311:

    
    int main(void) {
        WriteFmt("[INFO] Starting Pdb tests\n\n");
    
        TestFunction tests[] = {

In Iter.c:226:

    
    int main(void) {
        WriteFmt("[INFO] Starting Iter tests\n\n");
        TestFunction tests[] = {
            test_iter_remaining_forward,

In List.Deadend.c:24:

    
    static bool test_validate_corrupt_empty_list_fails(void) {
        WriteFmt("Testing ValidateList on corrupt empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:38:

    
    static bool test_validate_null_list_fails(void) {
        WriteFmt("Testing ValidateList on NULL list\n");
    
        ValidateList(NULL);

In List.Deadend.c:45:

    
    static bool test_validate_invalid_magic_fails(void) {
        WriteFmt("Testing ValidateList on invalid magic\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:58:

    
    static bool test_validate_corrupt_nonempty_list_fails(void) {
        WriteFmt("Testing ValidateList on corrupt non-empty list\n");
    
        GenericListNode node = {0};

In List.Deadend.c:77:

    
    static bool test_validate_nonempty_head_null_fails(void) {
        WriteFmt("Testing ValidateList on non-empty NULL head\n");
    
        int             value = 1;

In List.Deadend.c:97:

    
    static bool test_validate_head_prev_fails(void) {
        WriteFmt("Testing ValidateList on head prev corruption\n");
    
        int             value = 1;

In List.Deadend.c:117:

    
    static bool test_validate_tail_next_fails(void) {
        WriteFmt("Testing ValidateList on tail next corruption\n");
    
        int             value = 1;

In List.Deadend.c:137:

    
    static bool test_list_ptr_at_empty_fails(void) {
        WriteFmt("Testing ListPtrAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:146:

    
    static bool test_list_ptr_at_out_of_bounds_fails(void) {
        WriteFmt("Testing ListPtrAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:156:

    
    static bool test_list_at_out_of_bounds_fails(void) {
        WriteFmt("Testing ListAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:166:

    
    static bool test_list_node_ptr_at_empty_fails(void) {
        WriteFmt("Testing ListNodePtrAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:175:

    
    static bool test_list_node_ptr_at_out_of_bounds_fails(void) {
        WriteFmt("Testing ListNodePtrAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:185:

    
    static bool test_list_node_at_out_of_bounds_fails(void) {
        WriteFmt("Testing ListNodeAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:195:

    
    static bool test_list_first_on_empty_fails(void) {
        WriteFmt("Testing ListFirst on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:204:

    
    static bool test_list_last_on_empty_fails(void) {
        WriteFmt("Testing ListLast on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:213:

    
    static bool test_list_node_at_empty_fails(void) {
        WriteFmt("Testing ListNodeAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:222:

    
    static bool test_list_insert_out_of_range_fails(void) {
        WriteFmt("Testing ListInsertR out of range\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:231:

    
    static bool test_list_remove_out_of_range_fails(void) {
        WriteFmt("Testing ListRemove out of range\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:241:

    
    static bool test_list_pop_front_empty_fails(void) {
        WriteFmt("Testing ListPopFront on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:250:

    
    static bool test_list_pop_back_empty_fails(void) {
        WriteFmt("Testing ListPopBack on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:259:

    
    static bool test_list_remove_range_out_of_range_fails(void) {
        WriteFmt("Testing ListRemoveRange out of range\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:270:

    
    static bool test_list_swap_items_out_of_range_fails(void) {
        WriteFmt("Testing ListSwapItems out of range\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:280:

    
    static bool test_list_find_without_compare_fails(void) {
        WriteFmt("Testing ListFind without compare function\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:291:

    
    static bool test_list_find_without_key_fails(void) {
        WriteFmt("Testing ListFind without key pointer\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:301:

    
    static bool test_list_node_relative_null_fails(void) {
        WriteFmt("Testing ListNodeRelative with NULL node\n");
    
        ListNodeRelative(NULL, 1);

In List.Deadend.c:308:

    
    static bool test_list_sort_without_compare_fails(void) {
        WriteFmt("Testing ListSort without compare function\n");
    
        List(int) list = ListInit(get_test_alloc());

In List.Deadend.c:347:

        };
    
        WriteFmt("[INFO] Starting List.Deadend tests\n\n");
        return run_test_suite(
            NULL,

In Vec.Type.c:21:

    // Test basic Vec type functionality
    bool test_vec_type_basic(void) {
        WriteFmt("Testing basic Vec type functionality\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Type.c:56:

    // Test ValidateVec macro
    bool test_vec_validate(void) {
        WriteFmt("Testing ValidateVec macro\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Vec.Type.c:79:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Vec.Type tests\n\n");
    
        // Array of test functions

In Vec.Insert.c:27:

    
    bool test_vec_push_back(void) {
        WriteFmt("Testing VecPushBack\n");
    
        // Create a vector of integers

In Vec.Insert.c:55:

    // Test VecPushFront function
    bool test_vec_push_front(void) {
        WriteFmt("Testing VecPushFront\n");
    
        // Create a vector of integers

In Vec.Insert.c:83:

    // Test VecInsert function
    bool test_vec_insert(void) {
        WriteFmt("Testing VecInsert\n");
    
        // Create a vector of integers

In Vec.Insert.c:118:

    // Test VecPushBackArr function
    bool test_vec_push_back_arr(void) {
        WriteFmt("Testing VecPushBackArr\n");
    
        // Create a vector of integers

In Vec.Insert.c:159:

    // Test VecPushFrontArr function
    bool test_vec_push_front_arr(void) {
        WriteFmt("Testing VecPushFrontArr\n");
    
        // Create a vector of integers

In Vec.Insert.c:200:

    // Test VecInsertRange function for inserting at a specific index
    bool test_vec_push_arr(void) {
        WriteFmt("Testing VecInsertRange at specific index\n");
    
        // Create a vector of integers

In Vec.Insert.c:233:

    // Test VecInsertRange function for inserting from another vector
    bool test_vec_insert_range(void) {
        WriteFmt("Testing VecInsertRange from another vector\n");
    
        // Create a vector of integers

In Vec.Insert.c:271:

    // Test VecMerge function
    bool test_vec_merge(void) {
        WriteFmt("Testing VecMerge\n");
    
        // Create a vector of integers

In Vec.Insert.c:315:

    // the elements manually.)
    bool test_vec_init_clone_inherits_allocator_config(void) {
        WriteFmt("Testing manual clone allocator inheritance\n");
    
        typedef Vec(int) IntVec;

In Vec.Insert.c:357:

    // Test L-value and R-value operations
    bool test_lvalue_rvalue_operations(void) {
        WriteFmt("Testing L-value and R-value operations\n");
    
        // Create a vector of integers

In Vec.Insert.c:440:

    // Test that L-value insertions properly zero out values after insertion
    bool test_lvalue_zero_on_take_after_insertion(void) {
        WriteFmt("Testing L-value zero-on-take after insertion\n");
    
        // Create a vector of integers without copy_init

In Vec.Insert.c:521:

    // untouched prefix [0, idx) is intact.
    bool test_vec_insert_range_fast_overflowing_tail(void) {
        WriteFmt("Testing VecInsertRangeFast with count > (length - idx)\n");
    
        typedef Vec(int) IntVec;

In Vec.Insert.c:570:

    int main(void) {
        alloc = DefaultAllocatorInit();
        WriteFmt("[INFO] Starting Vec.Insert tests\n\n");
    
        // Array of test functions

In MachoCache.c:280:

    
    int main(void) {
        WriteFmt("[INFO] Starting MachoCache tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Compare.c:43:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEquals\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:90:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:130:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLexCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:168:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecNumericalCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:208:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecWeightCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:248:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecIsSubset\n");
    
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:295:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSignedCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:342:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecIsSuperset\n");
    
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:389:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecOverlaps\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:434:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDisjoint and BitVecIntersects\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:482:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEqualsRange\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:528:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecCompareRange\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:579:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecIsLexicographicallyLess and BitVecIsNumericallyLess\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:623:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecIsSorted\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:671:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec compare edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:710:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set operations edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:745:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive comparison operations\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:820:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec large-scale comparison operations\n");
    
        BitVec large1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:887:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec compare NULL pointer handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:900:

    
    bool test_bitvec_subset_null_failures(void) {
        WriteFmt("Testing BitVec subset NULL handling\n");
    
        // Test NULL pointer - should abort

In BitVec.Compare.c:911:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec range operations NULL handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:926:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec range operations bounds checking\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:947:

    
    bool test_bitvec_sorted_null_failures(void) {
        WriteFmt("Testing BitVec sorted operations NULL handling\n");
    
        // Test NULL pointer - should abort

In BitVec.Compare.c:957:

    // Two bitvectors built the same way must hash identically.
    bool test_bitvec_hash_determinism(void) {
        WriteFmt("Testing bitvec_hash determinism\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Compare.c:986:

    // share a byte prefix but differ in length must still distinguish.
    bool test_bitvec_hash_distinguishes(void) {
        WriteFmt("Testing bitvec_hash sensitivity to bits and length\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Compare.c:1023:

    // shaped helpers wired in directly -- no per-callsite cast needed.
    bool test_bitvec_hash_as_map_key(void) {
        WriteFmt("Testing bitvec_hash as Map<BitVec, u64> key\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Compare.c:1070:

    // equality / identity. Mirrors how str_compare is exercised.
    bool test_bitvec_compare_callback(void) {
        WriteFmt("Testing bitvec_compare as GenericCompare callback\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In BitVec.Compare.c:1103:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Compare tests\n\n");
    
        // Array of normal test functions

In Map.Ops.c:187:

        };
    
        WriteFmt("[INFO] Starting Map.Ops tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Ops");
    }

In PageProtect.c:41:

    
    int main(void) {
        WriteFmt("[INFO] Starting PageProtect tests\n\n");
    
        TestFunction tests[] = {

In List.Type.c:8:

    
    static bool test_list_type_defaults(void) {
        WriteFmt("Testing List type defaults\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In List.Type.c:29:

    
    static bool test_list_node_type_layout(void) {
        WriteFmt("Testing ListNode type layout\n");
    
        int value          = 42;

In List.Type.c:47:

        };
    
        WriteFmt("[INFO] Starting List.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Type");
    }

In Dns.c:305:

    
    int main(void) {
        WriteFmt("[INFO] Starting Dns tests\n\n");
    
        TestFunction tests[] = {

In Str.Init.c:24:

    // Test StrInit function
    bool test_str_init(void) {
        WriteFmt("Testing StrInit\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:44:

    // Test StrInitFromCstr function
    bool test_str_init_from_cstr(void) {
        WriteFmt("Testing StrInitFromCstr\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:65:

    // Test StrInitFromZstr function
    bool test_str_init_from_zstr(void) {
        WriteFmt("Testing StrInitFromZstr\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:85:

    // Test StrZ alias
    bool test_str_z_alias(void) {
        WriteFmt("Testing StrZ\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:103:

    // Test StrInitFromStr function
    bool test_str_init_from_str(void) {
        WriteFmt("Testing StrInitFromStr\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:125:

    // Test StrDup function (alias for StrInitFromStr)
    bool test_str_dup(void) {
        WriteFmt("Testing StrDup\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:147:

    // Test StrAppendFmt function
    bool test_str_WriteFmt(void) {
        WriteFmt("Testing StrAppendFmt\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:167:

    // Test StrInitStack macro
    bool test_str_init_stack(void) {
        WriteFmt("Testing StrInitStack\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:195:

    // Test StrInitCopy function
    bool test_str_init_copy(void) {
        WriteFmt("Testing StrInitCopy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:220:

    // Test that Str clones inherit the source allocator pointer
    bool test_str_clone_inherits_allocator_config(void) {
        WriteFmt("Testing Str clone allocator inheritance\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:250:

    // Test StrDeinit function
    bool test_str_deinit(void) {
        WriteFmt("Testing StrDeinit\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Init.c:272:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Init tests\n\n");
    
        // Array of test functions

In Map.Type.c:141:

        };
    
        WriteFmt("[INFO] Starting Map.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Type");
    }

In Str.Foreach.c:35:

    // Test StrForeachIdx macro
    bool test_str_foreach_idx(void) {
        WriteFmt("Testing StrForeachIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:58:

    // Test StrForeachReverseIdx macro
    bool test_str_foreach_reverse_idx(void) {
        WriteFmt("Testing StrForeachReverseIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:73:

    
        bool success = (ZstrCompare(StrBegin(&result), "o4l3l2e1H0") == 0);
        WriteFmt("  (Index 0 was processed)\n");
    
        StrDeinit(&s);

In Str.Foreach.c:83:

    // Test StrForeachPtrIdx macro
    bool test_str_foreach_ptr_idx(void) {
        WriteFmt("Testing StrForeachPtrIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:115:

    // Test StrForeachReversePtrIdx macro
    bool test_str_foreach_reverse_ptr_idx(void) {
        WriteFmt("Testing StrForeachReversePtrIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:137:

        success      = (ZstrCompare(StrBegin(&result), "o4l3l2e1H0") == 0);
        success      = success && (ZstrCompare(StrBegin(&s), "HELLO") == 0); // All uppercase
        WriteFmt("  (Index 0 was processed)\n");
    
        StrDeinit(&s);

In Str.Foreach.c:147:

    // Test StrForeach macro
    bool test_str_foreach(void) {
        WriteFmt("Testing StrForeach\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:171:

    // Test StrForeachReverse macro
    bool test_str_foreach_reverse(void) {
        WriteFmt("Testing StrForeachReverse\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:191:

        if (char_count == StrLen(&s)) {
            success = (ZstrCompare(StrBegin(&result), "olleH") == 0);
            WriteFmt("  (All characters were processed)\n");
        } else {
            success = (ZstrCompare(StrBegin(&result), "olle") == 0);

In Str.Foreach.c:194:

        } else {
            success = (ZstrCompare(StrBegin(&result), "olle") == 0);
            WriteFmt("  (First character was NOT processed - bug in macro)\n");
        }

In Str.Foreach.c:205:

    // Test StrForeachPtr macro
    bool test_str_foreach_ptr(void) {
        WriteFmt("Testing StrForeachPtr\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:237:

    // Test StrForeachPtrReverse macro
    bool test_str_foreach_ptr_reverse(void) {
        WriteFmt("Testing StrForeachPtrReverse\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:264:

            success = (ZstrCompare(StrBegin(&result), "olleH") == 0);
            success = success && (ZstrCompare(StrBegin(&s), "HELLO") == 0); // All uppercase
            WriteFmt("  (All characters were processed)\n");
        } else {
            success = (ZstrCompare(StrBegin(&result), "olle") == 0);

In Str.Foreach.c:268:

            success = (ZstrCompare(StrBegin(&result), "olle") == 0);
            success = success && (ZstrCompare(StrBegin(&s), "HELLo") == 0); // All uppercase except first char
            WriteFmt("  (First character was NOT processed - bug in macro)\n");
        }

In Str.Foreach.c:279:

    // Test StrForeachInRangeIdx macro
    bool test_str_foreach_in_range_idx(void) {
        WriteFmt("Testing StrForeachInRangeIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:314:

    // Test StrForeachInRange macro
    bool test_str_foreach_in_range(void) {
        WriteFmt("Testing StrForeachInRange\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:349:

    // Test StrForeachPtrInRangeIdx macro
    bool test_str_foreach_ptr_in_range_idx(void) {
        WriteFmt("Testing StrForeachPtrInRangeIdx\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:381:

    // Test StrForeachPtrInRange macro
    bool test_str_foreach_ptr_in_range(void) {
        WriteFmt("Testing StrForeachPtrInRange\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:413:

    // Make idx go out of bounds in StrForeachInRangeIdx by shrinking string during iteration
    bool test_str_foreach_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachInRangeIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:423:

        size original_length = StrLen(&s); // Capture this as 12
        StrForeachInRangeIdx(&s, chr, idx, 0, original_length) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), chr);
    
            // When we reach idx=4, drastically shrink the string to length 3

In Str.Foreach.c:429:

            if (idx == 4) {
                StrResize(&s, 3); // Shrink to only 3 characters
                WriteFmt("String resized to length {}, idx={}...\n", StrLen(&s), idx);
            }

In Str.Foreach.c:450:

    // Make idx go out of bounds in StrForeachInRangeIdx by deleting characters
    bool test_str_foreach_idx_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachInRangeIdx with character deletion where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:460:

        size original_length = StrLen(&s); // Capture this as 11
        StrForeachInRangeIdx(&s, chr, idx, 0, original_length) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), chr);
    
            // When we reach idx=3, delete several characters from the beginning

In Str.Foreach.c:466:

            if (idx == 3) {
                StrDeleteRange(&s, 0, 6); // Remove first 6 characters
                WriteFmt("Deleted first 6 characters, new length={}, idx={}...\n", StrLen(&s), idx);
            }

In Str.Foreach.c:487:

    // Make idx go out of bounds in StrForeachReverseIdx by modifying string during iteration
    bool test_str_foreach_reverse_idx_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachReverseIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:495:

        // StrForeachReverseIdx (VecForeachReverseIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        StrForeachReverseIdx(&s, chr, idx) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), chr);
    
            // When we reach idx=10, drastically shrink the string

In Str.Foreach.c:502:

            if (idx == 10) {
                StrResize(&s, 4); // Shrink to only 4 characters
                WriteFmt("String resized to length {} during reverse iteration... idx = {}\n", StrLen(&s), idx);
            }

In Str.Foreach.c:522:

    // Make idx go out of bounds in StrForeachPtrIdx by modifying string during iteration
    bool test_str_foreach_ptr_idx_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachPtrIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:530:

        // StrForeachPtrIdx (VecForeachPtrIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        StrForeachPtrIdx(&s, chr_ptr, idx) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), *chr_ptr);
    
            // When we reach idx=4, delete most characters from the string

In Str.Foreach.c:536:

            if (idx == 4) {
                StrResize(&s, 4); // Shrink to only 4 characters (valid indices: 0,1,2,3)
                WriteFmt("String resized to length {}, current idx={} is now out of bounds...\n", StrLen(&s), idx);
            }

In Str.Foreach.c:557:

    // Make idx go out of bounds in StrForeachReversePtrIdx by modifying string during iteration
    bool test_str_foreach_reverse_ptr_idx_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachReversePtrIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:565:

        // StrForeachReversePtrIdx (VecForeachPtrReverseIdx) has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        StrForeachReversePtrIdx(&s, chr_ptr, idx) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), *chr_ptr);
    
            // When we reach idx=12, shrink the string significantly

In Str.Foreach.c:570:

            if (idx == 12) {
                StrResize(&s, 5); // Shrink to only 5 characters
                WriteFmt("String resized to length {} during reverse ptr iteration... idx = {}\n", StrLen(&s), idx);
            }

In Str.Foreach.c:591:

    // Make idx go out of bounds in StrForeachPtrInRangeIdx by modifying string during iteration
    bool test_str_foreach_ptr_in_range_idx_out_of_bounds_access(void) {
        WriteFmt("Testing StrForeachPtrInRangeIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:600:

        size original_length = StrLen(&s); // Capture this as 32
        StrForeachPtrInRangeIdx(&s, chr_ptr, idx, 0, original_length) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), *chr_ptr);
    
            // When we reach idx=8, delete several characters

In Str.Foreach.c:605:

            if (idx == 8) {
                StrDeleteRange(&s, 0, 20); // Remove first 20 characters
                WriteFmt("Deleted first 20 characters, new length={}, idx = {}...\n", StrLen(&s), idx);
            }

In Str.Foreach.c:626:

    // Make idx go out of bounds in basic StrForeachIdx by modifying string during iteration
    bool test_str_foreach_idx_basic_out_of_bounds_access(void) {
        WriteFmt("Testing basic StrForeachIdx where idx goes out of bounds\n");
        DefaultAllocator alloc = DefaultAllocatorInit();

In Str.Foreach.c:634:

        // Basic StrForeachIdx (VecForeachIdx) now has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
        StrForeachIdx(&s, chr, idx) {
            WriteFmt("Accessing idx {} (s.length={}): '{c}'\n", idx, StrLen(&s), chr);
    
            // When we reach idx=3, drastically shrink the string

In Str.Foreach.c:640:

            if (idx == 3) {
                StrResize(&s, 2); // Shrink to only 2 characters
                WriteFmt(
                    "String resized to length {}, but basic foreach iteration continues... idx = {}\n",
                    StrLen(&s),

In Str.Foreach.c:665:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting Str.Foreach.Simple tests\n\n");
    
        // Array of normal test functions

In ArgParse.c:411:

    
    int main(void) {
        WriteFmt("[INFO] Starting ArgParse tests\n\n");
    
        TestFunction tests[] = {

In BitVec.Access.c:38:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:66:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:100:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:141:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec length and capacity operations\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:176:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec count operations\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:214:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:240:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:263:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:284:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec count edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:319:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec multiple access operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:348:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec large pattern access\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:388:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec macro functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:427:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec access stress test\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:470:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec comprehensive bit patterns\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:535:

    // Deadend tests
    bool test_bitvec_access_null_failures(void) {
        WriteFmt("Testing BitVec access NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.c:544:

    
    bool test_bitvec_set_null_failures(void) {
        WriteFmt("Testing BitVec set NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.c:553:

    
    bool test_bitvec_flip_null_failures(void) {
        WriteFmt("Testing BitVec flip NULL pointer handling\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.c:564:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:579:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:594:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec flip bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:610:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:628:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec set with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:645:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:661:

    
    bool test_bitvec_count_null_failures(void) {
        WriteFmt("Testing BitVec count operations with NULL pointer\n");
    
        // Test NULL bitvec pointer - should abort

In BitVec.Access.c:672:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec get with maximum index value\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:689:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFind and BitVecFindLast functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:736:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAll, BitVecAny, BitVecNone functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:788:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun function\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:840:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFind edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:875:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVec predicate edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:918:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:952:

    // Deadend tests - testing NULL pointers and invalid conditions that should cause fatal errors
    bool test_bitvec_find_deadend_tests(void) {
        WriteFmt("Testing BitVecFind deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.c:961:

    
    bool test_bitvec_predicate_deadend_tests(void) {
        WriteFmt("Testing BitVec predicate deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.c:970:

    
    bool test_bitvec_longest_run_deadend_tests(void) {
        WriteFmt("Testing BitVecLongestRun deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.c:980:

    // Main function that runs all tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Access tests\n\n");
    
        // Array of test functions (adding new tests to existing ones)

In BitVec.Pattern.Deadend.c:38:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:54:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:71:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:87:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:102:

    // Deadend test 5: BitVecFindAllPattern with NULL source
    bool test_bitvec_find_all_pattern_null_source(void) {
        WriteFmt("Testing BitVecFindAllPattern(NULL, pattern, results, 10) - should fatal\n");
    
        size results[10];

In BitVec.Pattern.Deadend.c:116:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:134:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:154:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:176:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&prefix, true);

In BitVec.Pattern.Deadend.c:188:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecStartsWith(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:200:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEndsWith(NULL, suffix) - should fatal\n");
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&suffix, true);

In BitVec.Pattern.Deadend.c:212:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecEndsWith(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:224:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:236:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:246:

    
    bool test_bitvec_replace_null_source(void) {
        WriteFmt("Testing BitVecReplace(NULL, old, new) - should fatal\n");
    
        // Don't create BitVecs since we're testing NULL source validation

In BitVec.Pattern.Deadend.c:256:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Deadend.c:269:

    
    bool test_bitvec_regex_match_null_source(void) {
        WriteFmt("Testing BitVecRegexMatch(NULL, pattern) - should fatal\n");
        BitVecRegexMatch(NULL, "101");
        return true;

In BitVec.Pattern.Deadend.c:277:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecRegexMatch(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:288:

    bool test_bitvec_prefix_match_null_source(void) {
        DefaultAllocator alloc = DefaultAllocatorInit();
        WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        BitVecPush(VecPtrAt(&vp, 0), true);

In BitVec.Pattern.Deadend.c:300:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:311:

    bool test_bitvec_suffix_match_null_source(void) {
        DefaultAllocator alloc = DefaultAllocatorInit();
        WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        BitVecPush(VecPtrAt(&vp, 0), true);

In BitVec.Pattern.Deadend.c:323:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSuffixMatch(source, NULL, 1) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:334:

    // Main function that runs all deadend tests
    int main(void) {
        WriteFmt("[INFO] Starting BitVec.Pattern.Deadend tests\n\n");
    
        // Deadend tests that would cause program termination

In Pe.c:223:

    
    int main(void) {
        WriteFmt("[INFO] Starting Pe tests\n\n");
    
        TestFunction tests[] = {

Last updated on June 4, 2026

ValidateAllocator ZstrIOArg