Merge pull request #6245 from odin-lang/new_os

`core:os/os2` -> `core:os` integration

16 files changed, 290 insertions, 147 deletions

diff --git a/tests/core/encoding/hxa/test_core_hxa.odin b/tests/core/encoding/hxa/test_core_hxa.odin
index a8f3e94f6..a4fee030c 100644
--- a/tests/core/encoding/hxa/test_core_hxa.odin
+++ b/tests/core/encoding/hxa/test_core_hxa.odin
@@ -1,6 +1,3 @@
-// Tests "core:encoding:hxa".
-// Must be run with `-collection:tests=` flag, e.g.
-// ./odin run tests/core/encoding/hxa/test_core_hxa.odin -out=tests/core/test_core_hxa -collection:tests=./tests
 package test_core_hxa
 
 import "core:encoding/hxa"
@@ -13,13 +10,11 @@ import "core:os"
 
 @test
 test_read :: proc(t: ^testing.T) {
-	data, _ := os.read_entire_file(TEAPOT_PATH)
-	// file, err := hxa.read_from_file(TEAPOT_PATH)
+	data, _ := os.read_entire_file(TEAPOT_PATH, context.allocator)
 	file, err := hxa.read(data)
 	file.backing = data
 	file.allocator = context.allocator
 	hxa.file_destroy(file)
-	// fmt.printfln("%#v", file)
 
 	e :: hxa.Read_Error.None
 	testing.expectf(t, err == e, "read_from_file(%v) -> %v != %v", TEAPOT_PATH, err, e)
diff --git a/tests/core/encoding/ini/test_core_ini.odin b/tests/core/encoding/ini/test_core_ini.odin
index 6e6c8152e..8c554c6b5 100644
--- a/tests/core/encoding/ini/test_core_ini.odin
+++ b/tests/core/encoding/ini/test_core_ini.odin
@@ -1,8 +1,7 @@
+#+feature dynamic-literals
 package test_core_ini
 
-import "base:runtime"
 import "core:encoding/ini"
-import "core:mem/virtual"
 import "core:strings"
 import "core:testing"
 
@@ -64,7 +63,7 @@ ini_to_string :: proc(t: ^testing.T) {
 
 	testing.expectf(
 		t,
-		strings.contains(str, "[LEVEL]LOG = debug"),
+		strings.contains(str, "[LEVEL]\nLOG = debug"),
 		"Expected `ini.save_map_to_string` to return a string equal to \"[LEVEL]LOG = debug\", got %v",
 		str,
 	)
diff --git a/tests/core/flags/test_core_flags.odin b/tests/core/flags/test_core_flags.odin
index 0cfcf8e75..834f6b630 100644
--- a/tests/core/flags/test_core_flags.odin
+++ b/tests/core/flags/test_core_flags.odin
@@ -1,16 +1,16 @@
 package test_core_flags
 
-import "base:runtime"
-import "core:bytes"
-import "core:flags"
-import "core:fmt"
-@require import "core:log"
-import "core:math"
-@require import "core:net"
-import "core:os"
-import "core:strings"
-import "core:testing"
-import "core:time/datetime"
+import            "base:runtime"
+import            "core:bytes"
+import            "core:flags"
+import            "core:fmt"
+@(require) import "core:log"
+import            "core:math"
+@(require) import "core:net"
+import            "core:os"
+import            "core:strings"
+import            "core:testing"
+import            "core:time/datetime"
 
 Custom_Data :: struct {
 	a: int,
@@ -1249,7 +1249,7 @@ test_os_handle :: proc(t: ^testing.T) {
 	test_data := "Hellope!"
 
 	W :: struct {
-		outf: os.Handle `args:"file=cw"`,
+		outf: ^os.File `args:"file=cw"`,
 	}
 	w: W
 
@@ -1263,7 +1263,7 @@ test_os_handle :: proc(t: ^testing.T) {
 	os.write_string(w.outf, test_data)
 
 	R :: struct {
-		inf: os.Handle `args:"file=r"`,
+		inf: ^os.File `args:"file=r"`,
 	}
 	r: R
 
@@ -1274,8 +1274,8 @@ test_os_handle :: proc(t: ^testing.T) {
 		return
 	}
 	defer os.close(r.inf)
-	data, read_ok := os.read_entire_file_from_handle(r.inf, context.temp_allocator)
-	testing.expect_value(t, read_ok, true)
+	data, read_err := os.read_entire_file(r.inf, context.temp_allocator)
+	testing.expect_value(t, read_err, nil)
 	file_contents_equal := 0 == bytes.compare(transmute([]u8)test_data, data)
 	testing.expectf(t, file_contents_equal, "expected file contents to be the same, got %v", data)
 }
diff --git a/tests/core/io/test_core_io.odin b/tests/core/io/test_core_io.odin
index 10c9550cb..728771b1b 100644
--- a/tests/core/io/test_core_io.odin
+++ b/tests/core/io/test_core_io.odin
@@ -5,7 +5,6 @@ import "core:bytes"
 import "core:io"
 import "core:log"
 import "core:os"
-import "core:os/os2"
 import "core:strings"
 import "core:testing"
 
@@ -552,49 +551,12 @@ test_os_file_stream :: proc(t: ^testing.T) {
 
 	TEMPORARY_FILENAME :: "test_core_io_os_file_stream"
 
-	fd, open_err := os.open(TEMPORARY_FILENAME, os.O_RDWR | os.O_CREATE | os.O_TRUNC, 0o644)
+	fd, open_err := os.open(TEMPORARY_FILENAME, {.Read, .Write, .Create, .Trunc})
 	if !testing.expectf(t, open_err == nil, "error on opening %q: %v", TEMPORARY_FILENAME, open_err) {
 		return
 	}
-	
-	stream := os.stream_from_handle(fd)
 
-	bytes_written, write_err := io.write(stream, buf[:])
-	if !testing.expectf(t, bytes_written == len(buf) && write_err == nil,
-		"failed to Write initial buffer: bytes_written<%v> != len_buf<%v>, %v", bytes_written, len(buf), write_err) {
-		return
-	}
-
-	flush_err := io.flush(stream)
-	if !testing.expectf(t, flush_err == nil,
-		"failed to Flush initial buffer: %v", write_err) {
-		return
-	}
-
-	results, _ := _test_stream(t, stream, buf[:])
-
-	log.debugf("%#v", results)
-}
-
-@test
-test_os2_file_stream :: proc(t: ^testing.T) {
-	defer if !testing.failed(t) {
-		testing.expect_value(t, os2.remove(TEMPORARY_FILENAME), nil)
-	}
-
-	buf: [32]u8
-	for i in 0..<u8(len(buf)) {
-		buf[i] = 'A' + i
-	}
-
-	TEMPORARY_FILENAME :: "test_core_io_os2_file_stream"
-
-	fd, open_err := os2.open(TEMPORARY_FILENAME, {.Read, .Write, .Create, .Trunc})
-	if !testing.expectf(t, open_err == nil, "error on opening %q: %v", TEMPORARY_FILENAME, open_err) {
-		return
-	}
-
-	stream := os2.to_stream(fd)
+	stream := os.to_stream(fd)
 
 	bytes_written, write_err := io.write(stream, buf[:])
 	if !testing.expectf(t, bytes_written == len(buf) && write_err == nil,
@@ -608,7 +570,7 @@ test_os2_file_stream :: proc(t: ^testing.T) {
 		return
 	}
 
-	// os2 file stream proc close and destroy are the same.
+	// os file stream proc close and destroy are the same.
 	results, _ := _test_stream(t, stream, buf[:], do_destroy = false)
 
 	log.debugf("%#v", results)
@@ -676,10 +638,10 @@ test_bufio_buffered_reader :: proc(t: ^testing.T) {
 
 @test
 test_bufio_buffered_read_writer :: proc(t: ^testing.T) {
-	// Using an os2.File as the backing stream for both reader & writer.
+	// Using an os.File as the backing stream for both reader & writer.
 
 	defer if !testing.failed(t) {
-		testing.expect_value(t, os2.remove(TEMPORARY_FILENAME), nil)
+		testing.expect_value(t, os.remove(TEMPORARY_FILENAME), nil)
 	}
 
 	buf: [32]u8
@@ -687,15 +649,15 @@ test_bufio_buffered_read_writer :: proc(t: ^testing.T) {
 		buf[i] = 'A' + i
 	}
 
-	TEMPORARY_FILENAME :: "test_core_io_bufio_read_writer_os2_file_stream"
+	TEMPORARY_FILENAME :: "test_core_io_bufio_read_writer_os_file_stream"
 
-	fd, open_err := os2.open(TEMPORARY_FILENAME, {.Read, .Write, .Create, .Trunc})
+	fd, open_err := os.open(TEMPORARY_FILENAME, {.Read, .Write, .Create, .Trunc})
 	if !testing.expectf(t, open_err == nil, "error on opening %q: %v", TEMPORARY_FILENAME, open_err) {
 		return
 	}
-	defer testing.expect_value(t, os2.close(fd), nil)
+	defer testing.expect_value(t, os.close(fd), nil)
 
-	stream := os2.to_stream(fd)
+	stream := os.to_stream(fd)
 
 	bytes_written, write_err := io.write(stream, buf[:])
 	if !testing.expectf(t, bytes_written == len(buf) && write_err == nil,
@@ -709,7 +671,7 @@ test_bufio_buffered_read_writer :: proc(t: ^testing.T) {
 		return
 	}
 
-	// bufio.Read_Writer isn't capable of seeking, so we have to reset the os2
+	// bufio.Read_Writer isn't capable of seeking, so we have to reset the os
 	// stream back to the start here.
 	pos, seek_err := io.seek(stream, 0, .Start)
 	if !testing.expectf(t, pos == 0 && seek_err == nil,
diff --git a/tests/core/nbio/fs.odin b/tests/core/nbio/fs.odin
index 6e079f96e..1b10c03c9 100644
--- a/tests/core/nbio/fs.odin
+++ b/tests/core/nbio/fs.odin
@@ -1,9 +1,9 @@
 package tests_nbio
 
-import    "core:nbio"
-import    "core:testing"
-import    "core:time"
-import os "core:os/os2"
+import "core:nbio"
+import "core:testing"
+import "core:time"
+import "core:os"
 
 @(test)
 close_invalid_handle :: proc(t: ^testing.T) {
diff --git a/tests/core/nbio/nbio.odin b/tests/core/nbio/nbio.odin
index 2f454f55b..6c3fd0e8c 100644
--- a/tests/core/nbio/nbio.odin
+++ b/tests/core/nbio/nbio.odin
@@ -1,11 +1,11 @@
 package tests_nbio
 
-import    "core:log"
-import    "core:nbio"
-import    "core:testing"
-import    "core:thread"
-import    "core:time"
-import os "core:os/os2"
+import "core:log"
+import "core:nbio"
+import "core:testing"
+import "core:thread"
+import "core:time"
+import "core:os"
 
 ev :: testing.expect_value
 e  :: testing.expect
diff --git a/tests/core/normal.odin b/tests/core/normal.odin
index d0889bf89..4708ed700 100644
--- a/tests/core/normal.odin
+++ b/tests/core/normal.odin
@@ -18,6 +18,7 @@ download_assets :: proc "contextless" () {
 @(require) import "encoding/cbor"
 @(require) import "encoding/hex"
 @(require) import "encoding/hxa"
+@(require) import "encoding/ini"
 @(require) import "encoding/json"
 @(require) import "encoding/uuid"
 @(require) import "encoding/varint"
@@ -36,8 +37,7 @@ download_assets :: proc "contextless" () {
 @(require) import "net"
 @(require) import "odin"
 @(require) import "os"
-@(require) import "os/os2"
-@(require) import "path/filepath"
+@(require) import "os/old"
 @(require) import "reflect"
 @(require) import "runtime"
 @(require) import "slice"
@@ -53,4 +53,4 @@ download_assets :: proc "contextless" () {
 @(require) import "text/regex"
 @(require) import "thread"
 @(require) import "time"
-@(require) import "unicode"
+@(require) import "unicode"
\ No newline at end of file
diff --git a/tests/core/os/os2/dir.odin b/tests/core/os/dir.odin
index 8ef333219..464abed98 100644
--- a/tests/core/os/os2/dir.odin
+++ b/tests/core/os/dir.odin
@@ -1,14 +1,14 @@
-package tests_core_os_os2
+package tests_core_os
 
-import os "core:os/os2"
-import    "core:log"
-import    "core:slice"
-import    "core:testing"
-import    "core:strings"
+import "core:os"
+import "core:log"
+import "core:slice"
+import "core:testing"
+import "core:strings"
 
 @(test)
 test_read_dir :: proc(t: ^testing.T) {
-	path, err_join := os.join_path({#directory, "../dir"}, context.allocator)
+	path, err_join := os.join_path({#directory, "dir"}, context.allocator)
 	defer delete(path)
 
 	fis, err_read := os.read_all_directory_by_path(path, context.allocator)
@@ -17,7 +17,7 @@ test_read_dir :: proc(t: ^testing.T) {
 	slice.sort_by_key(fis, proc(fi: os.File_Info) -> string { return fi.name })
 
 	if err_read == .Unsupported {
-		log.warn("os2 directory functionality is unsupported, skipping test")
+		log.warn("core:os directory functionality is unsupported, skipping test")
 		return
 	}
 
@@ -34,7 +34,7 @@ test_read_dir :: proc(t: ^testing.T) {
 
 @(test)
 test_walker :: proc(t: ^testing.T) {
-	path, err := os.join_path({#directory, "../dir"}, context.allocator)
+	path, err := os.join_path({#directory, "dir"}, context.allocator)
 	defer delete(path)
 	testing.expect_value(t, err, nil)
 
@@ -46,7 +46,7 @@ test_walker :: proc(t: ^testing.T) {
 
 @(test)
 test_walker_file :: proc(t: ^testing.T) {
-	path, err_join := os.join_path({#directory, "../dir"}, context.allocator)
+	path, err_join := os.join_path({#directory, "dir"}, context.allocator)
 	defer delete(path)
 	testing.expect_value(t, err_join, nil)
 
@@ -95,7 +95,7 @@ test_walker_internal :: proc(t: ^testing.T, w: ^os.Walker) {
 	}
 
 	if _, err := os.walker_error(w); err == .Unsupported {
-		log.warn("os2 directory functionality is unsupported, skipping test")
+		log.warn("core:os directory functionality is unsupported, skipping test")
 		return
 	}
 
diff --git a/tests/core/os/os2/file.odin b/tests/core/os/file.odin
index 0152a2008..aed57c26c 100644
--- a/tests/core/os/os2/file.odin
+++ b/tests/core/os/file.odin
@@ -1,7 +1,7 @@
-package tests_core_os_os2
+package tests_core_os
 
-import os "core:os/os2"
-import    "core:testing"
+import "core:os"
+import "core:testing"
 
 @(test)
 test_clone :: proc(t: ^testing.T) {
diff --git a/tests/core/os/os.odin b/tests/core/os/old/os.odin
index 1510bad31..9925cf708 100644
--- a/tests/core/os/os.odin
+++ b/tests/core/os/old/os.odin
@@ -1,8 +1,8 @@
-package test_core_os
+package test_core_os_old
 
 import "core:c/libc"
 import win32 "core:sys/windows"
-import "core:os"
+import os "core:os/old"
 import "core:slice"
 import "core:testing"
 import "core:log"
diff --git a/tests/core/os/os2/path.odin b/tests/core/os/path.odin
index 7b1cb0146..cdfaed56f 100644
--- a/tests/core/os/os2/path.odin
+++ b/tests/core/os/path.odin
@@ -1,9 +1,11 @@
-package tests_core_os_os2
+package tests_core_os
 
-import os "core:os/os2"
-import    "core:log"
-import    "core:testing"
-import    "core:strings"
+import "core:fmt"
+import "core:os"
+import "core:log"
+import "core:testing"
+import "core:slice"
+import "core:strings"
 
 @(test)
 test_executable :: proc(t: ^testing.T) {
@@ -334,6 +336,77 @@ test_join_filename :: proc(t: ^testing.T) {
 	}
 }
 
+Glob_Test :: struct {
+	pattern: string,
+	matches: []string,
+	err:     os.Error,
+}
+
+glob_tests := []Glob_Test{
+	{
+		pattern = ODIN_ROOT + "tests/core/os/*/*.txt",
+		matches = {
+			ODIN_ROOT + "tests/core/os/dir/b.txt",
+		},
+		err     = {},
+	},
+	{
+		pattern = ODIN_ROOT + "tests/core/os/*.odin",
+		matches = {
+			ODIN_ROOT + "tests/core/os/dir.odin",
+			ODIN_ROOT + "tests/core/os/file.odin",
+			ODIN_ROOT + "tests/core/os/path.odin",
+			ODIN_ROOT + "tests/core/os/process.odin",
+		},
+		err     = {},
+	},
+}
+
+@(test)
+test_glob :: proc(t: ^testing.T) {
+	compare_matches :: proc(t: ^testing.T, pattern: string, globbed, expected: []string) {
+		glob_fold   := make([]string, len(globbed), context.temp_allocator)
+		expect_fold := make([]string, len(globbed), context.temp_allocator)
+
+		for glob, i in globbed {
+			// If `glob` returned a path in response to a pattern,
+			// then `match` should consider that path a match, too,
+			// irrespective of `/` versus `\` presence.
+			no_match_msg := fmt.tprintf("Expected os.match(%q, %q) to be `true`, got `false`", pattern, glob)
+			match, _ := os.match(pattern, glob)
+
+			f, _ := strings.replace_all(glob, `\`, `/`, context.temp_allocator)
+			glob_fold[i] = f
+			testing.expect(t, match, no_match_msg)
+		}
+
+		for exp, i in expected {
+			f, _ := strings.replace_all(exp, `\`, `/`, context.temp_allocator)
+			expect_fold[i] = f
+		}
+
+		slice.sort(glob_fold)
+		slice.sort(expect_fold)
+
+		not_equal_msg := fmt.tprintf("Expected os.glob(%q) to return %v, got %v", pattern, glob_fold, expect_fold)
+		testing.expect(t, slice.equal(glob_fold, expect_fold), not_equal_msg)
+	}
+
+	for glob in glob_tests {
+		globbed, err := os.glob(glob.pattern, context.allocator)
+		defer {
+			for file in globbed {
+				delete(file)
+			}
+			delete(globbed)
+		}
+		testing.expect_value(t, err, glob.err)
+		compare_matches(t, glob.pattern, globbed, glob.matches)
+	}
+}
+
+
+// TODO: merge this and `test_split_list`
 @(test)
 test_split_path_list :: proc(t: ^testing.T) {
 	Test_Case :: struct {
@@ -375,3 +448,115 @@ test_split_path_list :: proc(t: ^testing.T) {
 		}
 	}
 }
+
+@(test)
+test_split_list :: proc(t: ^testing.T) {
+	when ODIN_OS == .Windows {
+		test_split_list_windows(t)
+	} else {
+		test_split_list_unix(t)
+	}
+}
+
+test_split_list_windows :: proc(t: ^testing.T) {
+	Datum :: struct {
+		i: int,
+		v: string,
+		e: [3]string,
+	}
+	@static data := []Datum{
+		{ 0, "C:\\Odin;C:\\Visual Studio;\"C:\\Some Other\"",
+			[3]string{"C:\\Odin", "C:\\Visual Studio", "C:\\Some Other"} }, // Issue #1537
+		{ 1, "a;;b", [3]string{"a", "", "b"} },
+		{ 2, "a;b;", [3]string{"a", "b", ""} },
+		{ 3, ";a;b", [3]string{"", "a", "b"} },
+		{ 4, ";;", [3]string{"", "", ""} },
+		{ 5, "\"a;b\"c;d;\"f\"", [3]string{"a;bc", "d", "f"} },
+		{ 6, "\"a;b;c\";d\";e\";f", [3]string{"a;b;c", "d;e", "f"} },
+	}
+
+	for d, i in data {
+		assert(i == d.i, fmt.tprintf("wrong data index: i %d != d.i %d\n", i, d.i))
+		r, err := os.split_path_list(d.v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		defer delete_split(r)
+		testing.expect(t, len(r) == len(d.e), fmt.tprintf("i:%d %s(%s) len(r) %d != len(d.e) %d", i, #procedure, d.v, len(r), len(d.e)))
+		if len(r) == len(d.e) {
+			for _, j in r {
+				testing.expect(t, r[j] == d.e[j], fmt.tprintf("i:%d %s(%v) -> %v[%d] != %v", i, #procedure, d.v, r[j], j, d.e[j]))
+			}
+		}
+	}
+
+	{
+		v := ""
+		r, err := os.split_path_list(v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		defer delete_split(r)
+		testing.expect(t, r == nil, fmt.tprintf("%s(%s) -> %v != nil", #procedure, v, r))
+	}
+	{
+		v := "a"
+		r, err := os.split_path_list(v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		defer delete_split(r)
+		testing.expect(t, len(r) == 1, fmt.tprintf("%s(%s) len(r) %d != 1", #procedure, v, len(r)))
+		if len(r) == 1 {
+			testing.expect(t, r[0] == "a", fmt.tprintf("%s(%v) -> %v[0] != a", #procedure, v, r[0]))
+		}
+	}
+}
+
+test_split_list_unix :: proc(t: ^testing.T) {
+	Datum :: struct {
+		v: string,
+		e: [3]string,
+	}
+	@static data := []Datum{
+		{ "/opt/butler:/home/fancykillerpanda/Projects/Odin/Odin:/usr/local/sbin",
+			[3]string{"/opt/butler", "/home/fancykillerpanda/Projects/Odin/Odin", "/usr/local/sbin"} }, // Issue #1537
+		{ "a::b", [3]string{"a", "", "b"} },
+		{ "a:b:", [3]string{"a", "b", ""} },
+		{ ":a:b", [3]string{"", "a", "b"} },
+		{ "::", [3]string{"", "", ""} },
+		{ "\"a:b\"c:d:\"f\"", [3]string{"a:bc", "d", "f"} },
+		{ "\"a:b:c\":d\":e\":f", [3]string{"a:b:c", "d:e", "f"} },
+	}
+
+	for d in data {
+		r, err := os.split_path_list(d.v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		defer delete_split(r)
+		testing.expectf(t, len(r) == len(d.e), "%s len(r) %d != len(d.e) %d", d.v, len(r), len(d.e))
+		if len(r) == len(d.e) {
+			for _, j in r {
+				testing.expectf(t, r[j] == d.e[j], "%v -> %v[%d] != %v", d.v, r[j], j, d.e[j])
+			}
+		}
+	}
+
+	{
+		v := ""
+		r, err := os.split_path_list(v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		testing.expectf(t, r == nil, "'%s' -> '%v' != nil", v, r)
+	}
+	{
+		v := "a"
+		r, err := os.split_path_list(v, context.allocator)
+		testing.expectf(t, err == nil, "Expected err to be nil, got %v", err)
+		defer delete_split(r)
+		testing.expectf(t, len(r) == 1, "'%s' len(r) %d != 1", v, len(r))
+		if len(r) == 1 {
+			testing.expectf(t, r[0] == "a", "'%v' -> %v[0] != a", v, r[0])
+		}
+	}
+}
+
+@(private)
+delete_split :: proc(s: []string) {
+	for part in s {
+		delete(part)
+	}
+	delete(s)
+}
\ No newline at end of file
diff --git a/tests/core/os/os2/process.odin b/tests/core/os/process.odin
index c530b4c79..adb65e95f 100644
--- a/tests/core/os/os2/process.odin
+++ b/tests/core/os/process.odin
@@ -1,9 +1,9 @@
 #+build !windows
-package tests_core_os_os2
+package tests_core_os
 
-import os "core:os/os2"
-import    "core:log"
-import    "core:testing"
+import "core:os"
+import "core:log"
+import "core:testing"
 
 @(test)
 test_process_exec :: proc(t: ^testing.T) {
diff --git a/tests/core/path/filepath/test_core_filepath.odin b/tests/core/path/filepath/test_core_filepath.odin
index f0137f69b..a0de7e831 100644
--- a/tests/core/path/filepath/test_core_filepath.odin
+++ b/tests/core/path/filepath/test_core_filepath.odin
@@ -33,7 +33,7 @@ test_split_list_windows :: proc(t: ^testing.T) {
 
 	for d, i in data {
 		assert(i == d.i, fmt.tprintf("wrong data index: i %d != d.i %d\n", i, d.i))
-		r := filepath.split_list(d.v)
+		r, _ := filepath.split_list(d.v, context.allocator)
 		defer delete_split(r)
 		testing.expect(t, len(r) == len(d.e), fmt.tprintf("i:%d %s(%s) len(r) %d != len(d.e) %d", i, #procedure, d.v, len(r), len(d.e)))
 		if len(r) == len(d.e) {
@@ -45,13 +45,13 @@ test_split_list_windows :: proc(t: ^testing.T) {
 
 	{
 		v := ""
-		r := filepath.split_list(v)
+		r, _ := filepath.split_list(v, context.allocator)
 		defer delete_split(r)
 		testing.expect(t, r == nil, fmt.tprintf("%s(%s) -> %v != nil", #procedure, v, r))
 	}
 	{
 		v := "a"
-		r := filepath.split_list(v)
+		r, _ := filepath.split_list(v, context.allocator)
 		defer delete_split(r)
 		testing.expect(t, len(r) == 1, fmt.tprintf("%s(%s) len(r) %d != 1", #procedure, v, len(r)))
 		if len(r) == 1 {
@@ -77,7 +77,7 @@ test_split_list_unix :: proc(t: ^testing.T) {
 	}
 
 	for d in data {
-		r := filepath.split_list(d.v)
+		r, _ := filepath.split_list(d.v, context.allocator)
 		defer delete_split(r)
 		testing.expectf(t, len(r) == len(d.e), "%s len(r) %d != len(d.e) %d", d.v, len(r), len(d.e))
 		if len(r) == len(d.e) {
@@ -89,12 +89,12 @@ test_split_list_unix :: proc(t: ^testing.T) {
 
 	{
 		v := ""
-		r := filepath.split_list(v)
+		r, _ := filepath.split_list(v, context.allocator)
 		testing.expectf(t, r == nil, "'%s' -> '%v' != nil", v, r)
 	}
 	{
 		v := "a"
-		r := filepath.split_list(v)
+		r, _ := filepath.split_list(v, context.allocator)
 		defer delete_split(r)
 		testing.expectf(t, len(r) == 1, "'%s' len(r) %d != 1", v, len(r))
 		if len(r) == 1 {
diff --git a/tests/core/sys/kqueue/structs.odin b/tests/core/sys/kqueue/structs.odin
index edf1fdd1e..15ec3f841 100644
--- a/tests/core/sys/kqueue/structs.odin
+++ b/tests/core/sys/kqueue/structs.odin
@@ -1,9 +1,9 @@
 #+build darwin, freebsd, openbsd, netbsd
 package tests_core_sys_kqueue
 
-import    "core:strings"
-import    "core:testing"
-import os "core:os/os2"
+import "core:strings"
+import "core:testing"
+import "core:os"
 
 @(test)
 structs :: proc(t: ^testing.T) {
diff --git a/tests/core/time/test_core_time.odin b/tests/core/time/test_core_time.odin
index cd2b19fb8..6e5e47696 100644
--- a/tests/core/time/test_core_time.odin
+++ b/tests/core/time/test_core_time.odin
@@ -2,6 +2,7 @@ package test_core_time
 
 import "core:testing"
 import "core:time"
+@(require) import "core:log"
 import dt "core:time/datetime"
 import tz "core:time/timezone"
 
@@ -364,9 +365,10 @@ test_convert_timezone_roundtrip :: proc(t: ^testing.T) {
 	std_dt, _ := dt.components_to_datetime(2024, 11, 4, 23, 47, 0)
 
 	local_tz, local_load_ok := tz.region_load("local")
-	testing.expectf(t, local_load_ok, "Failed to load local timezone")
 	defer tz.region_destroy(local_tz)
 
+	testing.expectf(t, local_load_ok, "Failed to load local timezone")
+
 	edm_tz, edm_load_ok := tz.region_load("America/Edmonton")
 	testing.expectf(t, edm_load_ok, "Failed to load America/Edmonton timezone")
 	defer tz.region_destroy(edm_tz)
diff --git a/tests/documentation/documentation_tester.odin b/tests/documentation/documentation_tester.odin
index 7b125d4e4..be59d9b4d 100644
--- a/tests/documentation/documentation_tester.odin
+++ b/tests/documentation/documentation_tester.odin
@@ -1,12 +1,11 @@
 package documentation_tester
 
-import "core:os"
-import "core:io"
-import "core:fmt"
-import "core:strings"
-import "core:odin/ast"
-import "core:odin/parser"
-import "core:c/libc"
+import     "core:os"
+import     "core:fmt"
+import     "core:strings"
+import     "core:odin/ast"
+import     "core:odin/parser"
+import     "core:c/libc"
 import doc "core:odin/doc-format"
 
 Example_Test :: struct {
@@ -63,10 +62,11 @@ main :: proc() {
 		errorf("expected path to odin executable")
 	}
 	g_path_to_odin = os.args[1]
-	data, ok := os.read_entire_file("all.odin-doc")
-	if !ok {
+	data, data_err := os.read_entire_file("all.odin-doc", context.allocator)
+	if data_err != nil {
 		errorf("unable to read file: all.odin-doc")
 	}
+	defer delete(data)
 	err: doc.Reader_Error
 	g_header, err = doc.read_from_bytes(data)
 	switch err {
@@ -257,8 +257,8 @@ find_and_add_examples :: proc(docs: string, package_name: string, entity_name: s
 
 write_test_suite :: proc(example_tests: []Example_Test) {
 	TEST_SUITE_DIRECTORY :: "verify"
-	os.remove_directory(TEST_SUITE_DIRECTORY)
-	os.make_directory(TEST_SUITE_DIRECTORY)
+	os.remove_all(TEST_SUITE_DIRECTORY)
+	os.mkdir(TEST_SUITE_DIRECTORY)
 
 	example_build := strings.builder_make()
 	test_runner := strings.builder_make()
@@ -276,9 +276,11 @@ import "core:sync"
 import "base:intrinsics"
 
 @(private="file")
-_read_pipe: os.Handle
+_read_pipe:  ^os.File
+@(private="file")
+_write_pipe: ^os.File
 @(private="file")
-_write_pipe: os.Handle
+_old_stdout: ^os.File
 @(private="file")
 _pipe_reader_semaphore: sync.Sema
 @(private="file")
@@ -286,20 +288,20 @@ _out_data: string
 @(private="file")
 _out_buffer: [mem.Megabyte]byte
 @(private="file")
-_bad_test_found: bool
+_bad_count: int
+@(private="file")
+_good_count: int
 
 @(private="file")
 _spawn_pipe_reader :: proc() {
 	thread.run(proc() {
-		stream := os.stream_from_handle(_read_pipe)
-		reader := io.to_reader(stream)
 		sync.post(&_pipe_reader_semaphore) // notify thread is ready
 		for {
 			n_read := 0
 			read_to_null_byte := 0
 			finished_reading := false
 			for ! finished_reading {
-				just_read, err := io.read(reader, _out_buffer[n_read:], &n_read); if err != .None {
+				just_read, err := io.read(os.to_stream(_read_pipe), _out_buffer[n_read:], &n_read); if err != .None {
 					panic("We got an IO error!")
 				}
 				for b in _out_buffer[n_read - just_read: n_read] {
@@ -328,11 +330,14 @@ _check :: proc(test_name: string, expected: string) {
 	if expected != output {
 		fmt.eprintf("Test %q got unexpected output:\n%q\n", test_name, output)
 		fmt.eprintf("Expected:\n%q\n", expected)
-		_bad_test_found = true
+		_bad_count += 1
+	} else {
+		_good_count += 1
 	}
 }
 
 main :: proc() {
+	_old_stdout = os.stdout
 	_read_pipe, _write_pipe, _ = os.pipe()
 	os.stdout = _write_pipe
 	_spawn_pipe_reader()
@@ -445,24 +450,19 @@ main :: proc() {
 			continue
 		}
 		defer os.close(test_file_handle)
-		stream := os.stream_from_handle(test_file_handle)
-		writer, ok := io.to_writer(stream); if ! ok {
-			fmt.eprintf("We could not make the writer for the path %q\n", save_path)
-			g_bad_doc = true
-			continue
-		}
-		fmt.wprintf(writer, "%v%v_%v", code_string[:index_of_proc_name], test.package_name, code_string[index_of_proc_name:])
+		fmt.wprintf(os.to_stream(test_file_handle), "%v%v_%v", code_string[:index_of_proc_name], test.package_name, code_string[index_of_proc_name:])
 		fmt.println("Done")
 	}
 
 	strings.write_string(&test_runner,
 `
-	if _bad_test_found {
+	fmt.wprintfln(os.to_stream(_old_stdout), "Passes: %v. Fails: %v", _good_count, _bad_count)
+	if _bad_count > 0 {
 		fmt.eprintln("One or more tests failed")
 		os.exit(1)
 	}
 }`)
-	os.write_entire_file("verify/main.odin", transmute([]byte)strings.to_string(test_runner))
+	_ = os.write_entire_file("verify/main.odin", transmute([]byte)strings.to_string(test_runner))
 }
 
 run_test_suite :: proc() -> bool {