package core:testing
Source

⌘K
Ctrl+K
or
/

    Types

    Internal_Cleanup ¶
    Source

    Internal_Cleanup :: struct {
	procedure: proc(rawptr),
	user_data: rawptr,
	ctx:       runtime.Context,
}

    Internal_Test ¶
    Source

    Internal_Test :: struct {
	pkg:  string,
	name: string,
	p:    Test_Signature,
}
     

    IMPORTANT NOTE: Compiler requires this layout

    Memory_Verifier_Proc ¶
    Source

    Memory_Verifier_Proc :: proc(t: ^T, ta: ^mem.Tracking_Allocator)
    Related Procedures With Parameters

    T ¶
    Source

    T :: struct {
	error_count:      int,
	// If your test needs to perform random operations, it's advised to use
	// this value to seed a local random number generator rather than relying
	// on the non-thread-safe global one.
	// 
	// This way, your results will be deterministic.
	// 
	// This value is chosen at startup of the test runner, logged, and may be
	// specified by the user. It is the same for all tests of a single run.
	seed:             u64,
	channel:          sync_chan.Chan($T=Channel_Event, $D=-1),
	cleanups:         [dynamic]Internal_Cleanup,
	// This allocator is shared between the test runner and its threads for
	// cloning log strings, so they can outlive the lifetime of individual
	// tests during channel transmission.
	_log_allocator:   runtime.Allocator,
	_fail_now_called: bool,
}
    Related Procedures With Parameters

    Test_Signature ¶
    Source

    Test_Signature :: proc(^T)
     

    IMPORTANT NOTE: Compiler requires this layout

    Constants

    MAX_EXPECTED_ASSERTIONS_PER_TEST ¶
    Source

    MAX_EXPECTED_ASSERTIONS_PER_TEST: int : 5

    Variables

    This section is empty.

    Procedures

    cleanup ¶
    Source

    cleanup :: proc(t: ^T, procedure: proc(rawptr), user_data: rawptr) {…}
     

    cleanup registers a procedure and user_data, which will be called when the test, and all its subtests, complete. Cleanup procedures will be called in LIFO (last added, first called) order.

    Each procedure will use a copy of the context at the time of registering, and if the test failed due to a timeout, failed assertion, panic, bounds-checking error, memory access violation, or any other signal-based fault, this procedure will run with greater privilege in the test runner's main thread.

    That means that any cleanup procedure absolutely must not fail in the same way, or it will take down the entire test runner with it. This is for when you need something to run no matter what, if a test failed.

    For almost every usual case, defer should be preferable and sufficient.

    expect ¶
    Source

    expect :: proc(t: ^T, ok: bool, msg: string = "", expr: string = #caller_expression(ok), loc := #caller_location) -> bool {…}

    expect_assert_from ¶
    Source

    expect_assert_from :: proc(t: ^T, expected_place: runtime.Source_Code_Location, caller_loc := #caller_location) {…}
     

    Let the test runner know that it should expect an assertion failure from a specific location in the source code for this test.

    In the event that an assertion fails, a debug message will be logged with its exact message and location in a copyable format to make it convenient to write tests which use this API.

    This procedure may be called up to 5 times with different locations.

    This is a limitation for the sake of simplicity in the implementation, and you should consider breaking up your tests into smaller procedures if you need to check for asserts in more than 2 places.

    expect_assert_message ¶
    Source

    expect_assert_message :: proc(t: ^T, expected_message: string, caller_loc := #caller_location) {…}
     

    Let the test runner know that it should expect an assertion failure with a specific message for this test.

    In the event that an assertion fails, a debug message will be logged with its exact message and location in a copyable format to make it convenient to write tests which use this API.

    This procedure may be called up to 5 times with different messages.

    This is a limitation for the sake of simplicity in the implementation, and you should consider breaking up your tests into smaller procedures if you need to check for more than a couple different assertion messages.

    expect_leaks ¶
    Source

    expect_leaks :: proc(t: ^T, client_test: proc(t: ^T), verifier: Memory_Verifier_Proc) {…}

    expect_signal ¶
    Source

    expect_signal :: proc(t: ^T, #any_int sig: i32) {…}
     

    Let the test runner know that it should expect a signal to be raised within this test.

    This API is for advanced users, as arbitrary signals will not be caught; only the ones already handled by the test runner, such as

    SIGINT, (interrupt) SIGTERM, (polite termination) SIGILL, (illegal instruction) SIGFPE, (arithmetic error) SIGSEGV, and (segmentation fault) SIGTRAP (only on POSIX systems). (trap / debug trap)

    Note that only one signal can be expected per test.

    expect_value ¶
    Source

    expect_value :: proc(t: ^T, value, expected: $T, loc := #caller_location, value_expr: string = #caller_expression(value)) -> bool {…}

    expectf ¶
    Source

    expectf :: proc(t: ^T, ok: bool, format: string, .. args: ..any, loc := #caller_location) -> bool {…}

    fail ¶
    Source

    fail :: proc(t: ^T, loc := #caller_location) {…}

    fail_now ¶
    Source

    fail_now :: proc(t: ^T, msg: string = "", loc := #caller_location) -> ! {…}
     

    fail_now will cause a test to immediately fail and abort, much in the same way a failed assertion or panic call will stop a thread.

    It is for when you absolutely need a test to fail without calling any of its deferred statements. It will be cleaner than a regular assert or panic, as the test runner will know to expect the signal this procedure will raise.

    failed ¶
    Source

    failed :: proc(t: ^T) -> bool {…}

    set_fail_timeout ¶
    Source

    set_fail_timeout :: proc(t: ^T, duration: time.Duration, loc := #caller_location) {…}

    Procedure Groups

    expect_assert ¶
    Source

    expect_assert :: proc{
	expect_assert_from,
	expect_assert_message,
}

    Source Files

    Generation Information

    Generated with odin version dev-2025-06 (vendor "odin") Windows_amd64 @ 2025-06-16 21:13:24.438111200 +0000 UTC