package core:testing

Source

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

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

Memory_Verifier_Proc :: proc(t: ^T, ta: ^mem.Tracking_Allocator)

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,
}

Test_Signature :: proc(^T)

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

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

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

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

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

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

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

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

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