Refactor the test runner

Changes

- Support multi-threaded testing.
- Support `set_fail_timeout` on all platforms.
- Display an animated progress report.
- Setup all tests with a context logger.
- Give all tests their own separate custom allocators.
- Support tracking test memory usage.
- Display a summary of the failed tests at the end.
- Let users select only specific tests to run.
- Support copying failed tests to the clipboard to run again.
- Support catching SIGINT (CTRL-C) to cancel early.
- Record context in cleanup procs.
- Write all log messages to STDERR for easy redirection.
- Possibly more I've forgotten.

New Options

- `-define:test_threads=N`: Specify thread count.
- `-define:test_thread_memory=B`: Specify initial memory block size in bytes to each thread.
- `-define:test_track_memory=true`: Track the memory usage of individual tests.
- `-define:test_fancy=false`: Disable animated progress report.
- `-define:test_select=package.test_name,...`: Run only select tests.
- `-define:test_clipboard=true`: Copy names of failed tests to the clipboard.
- `-define:test_progress_width=24`: Change the width of the animated progress bars.

core/testing/testing.odin

@@ -1,10 +1,11 @@
 package testing
 
-import "core:fmt"
-import "core:io"
-import "core:time"
 import "base:intrinsics"
+import "base:runtime"
+import pkg_log "core:log"
 import "core:reflect"
+import "core:sync/chan"
+import "core:time"
 
 _ :: reflect // alias reflect to nothing to force visibility for -vet
 
@@ -22,44 +23,45 @@ Internal_Test :: struct {
 Internal_Cleanup :: struct {
 	procedure: proc(rawptr),
 	user_data: rawptr,
+	ctx: runtime.Context,
 }
 
 T :: struct {
 	error_count: int,
 
-	w: io.Writer,
+	channel: Update_Channel_Sender,
 
 	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: proc() -> !,
 }
 
 
+@(deprecated="prefer `log.error`")
 error :: proc(t: ^T, args: ..any, loc := #caller_location) {
-	fmt.wprintf(t.w, "%v: ", loc)
-	fmt.wprintln(t.w, ..args)
-	t.error_count += 1
+	pkg_log.error(..args, location = loc)
 }
 
+@(deprecated="prefer `log.errorf`")
 errorf :: proc(t: ^T, format: string, args: ..any, loc := #caller_location) {
-	fmt.wprintf(t.w, "%v: ", loc)
-	fmt.wprintf(t.w, format, ..args)
-	fmt.wprintln(t.w)
-	t.error_count += 1
+	pkg_log.errorf(format, ..args, location = loc)
 }
 
 fail :: proc(t: ^T, loc := #caller_location) {
-	error(t, "FAIL", loc=loc)
-	t.error_count += 1
+	pkg_log.error("FAIL", location=loc)
 }
 
 fail_now :: proc(t: ^T, msg := "", loc := #caller_location) {
 	if msg != "" {
-		error(t, "FAIL:", msg, loc=loc)
+		pkg_log.error("FAIL:", msg, location=loc)
 	} else {
-		error(t, "FAIL", loc=loc)
+		pkg_log.error("FAIL", location=loc)
 	}
-	t.error_count += 1
 	if t._fail_now != nil {
 		t._fail_now()
 	}
@@ -69,32 +71,34 @@ failed :: proc(t: ^T) -> bool {
 	return t.error_count != 0
 }
 
+@(deprecated="prefer `log.info`")
 log :: proc(t: ^T, args: ..any, loc := #caller_location) {
-	fmt.wprintln(t.w, ..args)
+	pkg_log.info(..args, location = loc)
 }
 
+@(deprecated="prefer `log.infof`")
 logf :: proc(t: ^T, format: string, args: ..any, loc := #caller_location) {
-	fmt.wprintf(t.w, format, ..args)
-	fmt.wprintln(t.w)
+	pkg_log.infof(format, ..args, location = loc)
 }
 
 
-// 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.
+// 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.
 cleanup :: proc(t: ^T, procedure: proc(rawptr), user_data: rawptr) {
-	append(&t.cleanups, Internal_Cleanup{procedure, user_data})
+	append(&t.cleanups, Internal_Cleanup{procedure, user_data, context})
 }
 
 expect :: proc(t: ^T, ok: bool, msg: string = "", loc := #caller_location) -> bool {
 	if !ok {
-		error(t, msg, loc=loc)
+		pkg_log.error(msg, location=loc)
 	}
 	return ok
 }
 
 expectf :: proc(t: ^T, ok: bool, format: string, args: ..any, loc := #caller_location) -> bool {
 	if !ok {
-		errorf(t, format, ..args, loc=loc)
+		pkg_log.errorf(format, ..args, location=loc)
 	}
 	return ok
 }
@@ -102,12 +106,15 @@ expectf :: proc(t: ^T, ok: bool, format: string, args: ..any, loc := #caller_loc
 expect_value :: proc(t: ^T, value, expected: $T, loc := #caller_location) -> bool where intrinsics.type_is_comparable(T) {
 	ok := value == expected || reflect.is_nil(value) && reflect.is_nil(expected)
 	if !ok {
-		errorf(t, "expected %v, got %v", expected, value, loc=loc)
+		pkg_log.errorf("expected %v, got %v", expected, value, location=loc)
 	}
 	return ok
 }
 
 
 set_fail_timeout :: proc(t: ^T, duration: time.Duration, loc := #caller_location) {
-	_fail_timeout(t, duration, loc)
+	chan.send(t.channel, Event_Set_Fail_Timeout {
+		at_time = time.time_add(time.now(), duration),
+		location = loc,
+	})
 }