TestFunction

Documentation

API Reference

TestFunction

Description

Function pointer type for test functions.

Success

Function returns true if test passed, false if failed.

Failure

Function cannot fail - always returns boolean result.

Usage example (Cross-references)

Usage examples (Cross-references)

In TestRunner.h:38:

    /// TAGS: Testing, Deadend, Control
    ///
    bool test_deadend(TestFunction test_func, bool expect_failure);
    
    ///

In TestRunner.h:51:

    /// TAGS: Testing, Driver, Simple
    ///
    int simple_test_driver(TestFunction *tests, int count);
    
    ///

In TestRunner.h:64:

    /// TAGS: Testing, Driver, Deadend
    ///
    int deadend_test_driver(TestFunction *tests, int count);
    
    ///

In TestRunner.h:81:

    ///
    int run_test_suite(
        TestFunction *normal_tests,
        int           normal_count,
        TestFunction *deadend_tests,

In TestRunner.h:83:

        TestFunction *normal_tests,
        int           normal_count,
        TestFunction *deadend_tests,
        int           deadend_count,
        Zstr          test_name

In TestRunner.c:217:

    // aborts must unwind back here too, otherwise the abort handler would
    // longjmp to an uninitialised buffer.
    bool test_deadend(TestFunction test_func, bool expect_failure) {
        if (!test_func) {
            WriteFmt("[ERROR] test_deadend: NULL test function provided\n");

In TestRunner.c:255:

    
    /// Run an array of simple tests
    int simple_test_driver(TestFunction *tests, int count) {
        if (!tests) {
            WriteFmt("[ERROR] simple_test_driver: NULL tests array provided\n");

In TestRunner.c:284:

    
    /// Run an array of deadend tests (all expecting failure)
    int deadend_test_driver(TestFunction *tests, int count) {
        if (!tests) {
            WriteFmt("[ERROR] deadend_test_driver: NULL tests array provided\n");

In TestRunner.c:316:

    /// Main test driver - handles everything: normal tests and deadend tests
    int run_test_suite(
        TestFunction *normal_tests,
        int           normal_count,
        TestFunction *deadend_tests,

In TestRunner.c:318:

        TestFunction *normal_tests,
        int           normal_count,
        TestFunction *deadend_tests,
        int           deadend_count,
        Zstr          test_name

In Read.EdgeCases.c:695:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_empty_object_reading,
            test_empty_array_reading,

In Write.Nested.c:554:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_two_level_nesting_writing,
            test_three_level_nesting_writing,

In Write.Simple.c:362:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_simple_string_writing,
            test_simple_numbers_writing,

In Write.EdgeCases.c:529:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_empty_object_writing,
            test_empty_array_writing,

In Read.Nested.c:1126:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_basic_iterator_functionality,
            test_simple_json_object,

In Read.Simple.c:500:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_simple_string_parsing,
            test_simple_numbers,

In RoundTrip.c:811:

    int main(void) {
        // Array of test functions
        TestFunction tests[] = {
            test_simple_roundtrip,
            test_numeric_roundtrip,

In Parse.c:162:

    
    int main(void) {
        TestFunction tests[] = {
            test_kvconfig_basic_parse,
            test_kvconfig_comments_quotes_and_duplicates,

In Str.Remove.c:211:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_pop_back,
            test_str_pop_front,

In Http.c:66:

        WriteFmt("[INFO] Starting Http tests\n\n");
    
        TestFunction tests[] = {
            test_http_request_parse_get_with_headers,
            test_http_response_serialize_html,

In Allocator.Budget.c:228:

    
    int main(void) {
        TestFunction normal[] = {
            // Happy path
            test_basic_alloc_and_free,

In Allocator.Budget.c:241:

            test_alignment_honored,
        };
        TestFunction deadend[] = {
            test_tiny_buffer_rejects,
            test_reject_foreign_pointer,

In Map.Insert.c:140:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_insert_and_set,
            test_map_set_first,

In BitVec.Memory.c:475:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_shrink_to_fit,
            test_bitvec_reserve,

In BitVec.Memory.c:489:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_memory_null_failures,
            test_bitvec_swap_null_failures,

In Int.Access.c:196:

        WriteFmt("[INFO] Starting Int.Access tests\n\n");
    
        TestFunction tests[] = {
            test_int_bit_length,
            test_int_byte_length,

In BitVec.BitWise.Simple.c:962:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_shift_left,
            test_bitvec_shift_right,

In Str.Memory.c:206:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_try_reduce_space,
            test_str_swap_char_at,

In Graph.Access.c:133:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_access_helpers,
            test_graph_has_edge_query,

In Graph.Access.c:137:

            test_graph_has_edge_query,
        };
        TestFunction deadend_tests[] = {
            test_graph_cross_graph_node_handle_deadend,
            test_graph_predecessor_access_oob_deadend,

In Graph.Type.c:57:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_type_defaults,
            test_graph_aligned_init_and_id_layout,

In Str.Ops.c:342:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_cmp,
            test_str_cmp_ignore_case,

In Int.Convert.c:534:

        WriteFmt("[INFO] Starting Int.Convert tests\n\n");
    
        TestFunction tests[] = {
            test_int_from_unsigned_integer,
            test_int_bytes_le_round_trip,

In Int.Convert.c:560:

        // contract rule (programmer errors abort). The deadend driver
        // catches the abort and treats it as PASS.
        TestFunction deadend_tests[] = {
            test_int_from_binary_null,
            test_int_from_decimal_null,

In BitVec.Foreach.Deadend.c:119:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_foreach_invalid_usage,
            test_bitvec_run_lengths_null_bv,

In List.Init.c:116:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_init_variants,
            test_list_init_optional_allocator,

In PdbCache.c:333:

        WriteFmt("[INFO] Starting PdbCache tests\n\n");
    
        TestFunction tests[] = {
            test_pdb_cache_resolves_via_codeview,
            test_pdb_cache_rejects_unknown_module,

In List.Insert.c:254:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_insert_and_push_aliases,
            test_list_push_arr_l_zeroes_all_items,

In Backtrace.c:226:

        WriteFmt("[INFO] Starting Backtrace tests\n\n");
    
        TestFunction tests[] = {
            test_backtrace_capture_non_empty,
            test_backtrace_format_resolves_helper,

In Int.Type.c:105:

        WriteFmt("[INFO] Starting Int.Type tests\n\n");
    
        TestFunction tests[] = {
            test_int_init,
            test_int_clear,

In SymbolResolver.c:64:

        WriteFmt("[INFO] Starting SymbolResolver tests\n\n");
    
        TestFunction tests[] = {
            test_symres_resolve_self,
            test_symres_static_symbol_resolves,

In Allocator.Page.c:183:

    
    int main(void) {
        TestFunction tests[] = {
            test_page_size_query,
            test_basic_alloc_and_free,

In List.Foreach.c:340:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_foreach_basic,
            test_list_foreach_ranges,

In List.Ops.c:151:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_clear_and_reuse,
            test_list_sort_and_reverse,

In Str.Convert.c:828:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_str_from_u64,
            test_str_from_i64,

In Str.Convert.c:843:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_str_conversion_null_failures,
            test_str_conversion_bounds_failures,

In Graph.Ops.c:337:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_node_visit_scratch_state,
            test_graph_mark_delete_commit_and_reuse,

In Graph.Ops.c:348:

            test_graph_external_indexed_state_requires_reset_on_reuse,
        };
        TestFunction deadend_tests[] = {
            test_graph_stale_node_handle_after_commit_deadend,
        };

In Float.Compare.c:227:

        WriteFmt("[INFO] Starting Float.Compare tests\n\n");
    
        TestFunction tests[] = {
            test_float_compare_small_small,
            test_float_compare_very_large_large,

In Str.Access.c:174:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_len_empty,
            test_str_first,

In Socket.c:124:

        WriteFmt("[INFO] Starting Socket tests\n\n");
    
        TestFunction tests[] = {
            test_socket_addr_format_round_trip,
            test_socket_loopback_round_trip,

In Vec.Ops.c:162:

    
        // Array of test functions
        TestFunction tests[] = {test_vec_swap_items, test_vec_reverse, test_vec_sort};
    
        int total_tests = sizeof(tests) / sizeof(tests[0]);

In MachO.c:276:

        WriteFmt("[INFO] Starting MachO tests\n\n");
    
        TestFunction tests[] = {
            test_macho_parses_synthetic_blob,
            test_macho_resolves_address,

In Elf.c:96:

        WriteFmt("[INFO] Starting Elf tests\n\n");
    
        TestFunction tests[] = {
            test_elf_self_exe_parse,
            test_elf_find_text_section,

In BitVec.Insert.c:347:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_push,
            test_bitvec_insert_single,

In BitVec.Insert.c:359:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_insert_null_failures,
            test_bitvec_insert_invalid_range_failures,

In Allocator.Slab.c:190:

    
    int main(void) {
        TestFunction normal[] = {
            test_basic_alloc_and_free,
            test_free_then_alloc_recycles,

In Allocator.Slab.c:198:

            test_pool_alignment,
        };
        TestFunction deadend[] = {
            test_reject_foreign_pointer,
            test_reject_misaligned_pointer,

In Io.UserTypes.c:306:

        WriteFmt("[INFO] Starting Io.UserTypes tests\n\n");
    
        TestFunction tests[] = {
            test_user_type_write_basic,
            test_user_type_write_mixed_args,

In SysDns.c:224:

        WriteFmt("[INFO] Starting SysDns tests\n\n");
    
        TestFunction tests[] = {
            test_dns_resolve_localhost_from_hosts,
            test_dns_resolve_hosts_case_insensitive,

In AllocDebug.c:319:

        WriteFmt("[INFO] Starting AllocDebug tests\n\n");
    
        TestFunction normal[] = {
            // Happy path
            test_debug_normal_alloc_free,

In AllocDebug.c:341:

            test_debug_page_backed_alloc_free,
        };
        TestFunction deadend[] = {
            test_debug_double_free_aborts,
            test_debug_foreign_free_aborts,

In Vec.Foreach.c:580:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_vec_foreach,
            test_vec_foreach_idx,

In Map.Foreach.c:85:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_foreach_ptr,
            test_map_foreach_multimap_iterators,

In Buf.c:264:

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

In Allocator.Heap.c:362:

    
    int main(void) {
        TestFunction normal[] = {
            // Happy path
            test_basic_alloc_free,

In Allocator.Heap.c:382:

            test_independent_heaps,
        };
        TestFunction deadend[] = {
            test_reject_foreign_pointer,
            test_reject_double_free,

In BitVec.Type.c:62:

    
        // Array of test functions
        TestFunction tests[] = {test_bitvec_type_basic, test_bitvec_validate};
    
        int total_tests = sizeof(tests) / sizeof(tests[0]);

In BitVec.Pattern.Simple.c:1023:

    
        // Array of test functions
        TestFunction tests[] = {
            test_bitvec_basic_pattern_functions, test_bitvec_find_pattern,           test_bitvec_find_last_pattern,
            test_bitvec_find_all_pattern,        test_bitvec_find_all_pattern_vec,   test_bitvec_pattern_edge_cases,

In Io.Read.c:976:

        WriteFmt("[INFO] Starting format reader tests\n\n");
    
        TestFunction tests[] = {
            test_integer_decimal_reading,
            test_integer_hex_reading,

In Dwarf.c:186:

        WriteFmt("[INFO] Starting Dwarf tests\n\n");
    
        TestFunction tests[] = {
            test_dwarf_lines_load_self,
            test_dwarf_resolves_helper_to_source_file,

In ProcMaps.c:59:

        WriteFmt("[INFO] Starting ProcMaps tests\n\n");
    
        TestFunction tests[] = {
            test_procmaps_load,
            test_procmaps_find_self,

In Allocator.Arena.c:121:

    
    int main(void) {
        TestFunction normal[] = {
            test_basic_bump,
            test_grow_last_in_place,

In Allocator.Arena.c:128:

            test_alignment,
        };
        TestFunction deadend[] = {
            test_reject_remap_non_last,
            test_reject_foreign_free,

In Map.Deadend.c:147:

    
    int main(void) {
        TestFunction deadend_tests[] = {
            test_validate_uninitialized_map_fails,
            test_map_contains_pair_without_value_compare_fails,

In Graph.Init.c:185:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_reserve_clear,
            test_graph_node_deep_copy,

In Float.Type.c:104:

        WriteFmt("[INFO] Starting Float.Type tests\n\n");
    
        TestFunction tests[] = {
            test_float_init,
            test_float_clear,

In Float.Convert.c:243:

        WriteFmt("[INFO] Starting Float.Convert tests\n\n");
    
        TestFunction tests[] = {
            test_float_from_unsigned_integer,
            test_float_from_signed_integer,

In Float.Convert.c:258:

    
        // NULL-input: strict contract = LOG_FATAL; deadend driver catches.
        TestFunction deadend_tests[] = {
            test_float_from_str_null,
        };

In Io.Write.c:712:

        WriteFmt("[INFO] Starting format writer tests\n\n");
    
        TestFunction tests[] = {
            test_basic_formatting,
            test_string_formatting,

In BitVec.Math.c:939:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_hamming_distance_basic,
            test_bitvec_hamming_distance_edge_cases,

In BitVec.Math.c:962:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_hamming_distance_null_bv1,
            test_bitvec_hamming_distance_null_bv2,

In StrippedResolve.c:109:

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

In List.Access.c:162:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_len_empty,
            test_list_value_access_and_swap,

In BitVec.Access.Deadend.c:211:

    
        // Deadend tests that would cause program termination
        TestFunction deadend_tests[] = {
            test_bitvec_find_deadend_tests,
            test_bitvec_predicate_deadend_tests,

In Str.Insert.c:360:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_insert_char_at,
            test_str_insert_cstr,

In Float.Math.c:442:

        WriteFmt("[INFO] Starting Float.Math tests\n\n");
    
        TestFunction tests[] = {
            test_float_negate_abs,
            test_float_add_small_small,

In Float.Math.c:459:

        };
    
        TestFunction deadend_tests[1] = {0};
    
        int total_tests         = sizeof(tests) / sizeof(tests[0]);

In Vec.Init.c:329:

    
        // Array of test functions
        TestFunction tests[] = {
            test_vec_init_basic,
            test_vec_init_aligned,

In Vec.Memory.c:196:

    
        // Array of test functions
        TestFunction tests[] = {test_vec_try_reduce_space, test_vec_resize, test_vec_reserve, test_vec_clear};
    
        int total_tests = sizeof(tests) / sizeof(tests[0]);

In BitVec.BitWise.Deadend.c:149:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_bitwise_null_failures,
            test_bitvec_bitwise_ops_null_failures,

In Map.Remove.c:132:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_remove_value,
            test_map_remove_pair,

In Int.Compare.c:187:

        WriteFmt("[INFO] Starting Int.Compare tests\n\n");
    
        TestFunction tests[] = {
            test_int_compare,
            test_int_compare_wrappers,

In BitVec.Access.Simple.c:727:

    
        // Array of test functions
        TestFunction tests[] = {
            test_bitvec_get,
            test_bitvec_set,

In Vec.Remove.c:828:

    int main(void) {
        // Array of normal test functions
        TestFunction normal_tests[] = {
            test_vec_pop_back,
            test_vec_pop_front,

In List.Remove.c:232:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_remove_and_pop,
            test_list_remove_range_and_delete_aliases,

In Float.Access.c:65:

        WriteFmt("[INFO] Starting Float.Access tests\n\n");
    
        TestFunction tests[] = {
            test_float_is_zero,
            test_float_is_negative,

In BitVec.Init.c:406:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_init,
            test_bitvec_deinit,

In BitVec.Init.c:420:

    
        // Array of deadend test functions (expected failure scenarios)
        TestFunction deadend_tests[] = {
            test_bitvec_null_pointer_failures,
            test_bitvec_invalid_operations,

In BitVec.Foreach.Simple.c:728:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_foreach_idx,
            test_bitvec_foreach,

In Int.Math.c:1129:

        WriteFmt("[INFO] Starting Int.Math tests\n\n");
    
        TestFunction tests[] = {
            test_int_shift_left_grows,
            test_int_shift_right_shrinks,

In Int.Math.c:1181:

        };
    
        TestFunction deadend_tests[] = {
            test_int_add_null_result,
            test_int_shift_left_null,

In Map.Access.c:163:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_contains_and_find,
            test_map_get_ptr,

In File.c:102:

        WriteFmt("[INFO] Starting File tests\n\n");
    
        TestFunction tests[] = {
            test_file_read_into_str,
            test_file_read_grows_str,

In Str.Type.c:181:

    
        // Array of normal test functions
        TestFunction tests[] = {test_str_type, test_strs_type, test_validate_str, test_validate_strs};
    
        // Array of deadend test functions (tests that should crash/abort)

In Str.Type.c:184:

    
        // Array of deadend test functions (tests that should crash/abort)
        TestFunction deadend_tests[] = {test_validate_invalid_str, test_validate_invalid_strs};
    
        int total_tests   = sizeof(tests) / sizeof(tests[0]);

In BitVec.Remove.c:512:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_pop,
            test_bitvec_remove_single,

In BitVec.Remove.c:527:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_remove_null_failures,
            test_bitvec_remove_range_null_failures,

In Graph.Insert.c:90:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_add_node_semantics,
            test_graph_add_edge_dedup,

In Iter.Deadend.c:55:

    int main(void) {
        WriteFmt("[INFO] Starting Iter.Deadend tests\n\n");
        TestFunction tests[] = {
            deadend_must_read_eof,
            deadend_must_peek_out_of_range,

In Vec.Complex.c:902:

    
        // Array of test functions
        TestFunction tests[] = {
            test_complex_vec_init,
            test_complex_vec_push,

In BitVec.BitWise.c:1076:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_shift_left,
            test_bitvec_shift_right,

In BitVec.BitWise.c:1099:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_bitwise_null_failures,
            test_bitvec_bitwise_ops_null_failures,

In BitVec.Convert.c:773:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_to_string,
            test_bitvec_from_string,

In BitVec.Convert.c:792:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_convert_null_failures,
            test_bitvec_from_string_null_failures,

In BitVec.Foreach.c:781:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_foreach_idx,
            test_bitvec_foreach,

In BitVec.Foreach.c:800:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_foreach_invalid_usage,
            test_bitvec_run_lengths_null_bv,

In Map.Init.c:138:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_reserve_and_clear,
            test_map_rehash_policy_switch,

In Graph.Foreach.c:278:

    
    int main(void) {
        TestFunction tests[] = {
            test_graph_city_reachability,
            test_graph_foreach_with_external_map_counts,

In Graph.Foreach.c:283:

            test_graph_foreach_predecessors,
        };
        TestFunction deadend_tests[] = {
            test_graph_node_iteration_rejects_structural_mutation_deadend,
            test_graph_neighbor_iteration_rejects_structural_mutation_deadend,

In Vec.Access.c:296:

    
        // Array of test functions
        TestFunction tests[] = {
            test_vec_at,
            test_vec_ptr_at,

In Pdb.c:313:

        WriteFmt("[INFO] Starting Pdb tests\n\n");
    
        TestFunction tests[] = {
            test_pdb_parses_minimal_msf,
            test_pdb_rejects_bad_magic,

In Iter.c:227:

    int main(void) {
        WriteFmt("[INFO] Starting Iter tests\n\n");
        TestFunction tests[] = {
            test_iter_remaining_forward,
            test_iter_remaining_reverse,

In List.Deadend.c:318:

    
    int main(void) {
        TestFunction deadend_tests[] = {
            test_validate_corrupt_empty_list_fails,
            test_validate_null_list_fails,

In Vec.Type.c:82:

    
        // Array of test functions
        TestFunction tests[] = {test_vec_type_basic, test_vec_validate};
    
        int total_tests = sizeof(tests) / sizeof(tests[0]);

In Vec.Insert.c:573:

    
        // Array of test functions
        TestFunction tests[] = {
            test_vec_push_back,
            test_vec_push_front,

In MachoCache.c:282:

        WriteFmt("[INFO] Starting MachoCache tests\n\n");
    
        TestFunction tests[] = {
            test_macho_cache_resolves_via_main_symtab,
            test_macho_cache_falls_through_to_dsym,

In BitVec.Compare.c:1106:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_bitvec_equals,
            test_bitvec_compare,

In BitVec.Compare.c:1132:

    
        // Array of deadend test functions
        TestFunction deadend_tests[] = {
            test_bitvec_compare_null_failures,
            test_bitvec_subset_null_failures,

In Map.Ops.c:180:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_deep_copy_zstrs,
            test_map_policy_switch_preserves_entries,

In PageProtect.c:43:

        WriteFmt("[INFO] Starting PageProtect tests\n\n");
    
        TestFunction tests[] = {
            test_page_protect_roundtrip,
        };

In List.Type.c:42:

    
    int main(void) {
        TestFunction tests[] = {
            test_list_type_defaults,
            test_list_node_type_layout,

In Dns.c:307:

        WriteFmt("[INFO] Starting Dns tests\n\n");
    
        TestFunction tests[] = {
            test_dns_build_query_basic,
            test_dns_build_query_trailing_dot,

In Str.Init.c:275:

    
        // Array of test functions
        TestFunction tests[] = {
            test_str_init,
            test_str_init_from_cstr,

In Map.Type.c:134:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_type_defaults,
            test_map_type_with_value_compare,

In Str.Foreach.c:668:

    
        // Array of normal test functions
        TestFunction tests[] = {
            test_str_foreach_idx,
            test_str_foreach_reverse_idx,

In ArgParse.c:413:

        WriteFmt("[INFO] Starting ArgParse tests\n\n");
    
        TestFunction tests[] = {
            test_required_long_space,
            test_required_long_equals,

In BitVec.Access.c:983:

    
        // Array of test functions (adding new tests to existing ones)
        TestFunction tests[] = {
            test_bitvec_get,
            test_bitvec_set,

In BitVec.Access.c:1008:

    
        // Deadend tests that would cause program termination
        TestFunction deadend_tests[] = {
            test_bitvec_find_deadend_tests,
            test_bitvec_predicate_deadend_tests,

In BitVec.Pattern.Deadend.c:337:

    
        // Deadend tests that would cause program termination
        TestFunction deadend_tests[] = {
            test_bitvec_find_pattern_null_source,      test_bitvec_find_pattern_null_pattern,
            test_bitvec_find_last_pattern_null_source, test_bitvec_find_last_pattern_null_pattern,

In Pe.c:225:

        WriteFmt("[INFO] Starting Pe tests\n\n");
    
        TestFunction tests[] = {
            test_pe_parses_synthetic_blob,
            test_pe_rva_to_offset_round_trips,

Last updated on June 4, 2026

StrWriteFmt TO_BIG_ENDIAN2