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 PageProtect.c:43:

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

In File.c:1244:

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

In File.c:1281:

        };
    
        TestFunction deadend_tests[] = {
            test_fm_498_null_buf_positive_n_aborts,
        };

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 AllocDebug.c:1467:

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

In AllocDebug.c:1534:

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

In ArgParse.c:1953:

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

In ArgParse.c:2054:

        };
    
        TestFunction deadend_tests[] = {
            test_a3_option_without_any_name_aborts,
        };

In DateTime.c:216:

    
    int main(void) {
        TestFunction tests[] = {
            test_unix_roundtrip,
            test_days_from_civil_year_zero_leap,

In Ops.c:767:

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

In Ops.c:785:

            test_commit_marked_passes_no_overscan,
        };
        TestFunction deadend_tests[] = {
            test_graph_stale_node_handle_after_commit_deadend,
            test_edge_marked_stale_from_deadend,

In Init.c:237:

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

In Insert.c:326:

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

In Type.c:557:

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

In Type.c:562:

            test_graph_validate_passes_with_marked_node,
        };
        TestFunction deadend_tests[] = {
            test_graph_non_pow2_alignment_rejected_deadend,
            test_graph_validate_catches_corrupt_slots_vec_deadend,

In Foreach.c:613:

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

In Foreach.c:621:

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

In Access.c:365:

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

In Access.c:371:

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

In Compare.c:813:

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

In Type.c:392:

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

In Math.c:1462:

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

In Math.c:1529:

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

In Convert.c:876:

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

In Convert.c:922:

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

In Access.c:65:

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

In Ops.c:212:

    
        // Array of test functions
        TestFunction tests[] = {test_vec_swap_items, test_vec_reverse, test_vec_sort};
    
        TestFunction deadend_tests[] = {test_swap_idx_equal_length_aborts, test_swap_idx1_equal_length_aborts};

In Ops.c:214:

        TestFunction tests[] = {test_vec_swap_items, test_vec_reverse, test_vec_sort};
    
        TestFunction deadend_tests[] = {test_swap_idx_equal_length_aborts, test_swap_idx1_equal_length_aborts};
    
        int total_tests   = sizeof(tests) / sizeof(tests[0]);

In Complex.c:1034:

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

In Memory.c:733:

    
        // Array of test functions
        TestFunction tests[] = {
            test_vec_try_reduce_space,
            test_vec_resize,

In Memory.c:761:

        };
    
        TestFunction deadend_tests[] = {
            test_vec_reserve_capacity_overflow_aborts,
            test_validate_rejects_length_over_capacity

In Init.c:365:

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

In Insert.c:1995:

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

In Type.c:81:

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

In Remove.c:1465:

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

In Foreach.c:580:

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

In Access.c:357:

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

In Memory.c:732:

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

In Memory.c:753:

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

In Init.c:406:

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

In Init.c:420:

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

In 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 Compare.c:1795:

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

In Compare.c:1837:

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

In Insert.c:464:

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

In Insert.c:478:

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

In Pattern.Deadend.c:658:

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

In Foreach.Deadend.c:134:

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

In Foreach.Simple.c:728:

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

In Type.c:121:

    
        // Array of test functions
        TestFunction tests[] = {test_bitvec_type_basic, test_bitvec_validate, test_validate_memoization_skips_structural};
    
        // Deadend tests trigger exactly one abort each.

In Type.c:124:

    
        // Deadend tests trigger exactly one abort each.
        TestFunction deadend_tests[] = {test_structural_byte_size_check_aborts};
    
        int total_tests         = sizeof(tests) / sizeof(tests[0]);

In BitWise.Simple.c:1206:

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

In BitWise.Deadend.c:234:

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

In Pattern.Simple.c:1692:

    
        // Array of test functions
        TestFunction tests[] = {
            test_bitvec_basic_pattern_functions,
            test_bitvec_find_pattern,

In Math.c:1571:

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

In Math.c:1615:

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

In Remove.c:667:

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

In Remove.c:685:

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

In Convert.c:916:

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

In Convert.c:940:

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

In Access.Simple.c:727:

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

In Compare.c:297:

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

In Compare.c:310:

        };
    
        TestFunction deadend_tests[] = {
            test_m28_compare_i64_null_lhs_deadend,
        };

In Type.c:159:

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

In Math.c:4858:

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

In Math.c:5056:

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

In Convert.c:1642:

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

In Convert.c:1711:

        // 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_try_from_binary_null,

In Access.c:373:

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

In Access.c:393:

        };
    
        TestFunction deadend_tests[] = {
            test_m28_bit_length_invalid_deadend,
        };

In 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 Write.c:5731:

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

In Write.c:6031:

        int total_tests = sizeof(tests) / sizeof(tests[0]);
    
        TestFunction deadend_tests[] = {
            test_m16_nonraw_spec_deadend,
            test_m32_deadend_nonraw_legal_width,

In Read.c:2867:

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

In Arena.c:121:

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

In Arena.c:128:

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

In Budget.c:228:

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

In Budget.c:241:

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

In Page.c:183:

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

In Dispatch.c:303:

    
    int main(void) {
        TestFunction normal[] = {
            // Retry arithmetic / attempt counts
            test_al_alloc_retry_limit_plus_one,

In Dispatch.c:317:

    #endif
        };
        TestFunction deadend[] = {
            test_al_alloc_validates_magic,
            test_al_resize_validates_magic,

In Slab.c:190:

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

In Slab.c:198:

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

In Heap.c:362:

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

In Heap.c:382:

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

In Ops.c:1128:

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

In Ops.c:1160:

    
        // Array of deadend test functions (relocated from Str.Mutants*)
        TestFunction deadend_tests[] = {
            test_replace_zstr_null_aborts,                  // Str.Mutants3
            test_find_zstr_validates,                       // Str.Mutants4

In Memory.c:206:

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

In Init.c:346:

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

In Init.c:364:

    
        // Array of deadend test functions (relocated from Str.Mutants8)
        TestFunction deadend_tests[] = {test_init_copy_validates_src};
    
        int total_tests         = sizeof(tests) / sizeof(tests[0]);

In Insert.c:360:

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

In 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 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 Remove.c:211:

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

In Convert.c:2118:

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

In Convert.c:2210:

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

In Foreach.c:668:

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

In Access.c:174:

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

In Ops.c:262:

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

In Init.c:116:

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

In Insert.c:358:

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

In Type.c:96:

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

In Deadend.c:397:

    
    int main(void) {
        TestFunction deadend_tests[] = {
            test_iteration_target_at_length_fails,
            test_random_access_relative_target_at_length_fails,

In Remove.c:232:

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

In Foreach.c:340:

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

In Access.c:503:

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

In StrIter.c:127:

    int main(void) {
        WriteFmt("[INFO] Starting StrIter tests\n\n");
        TestFunction tests[] = {
            test_striter_from_zstr_length_and_read,
            test_striter_from_cstr_caps_length,

In Deadend.c:93:

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

In Iter.c:459:

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

In Ops.c:317:

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

In Init.c:273:

    
    int main(void) {
        TestFunction tests[] = {
            test_map_grows_to_fit_many_inserts,
            test_map_init_defaults_are_linear,

In Insert.c:1201:

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

In Insert.c:1239:

        };
    
        TestFunction deadend_tests[] = {
            test_rehash_rejects_invalid_policy,
            test_rehash_rejects_insufficient_with_small_n,

In Type.c:185:

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

In Deadend.c:722:

    
    int main(void) {
        TestFunction tests[] = {
            test_validate_more_tombstones_than_live_is_valid,
            test_validate_policy_skips_stuck_check_at_probe_budget_one,

In Deadend.c:729:

        };
    
        TestFunction deadend_tests[] = {
            test_validate_uninitialized_map_fails,
            test_map_init_with_invalid_policy_fails,

In Remove.c:405:

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

In Foreach.c:202:

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

In Access.c:447:

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

In TestRunner.c:264:

    // 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:302:

    
    /// 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:331:

    
    /// 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:363:

    /// 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:365:

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

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 Variant.c:126:

    int main(void) {
        WriteFmt("[INFO] Starting Generics.Variant tests\n\n");
        TestFunction tests[] = {
            test_variant_construct_and_match,
            test_variant_binds_typed_payload,

In Variant.c:135:

            test_variant_arms_are_exclusive,
        };
        TestFunction deadend_tests[] = {
            deadend_variant_nonexhaustive,
        };

In TypeMatch.c:129:

    int main(void) {
        WriteFmt("[INFO] Starting Generics.TypeMatch tests\n\n");
        TestFunction tests[] = {
            test_match_dispatch,
            test_match_binds_value,

In TypeMatch.c:138:

            test_is_predicate,
        };
        TestFunction deadend_tests[] = {
            deadend_match_nonexhaustive,
        };

In PdbCache.c:857:

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

In Backtrace.c:226:

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

In SysDns.c:2096:

        WriteFmt("[INFO] Starting SysDns tests\n\n");
    
        TestFunction tests[] = {
            // public resolve API against live /etc files
            test_dns_resolve_localhost_from_hosts,

In Socket.c:1686:

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

In Socket.c:1748:

        };
    
        TestFunction deadend_tests[] = {
            test_sk1_null_items_nonzero_count_aborts,
        };

In MachoCache.c:1290:

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

In Clock.c:62:

    
    int main(void) {
        TestFunction tests[] = {
            test_real_is_recent_wall_time,
            test_real_differs_from_tick,

In SymbolResolver.c:711:

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

In SymBind.c:92:

        WriteFmt("[INFO] Starting SymbolResolver.SymBind tests\n\n");
    
        TestFunction tests[] = {
            test_symbind_sized_prefers_global,
            test_symbind_zero_prefers_global,

In SidecarDwarf.c:79:

        WriteFmt("[INFO] Starting SymbolResolver.SidecarDwarf tests\n\n");
    
        TestFunction tests[] = {
            test_sidecardwarf_names_via_sidecar_functions,
            test_sidecardwarf_teardown_frees_sidecar_functions,

In SidecarSub.c:82:

        WriteFmt("[INFO] Starting SymbolResolver.SidecarSub tests\n\n");
    
        TestFunction tests[] = {
            test_sidecarsub_path3_names_marker,
            test_sidecarsub_teardown_frees,

In Sidecar.c:97:

        WriteFmt("[INFO] Starting SymbolResolver.Sidecar tests\n\n");
    
        TestFunction tests[] = {
            test_sidecar_debuglink_names_marker,
            test_sidecar_teardown_frees_sidecar,

In DwarfFallback.c:161:

        WriteFmt("[INFO] Starting SymbolResolver.DwarfFallback tests\n\n");
    
        TestFunction tests[] = {
            test_dwarffallback_names_and_arith,
            test_dwarffallback_interior_offset,

In Bias.c:168:

        WriteFmt("[INFO] Starting SymbolResolver.Bias tests\n\n");
    
        TestFunction tests[] = {
            test_bias_names_data_via_pvaddr_formula,
            test_bias_interior_offset_via_pvaddr_formula,

In Pe.c:1766:

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

In Dns.c:2196:

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

In Pdb.c:3227:

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

In Tzif.c:157:

    
    int main(void) {
        TestFunction tests[] = {
            test_v1_resolve,
            test_v2_resolve,

In ProcMaps.c:666:

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

In Http.c:412:

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

In MachO.c:1561:

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

In Elf.c:2480:

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

In Stripped.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 DwarfUnwind.c:1477:

        WriteFmt("[INFO] Starting DwarfUnwind tests\n\n");
    
        TestFunction tests[] = {
            test_du_def_cfa,
            test_du_def_cfa_offset_and_register,

In Dwarf.c:3470:

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

In Read.Simple.c:500:

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

In Write.EdgeCases.c:529:

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

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 Read.Nested.c:1126:

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

In Write.Simple.c:362:

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

In Read.EdgeCases.c:1242:

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

In RoundTrip.c:810:

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

In Parse.c:827:

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

Last updated on July 1, 2026

SymbolResolverResolve TzifLocalOffsetSeconds