Merge branch 'master' into xml

36 files changed, 2784 insertions, 172 deletions

diff --git a/tests/common/common.odin b/tests/common/common.odin
new file mode 100644
index 000000000..07b6afef9
--- /dev/null
+++ b/tests/common/common.odin
@@ -0,0 +1,75 @@
+// Boilerplate for tests
+package common
+
+import "core:testing"
+import "core:fmt"
+import "core:os"
+import "core:strings"
+
+TEST_count := 0
+TEST_fail  := 0
+
+when ODIN_TEST {
+	expect  :: testing.expect
+	log     :: testing.log
+} else {
+	expect  :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
+		TEST_count += 1
+		if !condition {
+			TEST_fail += 1
+			fmt.printf("[%v] FAIL %v\n", loc, message)
+			return
+		}
+	}
+	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
+	}
+}
+
+report :: proc(t: ^testing.T) {
+	if TEST_fail > 0 {
+		if TEST_fail > 1 {
+			fmt.printf("%v/%v tests successful, %v tests failed.\n", TEST_count - TEST_fail, TEST_count, TEST_fail)
+		} else {
+			fmt.printf("%v/%v tests successful, 1 test failed.\n", TEST_count - TEST_fail, TEST_count)
+		}
+		os.exit(1)
+	} else {
+		fmt.printf("%v/%v tests successful.\n", TEST_count, TEST_count)
+	}
+}
+
+// Returns absolute path to `sub_path` where `sub_path` is within the "tests/" sub-directory of the Odin project root
+// and we're being run from the Odin project root or from a sub-directory of "tests/"
+// e.g. get_data_path("assets/blah") will return "/Odin_root/tests/assets/blah" if run within "/Odin_root",
+// "/Odin_root/tests" or "/Odin_root/tests/subdir" etc
+get_data_path :: proc(t: ^testing.T, sub_path: string) -> (data_path: string) {
+
+	cwd := os.get_current_directory()
+	defer delete(cwd)
+
+	when ODIN_OS == .Windows {
+		norm, was_allocation := strings.replace_all(cwd, "\\", "/")
+		if !was_allocation {
+			norm = strings.clone(norm)
+		}
+		defer delete(norm)
+	} else {
+		norm := cwd
+	}
+
+	last_index := strings.last_index(norm, "/tests/")
+	if last_index == -1 {
+		len := len(norm)
+		if len >= 6 && norm[len-6:] == "/tests" {
+			data_path = fmt.tprintf("%s/%s", norm, sub_path)
+		} else {
+			data_path = fmt.tprintf("%s/tests/%s", norm, sub_path)
+		}
+	} else {
+		data_path = fmt.tprintf("%s/tests/%s", norm[:last_index], sub_path)
+	}
+
+	return data_path
+}
diff --git a/tests/core/Makefile b/tests/core/Makefile
index e17dede90..2c24fef75 100644
--- a/tests/core/Makefile
+++ b/tests/core/Makefile
@@ -1,29 +1,46 @@
 ODIN=../../odin
 PYTHON=$(shell which python3)
 
-all: download_test_assets image_test compress_test strings_test hash_test crypto_test encoding_test
+all: download_test_assets image_test compress_test strings_test hash_test crypto_test noise_test encoding_test \
+	 math_test linalg_glsl_math_test filepath_test reflect_test os_exit_test
 
 download_test_assets:
 	$(PYTHON) download_assets.py
 
 image_test:
-	$(ODIN) run image/test_core_image.odin -out=test_image -o:speed -no-bounds-check
+	$(ODIN) run image/test_core_image.odin -file -out:test_core_image
 
 compress_test:
-	$(ODIN) run compress/test_core_compress.odin -out=test_compress -o:speed -no-bounds-check
+	$(ODIN) run compress/test_core_compress.odin -file -out:test_core_compress
 
 strings_test:
-	$(ODIN) run strings/test_core_strings.odin -out=test_strings -o:speed -no-bounds-check
-
-odin_test:
-	$(ODIN) run odin -out=test_odin -o:speed -no-bounds-check
+	$(ODIN) run strings/test_core_strings.odin -file -out:test_core_strings
 
 hash_test:
-	$(ODIN) run hash -out=test_hash -o:speed -no-bounds-check
+	$(ODIN) run hash -o:speed -no-bounds-check -out:test_hash 
 
 crypto_test:
-	$(ODIN) run crypto -out=crypto_hash -o:speed -no-bounds-check
+	$(ODIN) run crypto -o:speed -no-bounds-check -out:test_crypto_hash 
+
+noise_test:
+	$(ODIN) run math/noise -out:test_noise
 
 encoding_test:
-	$(ODIN) run encoding/json -out=test_encoding_json -o:speed -no-bounds-check
-	$(ODIN) run encoding/xml  -out=test_encoding_xml  -o:speed -no-bounds-check
+	$(ODIN) run encoding/hxa -collection:tests=.. -out:test_hxa
+	$(ODIN) run encoding/json -out:test_json
+	$(ODIN) run encoding/varint -out:test_varint
+
+math_test:
+	$(ODIN) run math/test_core_math.odin -file -collection:tests=.. -out:test_core_math
+
+linalg_glsl_math_test:
+	$(ODIN) run math/linalg/glsl/test_linalg_glsl_math.odin -file -collection:tests=.. -out:test_linalg_glsl_math
+
+filepath_test:
+	$(ODIN) run path/filepath/test_core_filepath.odin -file -collection:tests=.. -out:test_core_filepath
+
+reflect_test:
+	$(ODIN) run reflect/test_core_reflect.odin -file -collection:tests=.. -out:test_core_reflect
+
+os_exit_test:
+	$(ODIN) run os/test_core_os_exit.odin -file -out:test_core_os_exit && exit 1 || exit 0
\ No newline at end of file
diff --git a/tests/core/assets/HXA/teapot.hxa b/tests/core/assets/HXA/teapot.hxa
new file mode 100644
index 000000000..954ab5a10
--- /dev/null
+++ b/tests/core/assets/HXA/teapot.hxa
diff --git a/tests/core/assets/Shoco/LICENSE b/tests/core/assets/Shoco/LICENSE
new file mode 100644
index 000000000..9ca94bcdf
--- /dev/null
+++ b/tests/core/assets/Shoco/LICENSE
@@ -0,0 +1,26 @@
+Copyright (c) 2016-2021 Ginger Bill. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/core/assets/Shoco/LICENSE.shoco b/tests/core/assets/Shoco/LICENSE.shoco
new file mode 100644
index 000000000..5d5e4d623
--- /dev/null
+++ b/tests/core/assets/Shoco/LICENSE.shoco
diff --git a/tests/core/assets/Shoco/README.md b/tests/core/assets/Shoco/README.md
new file mode 100644
index 000000000..9e46f80d0
--- /dev/null
+++ b/tests/core/assets/Shoco/README.md
@@ -0,0 +1,95 @@
+<p align="center">
+    <img src="misc/logo-slim.png" alt="Odin logo" style="width:65%">
+    <br/>
+   The Data-Oriented Language for Sane Software Development.
+    <br/>
+    <br/>
+    <a href="https://github.com/odin-lang/odin/releases/latest">
+        <img src="https://img.shields.io/github/release/odin-lang/odin.svg">
+    </a>
+    <a href="https://github.com/odin-lang/odin/releases/latest">
+        <img src="https://img.shields.io/badge/platforms-Windows%20|%20Linux%20|%20macOS-green.svg">
+    </a>
+    <br>
+    <a href="https://discord.gg/odinlang">
+        <img src="https://img.shields.io/discord/568138951836172421?logo=discord">
+    </a>
+    <a href="https://github.com/odin-lang/odin/actions">
+        <img src="https://github.com/odin-lang/odin/workflows/CI/badge.svg?branch=master&event=push">
+    </a>
+</p>
+
+# The Odin Programming Language
+
+
+Odin is a general-purpose programming language with distinct typing, built for high performance, modern systems, and built-in data-oriented data types. The Odin Programming Language, the C alternative for the joy of programming.
+
+Website: [https://odin-lang.org/](https://odin-lang.org/)
+
+```odin
+package main
+
+import "core:fmt"
+
+main :: proc() {
+	program := "+ + * 😃 - /"
+	accumulator := 0
+
+	for token in program {
+		switch token {
+		case '+': accumulator += 1
+		case '-': accumulator -= 1
+		case '*': accumulator *= 2
+		case '/': accumulator /= 2
+		case '😃': accumulator *= accumulator
+		case: // Ignore everything else
+		}
+	}
+
+	fmt.printf("The program \"%s\" calculates the value %d\n",
+	           program, accumulator)
+}
+
+```
+
+## Documentation
+
+#### [Getting Started](https://odin-lang.org/docs/install)
+
+Instructions for downloading and installing the Odin compiler and libraries.
+
+#### [Nightly Builds](https://odin-lang.org/docs/nightly/)
+
+Get the latest nightly builds of Odin.
+
+### Learning Odin
+
+#### [Overview of Odin](https://odin-lang.org/docs/overview)
+
+An overview of the Odin programming language.
+
+#### [Frequently Asked Questions (FAQ)](https://odin-lang.org/docs/faq)
+
+Answers to common questions about Odin.
+
+#### [Packages](https://pkg.odin-lang.org/)
+
+Documentation for all the official packages part of the [core](https://pkg.odin-lang.org/core/) and [vendor](https://pkg.odin-lang.org/vendor/) library collections.
+
+#### [The Odin Wiki](https://github.com/odin-lang/Odin/wiki)
+
+A wiki maintained by the Odin community.
+
+#### [Odin Discord](https://discord.gg/sVBPHEv)
+
+Get live support and talk with other odiners on the Odin Discord.
+
+### Articles
+
+#### [The Odin Blog](https://odin-lang.org/news/)
+
+The official blog of the Odin programming language, featuring announcements, news, and in-depth articles by the Odin team and guests.
+
+## Warnings
+
+* The Odin compiler is still in development.
diff --git a/tests/core/assets/Shoco/README.md.shoco b/tests/core/assets/Shoco/README.md.shoco
new file mode 100644
index 000000000..013f4f469
--- /dev/null
+++ b/tests/core/assets/Shoco/README.md.shoco
diff --git a/tests/core/build.bat b/tests/core/build.bat
index 7a214acc9..b03fef4bb 100644
--- a/tests/core/build.bat
+++ b/tests/core/build.bat
@@ -1,39 +1,65 @@
 @echo off

-set COMMON=-show-timings -no-bounds-check -vet -strict-style

+set COMMON=-show-timings -no-bounds-check -vet -strict-style -collection:tests=..

 set PATH_TO_ODIN==..\..\odin

 python3 download_assets.py

 echo ---

 echo Running core:image tests

 echo ---

-%PATH_TO_ODIN% run image    %COMMON% -out:test_image.exe

+%PATH_TO_ODIN% run image    %COMMON% -out:test_core_image.exe

 

 echo ---

 echo Running core:compress tests

 echo ---

-%PATH_TO_ODIN% run compress %COMMON% -out:test_compress.exe

+%PATH_TO_ODIN% run compress %COMMON% -out:test_core_compress.exe

 

 echo ---

 echo Running core:strings tests

 echo ---

-%PATH_TO_ODIN% run strings %COMMON% -out:test_strings.exe

+%PATH_TO_ODIN% run strings %COMMON% -out:test_core_strings.exe

 

 echo ---

 echo Running core:hash tests

 echo ---

-%PATH_TO_ODIN% run hash %COMMON% -o:size -out:test_hash.exe

+%PATH_TO_ODIN% run hash %COMMON% -o:size -out:test_core_hash.exe

 

 echo ---

 echo Running core:odin tests

 echo ---

-%PATH_TO_ODIN% run odin %COMMON% -o:size -out:test_odin.exe

+%PATH_TO_ODIN% run odin %COMMON% -o:size -out:test_core_odin.exe

 

 echo ---

 echo Running core:crypto hash tests

 echo ---

-%PATH_TO_ODIN% run crypto %COMMON% -o:speed -out:test_crypto.exe

+%PATH_TO_ODIN% run crypto %COMMON% -out:test_crypto_hash.exe

 

 echo ---

 echo Running core:encoding tests

 echo ---

-%PATH_TO_ODIN% run encoding\json %COMMON% -out:test_json.exe

-%PATH_TO_ODIN% run encoding\xml %COMMON% -out:test_xml.exe
\ No newline at end of file
+%PATH_TO_ODIN% run encoding/hxa %COMMON% -out:test_hxa.exe

+%PATH_TO_ODIN% run encoding/json %COMMON% -out:test_json.exe

+%PATH_TO_ODIN% run encoding/varint %COMMON% -out:test_varint.exe

+

+echo ---

+echo Running core:math/noise tests

+echo ---

+%PATH_TO_ODIN% run math/noise %COMMON% -out:test_noise.exe

+

+echo ---

+echo Running core:math tests

+echo ---

+%PATH_TO_ODIN% run math %COMMON% -out:test_core_math.exe

+

+echo ---

+echo Running core:math/linalg/glsl tests

+echo ---

+%PATH_TO_ODIN% run math/linalg/glsl %COMMON% -out:test_linalg_glsl.exe

+

+echo ---

+echo Running core:path/filepath tests

+echo ---

+%PATH_TO_ODIN% run path/filepath %COMMON% -out:test_core_filepath.exe

+

+echo ---

+echo Running core:reflect tests

+echo ---

+%PATH_TO_ODIN% run reflect %COMMON% -out:test_core_reflect.exe
\ No newline at end of file
diff --git a/tests/core/compress/test_core_compress.odin b/tests/core/compress/test_core_compress.odin
index 908ef12e4..ee7233e52 100644
--- a/tests/core/compress/test_core_compress.odin
+++ b/tests/core/compress/test_core_compress.odin
@@ -7,13 +7,14 @@ package test_core_compress
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
 
-	A test suite for ZLIB, GZIP.
+	A test suite for ZLIB, GZIP and Shoco.
 */
 
 import "core:testing"
 
 import "core:compress/zlib"
 import "core:compress/gzip"
+import "core:compress/shoco"
 
 import "core:bytes"
 import "core:fmt"
@@ -38,7 +39,8 @@ when ODIN_TEST {
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
@@ -47,8 +49,12 @@ main :: proc() {
 	t := testing.T{w=w}
 	zlib_test(&t)
 	gzip_test(&t)
+	shoco_test(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 @test
@@ -130,3 +136,56 @@ gzip_test :: proc(t: ^testing.T) {
 		expect(t, false, error)
 	}
 }
+
+@test
+shoco_test :: proc(t: ^testing.T) {
+
+	Shoco_Tests :: []struct{
+		compressed:     []u8,
+		raw:            []u8,
+		short_pack:     int,
+		short_sentinel: int,
+	}{
+		{ #load("../assets/Shoco/README.md.shoco"), #load("../assets/Shoco/README.md"), 10, 1006 },
+		{ #load("../assets/Shoco/LICENSE.shoco"),   #load("../assets/Shoco/LICENSE"),   25, 68   },
+	}
+
+	for v in Shoco_Tests {
+		expected_raw        := len(v.raw)
+		expected_compressed := len(v.compressed)
+
+		biggest_unpacked := shoco.decompress_bound(expected_compressed)
+		biggest_packed   := shoco.compress_bound(expected_raw)
+
+		buffer := make([]u8, max(biggest_packed, biggest_unpacked))
+		defer delete(buffer)
+
+		size, err := shoco.decompress(v.compressed, buffer[:])
+		msg := fmt.tprintf("Expected `decompress` to return `nil`, got %v", err)
+		expect(t, err == nil, msg)
+
+		msg  = fmt.tprintf("Decompressed %v bytes into %v. Expected to decompress into %v bytes.", len(v.compressed), size, expected_raw)
+		expect(t, size == expected_raw, msg)
+		expect(t, string(buffer[:size]) == string(v.raw), "Decompressed contents don't match.")
+
+		size, err = shoco.compress(string(v.raw), buffer[:])
+		expect(t, err == nil, "Expected `compress` to return `nil`.")
+
+		msg = fmt.tprintf("Compressed %v bytes into %v. Expected to compress into %v bytes.", expected_raw, size, expected_compressed)
+		expect(t, size == expected_compressed, msg)
+
+		size, err = shoco.decompress(v.compressed, buffer[:expected_raw - 10])
+		msg = fmt.tprintf("Decompressing into too small a buffer returned %v, expected `.Output_Too_Short`", err)
+		expect(t, err == .Output_Too_Short, msg)
+
+		size, err = shoco.compress(string(v.raw), buffer[:expected_compressed - 10])
+		msg = fmt.tprintf("Compressing into too small a buffer returned %v, expected `.Output_Too_Short`", err)
+		expect(t, err == .Output_Too_Short, msg)
+
+		size, err = shoco.decompress(v.compressed[:v.short_pack], buffer[:])
+		expect(t, err == .Stream_Too_Short, "Expected `decompress` to return `Stream_Too_Short` because there was no more data after selecting a pack.")
+
+		size, err = shoco.decompress(v.compressed[:v.short_sentinel], buffer[:])
+		expect(t, err == .Stream_Too_Short, "Expected `decompress` to return `Stream_Too_Short` because there was no more data after non-ASCII sentinel.")
+	}
+}
\ No newline at end of file
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index 6d3a9f8e4..636632d71 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -36,6 +36,8 @@ import "core:crypto/sm3"
 import "core:crypto/jh"
 import "core:crypto/groestl"
 import "core:crypto/haval"
+import "core:crypto/siphash"
+import "core:os"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -52,8 +54,9 @@ when ODIN_TEST {
 			return
 		}
 	}
-	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+	log :: proc(t: ^testing.T, v: any, loc := #caller_location) {
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
@@ -111,6 +114,7 @@ main :: proc() {
 	test_haval_192(&t)
 	test_haval_224(&t)
 	test_haval_256(&t)
+	test_siphash_2_4(&t)
 
 	// "modern" crypto tests
 	test_chacha20(&t)
@@ -121,7 +125,10 @@ main :: proc() {
 
 	bench_modern(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 TestHash :: struct {
@@ -198,7 +205,7 @@ test_md5 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha1 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -220,7 +227,7 @@ test_sha1 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha224 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -238,7 +245,7 @@ test_sha224 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha256 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -256,7 +263,7 @@ test_sha256 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha384 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -274,7 +281,7 @@ test_sha384 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha512 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -292,7 +299,7 @@ test_sha512 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha3_224 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -314,7 +321,7 @@ test_sha3_224 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha3_256 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -336,7 +343,7 @@ test_sha3_256 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha3_384 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -358,7 +365,7 @@ test_sha3_384 :: proc(t: ^testing.T) {
 
 @(test)
 test_sha3_512 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -408,7 +415,7 @@ test_shake_256 :: proc(t: ^testing.T) {
 
 @(test)
 test_keccak_224 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -424,7 +431,7 @@ test_keccak_224 :: proc(t: ^testing.T) {
 
 @(test)
 test_keccak_256 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -440,7 +447,7 @@ test_keccak_256 :: proc(t: ^testing.T) {
 
 @(test)
 test_keccak_384 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -456,7 +463,7 @@ test_keccak_384 :: proc(t: ^testing.T) {
 
 @(test)
 test_keccak_512 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
 	// https://www.di-mgt.com.au/sha_testvectors.html
 	test_vectors := [?]TestHash {
@@ -472,7 +479,7 @@ test_keccak_512 :: proc(t: ^testing.T) {
 
 @(test)
 test_whirlpool :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://web.archive.org/web/20171129084214/http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html
 	test_vectors := [?]TestHash {
 		TestHash{"19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3", ""},
@@ -628,7 +635,7 @@ test_blake2s :: proc(t: ^testing.T) {
 
 @(test)
 test_ripemd_128 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
 	test_vectors := [?]TestHash {
 		TestHash{"cdf26213a150dc3ecb610f18f6b38b46", ""},
@@ -648,7 +655,7 @@ test_ripemd_128 :: proc(t: ^testing.T) {
 
 @(test)
 test_ripemd_160 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
 	test_vectors := [?]TestHash {
 		TestHash{"9c1185a5c5e9fc54612808977ee8f548b2258d31", ""},
@@ -668,7 +675,7 @@ test_ripemd_160 :: proc(t: ^testing.T) {
 
 @(test)
 test_ripemd_256 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
 	test_vectors := [?]TestHash {
 		TestHash{"02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d", ""},
@@ -677,7 +684,7 @@ test_ripemd_256 :: proc(t: ^testing.T) {
 		TestHash{"87e971759a1ce47a514d5c914c392c9018c7c46bc14465554afcdf54a5070c0e", "message digest"},
 		TestHash{"649d3034751ea216776bf9a18acc81bc7896118a5197968782dd1fd97d8d5133", "abcdefghijklmnopqrstuvwxyz"},
 		TestHash{"3843045583aac6c8c8d9128573e7a9809afb2a0f34ccc36ea9e72f16f6368e3f", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
-		TestHash{"5740a408ac16b720b84424ae931cbb1fe363d1d0bf4017f1a89f7ea6de77a0b8", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"}, 
+		TestHash{"5740a408ac16b720b84424ae931cbb1fe363d1d0bf4017f1a89f7ea6de77a0b8", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
 	}
 	for v, _ in test_vectors {
 		computed     := ripemd.hash_256(v.str)
@@ -688,7 +695,7 @@ test_ripemd_256 :: proc(t: ^testing.T) {
 
 @(test)
 test_ripemd_320 :: proc(t: ^testing.T) {
-	// Test vectors from 
+	// Test vectors from
 	// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
 	test_vectors := [?]TestHash {
 		TestHash{"22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8", ""},
@@ -813,7 +820,7 @@ test_sm3 :: proc(t: ^testing.T) {
 	test_vectors := [?]TestHash {
 		TestHash{"1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b", ""},
 		TestHash{"66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0", "abc"},
-		TestHash{"debe9ff92275b8a138604889c18e5a4d6fdb70e5387e5765293dcba39c0c5732", "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"}, 
+		TestHash{"debe9ff92275b8a138604889c18e5a4d6fdb70e5387e5765293dcba39c0c5732", "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"},
 		TestHash{"5fdfe814b8573ca021983970fc79b2218c9570369b4859684e2e4c3fc76cb8ea", "The quick brown fox jumps over the lazy dog"},
 		TestHash{"ca27d14a42fc04c1e5ecf574a95a8c2d70ecb5805e9b429026ccac8f28b20098", "The quick brown fox jumps over the lazy cog"},
 	}
@@ -945,7 +952,7 @@ test_haval_128 :: proc(t: ^testing.T) {
 		TestHash{"3caf4a79e81adcd6d1716bcc1cef4573", "message digest"},
 		TestHash{"dc502247fb3eb8376109eda32d361d82", "abcdefghijklmnopqrstuvwxyz"},
 		TestHash{"44068770868768964d1f2c3bff4aa3d8", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
-		TestHash{"de5eb3f7d9eb08fae7a07d68e3047ec6", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},  
+		TestHash{"de5eb3f7d9eb08fae7a07d68e3047ec6", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
 	}
 	for v, _ in test_vectors_3 {
 		computed     := haval.hash_128_3(v.str)
@@ -981,7 +988,7 @@ test_haval_160 :: proc(t: ^testing.T) {
 		TestHash{"43a47f6f1c016207f08be8115c0977bf155346da", "message digest"},
 		TestHash{"eba9fa6050f24c07c29d1834a60900ea4e32e61b", "abcdefghijklmnopqrstuvwxyz"},
 		TestHash{"c30bce448cf8cfe957c141e90c0a063497cdfeeb", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
-		TestHash{"97dc988d97caae757be7523c4e8d4ea63007a4b9", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"}, 
+		TestHash{"97dc988d97caae757be7523c4e8d4ea63007a4b9", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
 	}
 	for v, _ in test_vectors_3 {
 		computed     := haval.hash_160_3(v.str)
@@ -1100,3 +1107,44 @@ test_haval_256 :: proc(t: ^testing.T) {
 		expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
 	}
 }
+
+@(test)
+test_siphash_2_4 :: proc(t: ^testing.T) {
+	// Test vectors from
+	// https://github.com/veorq/SipHash/blob/master/vectors.h
+	test_vectors := [?]u64 {
+		0x726fdb47dd0e0e31, 0x74f839c593dc67fd, 0x0d6c8009d9a94f5a, 0x85676696d7fb7e2d,
+		0xcf2794e0277187b7, 0x18765564cd99a68d, 0xcbc9466e58fee3ce, 0xab0200f58b01d137,
+		0x93f5f5799a932462, 0x9e0082df0ba9e4b0, 0x7a5dbbc594ddb9f3, 0xf4b32f46226bada7,
+		0x751e8fbc860ee5fb, 0x14ea5627c0843d90, 0xf723ca908e7af2ee, 0xa129ca6149be45e5,
+		0x3f2acc7f57c29bdb, 0x699ae9f52cbe4794, 0x4bc1b3f0968dd39c, 0xbb6dc91da77961bd,
+		0xbed65cf21aa2ee98, 0xd0f2cbb02e3b67c7, 0x93536795e3a33e88, 0xa80c038ccd5ccec8,
+		0xb8ad50c6f649af94, 0xbce192de8a85b8ea, 0x17d835b85bbb15f3, 0x2f2e6163076bcfad,
+		0xde4daaaca71dc9a5, 0xa6a2506687956571, 0xad87a3535c49ef28, 0x32d892fad841c342,
+		0x7127512f72f27cce, 0xa7f32346f95978e3, 0x12e0b01abb051238, 0x15e034d40fa197ae,
+		0x314dffbe0815a3b4, 0x027990f029623981, 0xcadcd4e59ef40c4d, 0x9abfd8766a33735c,
+		0x0e3ea96b5304a7d0, 0xad0c42d6fc585992, 0x187306c89bc215a9, 0xd4a60abcf3792b95,
+		0xf935451de4f21df2, 0xa9538f0419755787, 0xdb9acddff56ca510, 0xd06c98cd5c0975eb,
+		0xe612a3cb9ecba951, 0xc766e62cfcadaf96, 0xee64435a9752fe72, 0xa192d576b245165a,
+		0x0a8787bf8ecb74b2, 0x81b3e73d20b49b6f, 0x7fa8220ba3b2ecea, 0x245731c13ca42499,
+		0xb78dbfaf3a8d83bd, 0xea1ad565322a1a0b, 0x60e61c23a3795013, 0x6606d7e446282b93,
+		0x6ca4ecb15c5f91e1, 0x9f626da15c9625f3, 0xe51b38608ef25f57, 0x958a324ceb064572,
+	}
+
+	key: [16]byte
+	for i in 0..<16 {
+		key[i] = byte(i)
+	}
+
+	for i in 0..<len(test_vectors) {
+		data := make([]byte, i)
+		for j in 0..<i {
+			data[j] = byte(j)
+		}
+
+		vector   := test_vectors[i]
+		computed := siphash.sum_2_4(data[:], key[:])
+
+		expect(t, computed == vector, fmt.tprintf("Expected: 0x%x for input of %v, but got 0x%x instead", vector, data, computed))
+	}
+}
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
index 71adad137..6d1ae0047 100644
--- a/tests/core/crypto/test_core_crypto_modern.odin
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -308,7 +308,7 @@ test_x25519 :: proc(t: ^testing.T) {
 test_rand_bytes :: proc(t: ^testing.T) {
 	log(t, "Testing rand_bytes")
 
-	if ODIN_OS != "linux" {
+	if ODIN_OS != .Linux {
 		log(t, "rand_bytes not supported - skipping")
 		return
 	}
diff --git a/tests/core/download_assets.py b/tests/core/download_assets.py
index 831b5b13a..d86f7f1e7 100644
--- a/tests/core/download_assets.py
+++ b/tests/core/download_assets.py
@@ -50,7 +50,10 @@ def try_download_file(url, out_file):
 	 	print("Could not download", url)
 	 	return 1	
 
-def try_download_and_unpack_zip(url, out_file, extract_path):
+def try_download_and_unpack_zip(suite):
+	url      = ASSETS_BASE_URL.format(suite, "{}.zip".format(suite))
+	out_file = DOWNLOAD_BASE_PATH.format(suite) + "/{}.zip".format(suite)
+
 	print("\tDownloading {} to {}.".format(url, out_file))
 
 	if try_download_file(url, out_file) is not None:
@@ -62,6 +65,7 @@ def try_download_and_unpack_zip(url, out_file, extract_path):
 		with zipfile.ZipFile(out_file) as z:
 			for file in z.filelist:
 				filename = file.filename
+				extract_path = DOWNLOAD_BASE_PATH.format(suite)
 
 				print("\t\tExtracting: {}".format(filename))
 				z.extract(file, extract_path)
@@ -69,56 +73,25 @@ def try_download_and_unpack_zip(url, out_file, extract_path):
 		print("Could not extract ZIP file")
 		return 2
 
-def download_png_assets():
-	suite = "PNG"
-	url          = ASSETS_BASE_URL.format(suite, "{}.zip".format(suite))
-	out_file     = DOWNLOAD_BASE_PATH.format(suite) + "/{}.zip".format(suite)
-	extract_path = DOWNLOAD_BASE_PATH.format(suite)
 
+def main():
 	print("Downloading PNG assets")
 
 	# Make PNG assets path
 	try:
-		path = DOWNLOAD_BASE_PATH.format(suite)
+		path = DOWNLOAD_BASE_PATH.format("PNG")
 		os.makedirs(path)
 	except FileExistsError:
 		pass
 
 	# Try downloading and unpacking the PNG assets
-	r = try_download_and_unpack_zip(url, out_file, extract_path)
+	r = try_download_and_unpack_zip("PNG")
 	if r is not None:
 		return r
 
 	# We could fall back on downloading the PNG files individually, but it's slow
 
 	print("Done downloading PNG assets")
-
-def download_unicode_assets():
-	suite = "XML"
-	url          = "https://www.w3.org/2003/entities/2007xml/unicode.xml.zip"
-	out_file     = DOWNLOAD_BASE_PATH.format(suite) + "/{}.zip".format(suite)
-	extract_path = DOWNLOAD_BASE_PATH.format(suite)
-
-	print("Downloading {}.".format(url))
-
-	# Make XML assets path
-	try:
-		path = DOWNLOAD_BASE_PATH.format(suite)
-		os.makedirs(path)
-	except FileExistsError:
-		pass
-
-	# Try downloading and unpacking the assets
-	r = try_download_and_unpack_zip(url, out_file, extract_path)
-	if r is not None:
-		return r
-
-	print("Done downloading Unicode/XML assets")
-
-def main():
-	download_png_assets()
-	download_unicode_assets()
-
 	return 0
 
 if __name__ == '__main__':
diff --git a/tests/core/encoding/hxa/test_core_hxa.odin b/tests/core/encoding/hxa/test_core_hxa.odin
new file mode 100644
index 000000000..b93562fd5
--- /dev/null
+++ b/tests/core/encoding/hxa/test_core_hxa.odin
@@ -0,0 +1,232 @@
+// 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"
+import "core:fmt"
+import "core:testing"
+import tc "tests:common"
+
+TEAPOT_PATH   :: "core/assets/HXA/teapot.hxa"
+
+main :: proc() {
+    t := testing.T{}
+
+	test_read(&t)
+	test_write(&t)
+
+	tc.report(&t)
+}
+
+@test
+test_read :: proc(t: ^testing.T) {
+
+	using hxa
+
+	filename := tc.get_data_path(t, TEAPOT_PATH)
+	defer delete(filename)
+
+	file, err := read_from_file(filename)
+	e :: hxa.Read_Error.None
+	tc.expect(t, err == e, fmt.tprintf("%v: read_from_file(%v) -> %v != %v", #procedure, filename, err, e))
+	defer file_destroy(file)
+
+	/* Header */
+	tc.expect(t, file.magic_number == 0x417848, fmt.tprintf("%v: file.magic_number %v != %v",
+															#procedure, file.magic_number, 0x417848))
+	tc.expect(t, file.version == 1, fmt.tprintf("%v: file.version %v != %v",
+															#procedure, file.version, 1))
+	tc.expect(t, file.internal_node_count == 1, fmt.tprintf("%v: file.internal_node_count %v != %v",
+															#procedure, file.internal_node_count, 1))
+
+	/* Nodes (only one) */
+	tc.expect(t, len(file.nodes) == 1, fmt.tprintf("%v: len(file.nodes) %v != %v", #procedure, len(file.nodes), 1))
+
+	m := &file.nodes[0].meta_data
+	tc.expect(t, len(m^) == 38, fmt.tprintf("%v: len(m^) %v != %v", #procedure, len(m^), 38))
+	{
+		e :: "Texture resolution"
+		tc.expect(t, m[0].name == e, fmt.tprintf("%v: m[0].name %v != %v", #procedure, m[0].name, e))
+
+		m_v, m_v_ok := m[0].value.([]i64le)
+		tc.expect(t, m_v_ok, fmt.tprintf("%v: m_v_ok %v != %v", #procedure, m_v_ok, true))
+		tc.expect(t, len(m_v) == 1, fmt.tprintf("%v: len(m_v) %v != %v", #procedure, len(m_v), 1))
+		tc.expect(t, m_v[0] == 1024, fmt.tprintf("%v: m_v[0] %v != %v", #procedure, len(m_v), 1024))
+	}
+	{
+		e :: "Validate"
+		tc.expect(t, m[37].name == e, fmt.tprintf("%v: m[37].name %v != %v", #procedure, m[37].name, e))
+
+		m_v, m_v_ok := m[37].value.([]i64le)
+		tc.expect(t, m_v_ok, fmt.tprintf("%v: m_v_ok %v != %v", #procedure, m_v_ok, true))
+		tc.expect(t, len(m_v) == 1, fmt.tprintf("%v: len(m_v) %v != %v", #procedure, len(m_v), 1))
+		tc.expect(t, m_v[0] == -2054847231, fmt.tprintf("%v: m_v[0] %v != %v", #procedure, len(m_v), -2054847231))
+	}
+
+	/* Node content */
+	v, v_ok := file.nodes[0].content.(hxa.Node_Geometry)
+	tc.expect(t, v_ok, fmt.tprintf("%v: v_ok %v != %v", #procedure, v_ok, true))
+
+	tc.expect(t, v.vertex_count == 530, fmt.tprintf("%v: v.vertex_count %v != %v", #procedure, v.vertex_count, 530))
+	tc.expect(t, v.edge_corner_count == 2026, fmt.tprintf("%v: v.edge_corner_count %v != %v",
+														  #procedure, v.edge_corner_count, 2026))
+	tc.expect(t, v.face_count == 517, fmt.tprintf("%v: v.face_count %v != %v", #procedure, v.face_count, 517))
+
+	/* Vertex stack */
+	tc.expect(t, len(v.vertex_stack) == 1, fmt.tprintf("%v: len(v.vertex_stack) %v != %v",
+													   #procedure, len(v.vertex_stack), 1))
+	{
+		e := "vertex"
+		tc.expect(t, v.vertex_stack[0].name == e, fmt.tprintf("%v: v.vertex_stack[0].name %v != %v",
+															  #procedure, v.vertex_stack[0].name, e))
+	}
+	tc.expect(t, v.vertex_stack[0].components == 3, fmt.tprintf("%v: v.vertex_stack[0].components %v != %v",
+																#procedure, v.vertex_stack[0].components, 3))
+
+	/* Vertex stack data */
+	vs_d, vs_d_ok := v.vertex_stack[0].data.([]f64le)
+	tc.expect(t, vs_d_ok, fmt.tprintf("%v: vs_d_ok %v != %v", #procedure, vs_d_ok, true))
+	tc.expect(t, len(vs_d) == 1590, fmt.tprintf("%v: len(vs_d) %v != %v", #procedure, len(vs_d), 1590))
+
+	tc.expect(t, vs_d[0] == 4.06266, fmt.tprintf("%v: vs_d[0] %v (%h) != %v (%h)",
+												 #procedure, vs_d[0], vs_d[0], 4.06266, 4.06266))
+	tc.expect(t, vs_d[1] == 2.83457, fmt.tprintf("%v: vs_d[1] %v (%h) != %v (%h)",
+												 #procedure, vs_d[1], vs_d[1], 2.83457, 2.83457))
+	tc.expect(t, vs_d[2] == 0hbfbc5da6a4441787, fmt.tprintf("%v: vs_d[2] %v (%h) != %v (%h)",
+															#procedure, vs_d[2], vs_d[2],
+															0hbfbc5da6a4441787, 0hbfbc5da6a4441787))
+	tc.expect(t, vs_d[3] == 0h4010074fb549f948, fmt.tprintf("%v: vs_d[3] %v (%h) != %v (%h)",
+															#procedure, vs_d[3], vs_d[3],
+															0h4010074fb549f948, 0h4010074fb549f948))
+	tc.expect(t, vs_d[1587] == 0h400befa82e87d2c7, fmt.tprintf("%v: vs_d[1587] %v (%h) != %v (%h)",
+															   #procedure, vs_d[1587], vs_d[1587],
+															   0h400befa82e87d2c7, 0h400befa82e87d2c7))
+	tc.expect(t, vs_d[1588] == 2.83457, fmt.tprintf("%v: vs_d[1588] %v (%h) != %v (%h)",
+													#procedure, vs_d[1588], vs_d[1588], 2.83457, 2.83457))
+	tc.expect(t, vs_d[1589] == -1.56121, fmt.tprintf("%v: vs_d[1589] %v (%h) != %v (%h)",
+													 #procedure, vs_d[1589], vs_d[1589], -1.56121, -1.56121))
+
+	/* Corner stack */
+	tc.expect(t, len(v.corner_stack) == 1,
+			  fmt.tprintf("%v: len(v.corner_stack) %v != %v", #procedure, len(v.corner_stack), 1))
+	{
+		e := "reference"
+		tc.expect(t, v.corner_stack[0].name == e, fmt.tprintf("%v: v.corner_stack[0].name %v != %v",
+															  #procedure, v.corner_stack[0].name, e))
+	}
+	tc.expect(t, v.corner_stack[0].components == 1, fmt.tprintf("%v: v.corner_stack[0].components %v != %v",
+																#procedure, v.corner_stack[0].components, 1))
+
+	/* Corner stack data */
+	cs_d, cs_d_ok := v.corner_stack[0].data.([]i32le)
+	tc.expect(t, cs_d_ok, fmt.tprintf("%v: cs_d_ok %v != %v", #procedure, cs_d_ok, true))
+	tc.expect(t, len(cs_d) == 2026, fmt.tprintf("%v: len(cs_d) %v != %v", #procedure, len(cs_d), 2026))
+	tc.expect(t, cs_d[0] == 6, fmt.tprintf("%v: cs_d[0] %v != %v", #procedure, cs_d[0], 6))
+	tc.expect(t, cs_d[2025] == -32, fmt.tprintf("%v: cs_d[2025] %v != %v", #procedure, cs_d[2025], -32))
+
+	/* Edge and face stacks (empty) */
+	tc.expect(t, len(v.edge_stack) == 0, fmt.tprintf("%v: len(v.edge_stack) %v != %v",
+													 #procedure, len(v.edge_stack), 0))
+	tc.expect(t, len(v.face_stack) == 0, fmt.tprintf("%v: len(v.face_stack) %v != %v",
+													 #procedure, len(v.face_stack), 0))
+}
+
+@test
+test_write :: proc(t: ^testing.T) {
+
+	using hxa
+
+	n1 :Node
+
+	n1_m1_value := []f64le{0.4, -1.23, 2341.6, -333.333}
+	n1_m1 := Meta{"m1", n1_m1_value}
+
+	n1.meta_data = []Meta{n1_m1}
+
+	n1_l1 := Layer{"l1", 2, []f32le{32.1, -41.3}}
+	n1_l2 := Layer{"l2", 3, []f64le{0.64, 1.64, -2.64}}
+
+	n1_content := Node_Image{Image_Type.Image_1D, [3]u32le{1, 1, 2}, Layer_Stack{n1_l1, n1_l2}} 
+
+	n1.content = n1_content
+
+	w_file :File
+	w_file.nodes = []Node{n1}
+
+	required_size := required_write_size(w_file)
+	buf := make([]u8, required_size)
+
+	n, write_err := write(buf, w_file)
+	write_e :: hxa.Write_Error.None
+	tc.expect(t, write_err == write_e, fmt.tprintf("%v: write_err %v != %v", #procedure, write_err, write_e))
+	tc.expect(t, n == required_size, fmt.tprintf("%v: n %v != %v", #procedure, n, required_size))
+
+	file, read_err := read(buf)
+	read_e :: hxa.Read_Error.None
+	tc.expect(t, read_err == read_e, fmt.tprintf("%v: read_err %v != %v", #procedure, read_err, read_e))
+	defer file_destroy(file)
+
+	delete(buf)
+
+	tc.expect(t, file.magic_number == 0x417848, fmt.tprintf("%v: file.magic_number %v != %v",
+															#procedure, file.magic_number, 0x417848))
+	tc.expect(t, file.version == 3, fmt.tprintf("%v: file.version %v != %v", #procedure, file.version, 3))
+	tc.expect(t, file.internal_node_count == 1, fmt.tprintf("%v: file.internal_node_count %v != %v",
+															#procedure, file.internal_node_count, 1))
+
+	tc.expect(t, len(file.nodes) == len(w_file.nodes), fmt.tprintf("%v: len(file.nodes) %v != %v",
+																   #procedure, len(file.nodes), len(w_file.nodes)))
+
+	m := &file.nodes[0].meta_data
+	w_m := &w_file.nodes[0].meta_data
+	tc.expect(t, len(m^) == len(w_m^), fmt.tprintf("%v: len(m^) %v != %v", #procedure, len(m^), len(w_m^)))
+	tc.expect(t, m[0].name == w_m[0].name, fmt.tprintf("%v: m[0].name %v != %v", #procedure, m[0].name, w_m[0].name))
+
+	m_v, m_v_ok := m[0].value.([]f64le)
+	tc.expect(t, m_v_ok, fmt.tprintf("%v: m_v_ok %v != %v", #procedure, m_v_ok, true))
+	tc.expect(t, len(m_v) == len(n1_m1_value), fmt.tprintf("%v: %v != len(m_v) %v",
+														   #procedure, len(m_v), len(n1_m1_value)))
+	for i := 0; i < len(m_v); i += 1 {
+		tc.expect(t, m_v[i] == n1_m1_value[i], fmt.tprintf("%v: m_v[%d] %v != %v",
+														   #procedure, i, m_v[i], n1_m1_value[i]))
+	}
+
+	v, v_ok := file.nodes[0].content.(hxa.Node_Image)
+	tc.expect(t, v_ok, fmt.tprintf("%v: v_ok %v != %v", #procedure, v_ok, true))
+	tc.expect(t, v.type == n1_content.type, fmt.tprintf("%v: v.type %v != %v", #procedure, v.type, n1_content.type))
+	tc.expect(t, len(v.resolution) == 3, fmt.tprintf("%v: len(v.resolution) %v != %v",
+													 #procedure, len(v.resolution), 3))
+	tc.expect(t, len(v.image_stack) == len(n1_content.image_stack), fmt.tprintf("%v: len(v.image_stack) %v != %v",
+			  #procedure, len(v.image_stack), len(n1_content.image_stack)))
+	for i := 0; i < len(v.image_stack); i += 1 {
+		tc.expect(t, v.image_stack[i].name == n1_content.image_stack[i].name,
+				  fmt.tprintf("%v: v.image_stack[%d].name %v != %v",
+							  #procedure, i, v.image_stack[i].name, n1_content.image_stack[i].name))
+		tc.expect(t, v.image_stack[i].components == n1_content.image_stack[i].components,
+				  fmt.tprintf("%v: v.image_stack[%d].components %v != %v",
+				  			  #procedure, i, v.image_stack[i].components, n1_content.image_stack[i].components))
+
+		switch n1_t in n1_content.image_stack[i].data {
+		case []u8:
+			tc.expect(t, false, fmt.tprintf("%v: n1_content.image_stack[i].data []u8", #procedure))
+		case []i32le:
+			tc.expect(t, false, fmt.tprintf("%v: n1_content.image_stack[i].data []i32le", #procedure))
+		case []f32le:
+			l, l_ok := v.image_stack[i].data.([]f32le)
+			tc.expect(t, l_ok, fmt.tprintf("%v: l_ok %v != %v", #procedure, l_ok, true))
+			tc.expect(t, len(l) == len(n1_t), fmt.tprintf("%v: len(l) %v != %v", #procedure, len(l), len(n1_t)))
+			for j := 0; j < len(l); j += 1 {
+				tc.expect(t, l[j] == n1_t[j], fmt.tprintf("%v: l[%d] %v (%h) != %v (%h)",
+														  #procedure, j, l[j], l[j], n1_t[j], n1_t[j]))
+			}
+		case []f64le:
+			l, l_ok := v.image_stack[i].data.([]f64le)
+			tc.expect(t, l_ok, fmt.tprintf("%v: l_ok %v != %v", #procedure, l_ok, true))
+			tc.expect(t, len(l) == len(n1_t), fmt.tprintf("%v: len(l) %v != %v", #procedure, len(l), len(n1_t)))
+			for j := 0; j < len(l); j += 1 {
+				tc.expect(t, l[j] == n1_t[j], fmt.tprintf("%v: l[%d] %v != %v", #procedure, j, l[j], n1_t[j]))
+			}
+		}
+	}
+}
diff --git a/tests/core/encoding/json/test_core_json.odin b/tests/core/encoding/json/test_core_json.odin
index 6f2e8c35a..0e6a6412f 100644
--- a/tests/core/encoding/json/test_core_json.odin
+++ b/tests/core/encoding/json/test_core_json.odin
@@ -3,6 +3,7 @@ package test_core_json
 import "core:encoding/json"
 import "core:testing"
 import "core:fmt"
+import "core:os"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -20,17 +21,22 @@ when ODIN_TEST {
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
 main :: proc() {
 	t := testing.T{}
-	
+
 	parse_json(&t)
 	marshal_json(&t)
+	unmarshal_json(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 @test
@@ -65,7 +71,8 @@ parse_json :: proc(t: ^testing.T) {
    
 	_, err := json.parse(transmute([]u8)json_data)
 
-	expect(t, err == .None, "expected json error to be none")
+	msg := fmt.tprintf("Expected `json.parse` to return nil, got %v", err)
+	expect(t, err == nil, msg)
 }
 
 @test
@@ -82,6 +89,259 @@ marshal_json :: proc(t: ^testing.T) {
 	}
    
 	_, err := json.marshal(my_struct)
-	
-	expect(t, err == .None, "expected json error to be none")
+	msg := fmt.tprintf("Expected `json.marshal` to return nil, got %v", err)
+	expect(t, err == nil, msg)
 }
+
+PRODUCTS := `
+{
+	"cash":     "0",
+	"products": [
+		{
+			"name": "Cog\nCola",
+			"cost":  "3",
+			"owned": "1",
+
+			"profit": "4",
+			"seconds": 3,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "gingerBeer",
+			"cost":  "9",
+			"owned": "0",
+
+			"profit": "16",
+			"seconds": 5,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Coffee",
+			"cost":  "27",
+			"owned": "0",
+
+			"profit": "64",
+			"seconds": 7,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Haggis",
+			"cost":  "81",
+			"owned": "0",
+
+			"profit": "256",
+			"seconds": 11,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Lasagna",
+			"cost":  "243",
+			"owned": "0",
+
+			"profit": "1024",
+			"seconds": 13,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Asparagus",
+			"cost":  "729",
+			"owned": "0",
+
+			"profit": "4096",
+			"seconds": 17,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Yorkshire Pudding",
+			"cost":  "2187",
+			"owned": "0",
+
+			"profit": "16384",
+			"seconds": 19,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Salmon Wrap",
+			"cost":  "6561",
+			"owned": "0",
+
+			"profit": "65536",
+			"seconds": 23,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Poke Bowl",
+			"cost":  "19683",
+			"owned": "0",
+
+			"profit": "262144",
+			"seconds": 29,
+			"multiplier": 1,
+			"auto_click": false
+		},
+		{
+			"name": "Chili Con Carne",
+			"cost":  "59049",
+			"owned": "0",
+
+			"profit": "1048576",
+			"seconds": 59,
+			"multiplier": 1,
+			"auto_click": false
+		},
+	],
+}
+`
+
+original_data := Game_Marshal{
+	cash = "0",
+	products = {
+		{
+			name       = "Cog\nCola",
+			cost       = "3",
+			owned      = "1",
+			profit     = "4",
+			seconds    = 3,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "gingerBeer",
+			cost       = "9",
+			owned      = "0",
+			profit     = "16",
+			seconds    = 5,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Coffee",
+			cost       = "27",
+			owned      = "0",
+			profit     = "64",
+			seconds    = 7,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Haggis",
+			cost       = "81",
+			owned      = "0",
+			profit     = "256",
+			seconds    = 11,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Lasagna",
+			cost       = "243",
+			owned      = "0",
+			profit     = "1024",
+			seconds    = 13,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Asparagus",
+			cost       = "729",
+			owned      = "0",
+			profit     = "4096",
+			seconds    = 17,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Yorkshire Pudding",
+			cost       = "2187",
+			owned      = "0",
+			profit     = "16384",
+			seconds    = 19,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Salmon Wrap",
+			cost       = "6561",
+			owned      = "0",
+			profit     = "65536",
+			seconds    = 23,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Poke Bowl",
+			cost       = "19683",
+			owned      = "0",
+			profit     = "262144",
+			seconds    = 29,
+			multiplier = 1,
+			auto_click = false,
+		},
+		{
+			name       = "Chili Con Carne",
+			cost       = "59049",
+			owned      = "0",
+			profit     = "1048576",
+			seconds    = 59,
+			multiplier = 1,
+			auto_click = false,
+		},
+	},
+}
+
+Product_Marshal :: struct {
+	name:       cstring,
+	owned:      string,
+
+	cost:       string,
+
+	profit:     string,
+	seconds:    int,
+	multiplier: int,
+
+	auto_click: bool,
+}
+
+Game_Marshal :: struct {
+	cash:     string,
+	products: []Product_Marshal,
+}
+
+cleanup :: proc(g: Game_Marshal) {
+	for p in g.products {
+		delete(p.name)
+		delete(p.owned)
+		delete(p.cost)
+		delete(p.profit)
+	}
+	delete(g.products)
+	delete(g.cash)
+}
+
+@test
+unmarshal_json :: proc(t: ^testing.T) {
+	g: Game_Marshal
+	err := json.unmarshal(transmute([]u8)PRODUCTS, &g, json.DEFAULT_SPECIFICATION)
+	defer cleanup(g)
+
+	msg := fmt.tprintf("Expected `json.unmarshal` to return nil, got %v", err)
+	expect(t, err == nil, msg)
+
+	msg = fmt.tprintf("Expected %v products to have been unmarshaled, got %v", len(original_data.products), len(g.products))
+	expect(t, len(g.products) == len(original_data.products), msg)
+
+	msg = fmt.tprintf("Expected cash to have been unmarshaled as %v, got %v", original_data.cash, g.cash)
+	expect(t, original_data.cash == g.cash, msg)
+
+	for p, i in g.products {
+		expect(t, p == original_data.products[i], "Producted unmarshaled improperly")
+	}
+}
\ No newline at end of file
diff --git a/tests/core/encoding/varint/test_core_varint.odin b/tests/core/encoding/varint/test_core_varint.odin
new file mode 100644
index 000000000..2c3669afa
--- /dev/null
+++ b/tests/core/encoding/varint/test_core_varint.odin
@@ -0,0 +1,156 @@
+package test_core_varint
+
+import "core:encoding/varint"
+import "core:testing"
+import "core:fmt"
+import "core:os"
+import "core:slice"
+import "core:math/rand"
+
+TEST_count := 0
+TEST_fail  := 0
+
+RANDOM_TESTS :: 100
+
+when ODIN_TEST {
+	expect  :: testing.expect
+	log     :: testing.log
+} else {
+	expect  :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
+		TEST_count += 1
+		if !condition {
+			TEST_fail += 1
+			fmt.printf("[%v] %v\n", loc, message)
+			return
+		}
+	}
+	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
+	}
+}
+
+main :: proc() {
+	t := testing.T{}
+
+	test_leb128(&t)
+
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
+}
+
+@(test)
+test_leb128 :: proc(t: ^testing.T) {
+	buf: [varint.LEB128_MAX_BYTES]u8
+
+	for vector in ULEB_Vectors {
+		val, size, err := varint.decode_uleb128(vector.encoded)
+
+		msg := fmt.tprintf("Expected %02x to decode to %v consuming %v bytes, got %v and %v", vector.encoded, vector.value, vector.size, val, size)
+		expect(t, size == vector.size && val == vector.value, msg)
+
+		msg  = fmt.tprintf("Expected decoder to return error %v, got %v for vector %v", vector.error, err, vector)
+		expect(t, err == vector.error, msg)
+
+		if err == .None { // Try to roundtrip
+			size, err = varint.encode_uleb128(buf[:], vector.value)
+
+			msg = fmt.tprintf("Expected %v to encode to %02x, got %02x", vector.value, vector.encoded, buf[:size])
+			expect(t, size == vector.size && slice.simple_equal(vector.encoded, buf[:size]), msg)
+		}
+	}
+
+	for vector in ILEB_Vectors {
+		val, size, err := varint.decode_ileb128(vector.encoded)
+
+		msg := fmt.tprintf("Expected %02x to decode to %v consuming %v bytes, got %v and %v", vector.encoded, vector.value, vector.size, val, size)
+		expect(t, size == vector.size && val == vector.value, msg)
+
+		msg  = fmt.tprintf("Expected decoder to return error %v, got %v", vector.error, err)
+		expect(t, err == vector.error, msg)
+
+		if err == .None { // Try to roundtrip
+			size, err = varint.encode_ileb128(buf[:], vector.value)
+
+			msg = fmt.tprintf("Expected %v to encode to %02x, got %02x", vector.value, vector.encoded, buf[:size])
+			expect(t, size == vector.size && slice.simple_equal(vector.encoded, buf[:size]), msg)
+		}
+	}
+
+	for num_bytes in 1..uint(16) {
+		for _ in 0..RANDOM_TESTS {
+			unsigned, signed := get_random(num_bytes)
+
+			{
+				encode_size, encode_err := varint.encode_uleb128(buf[:], unsigned)
+				msg := fmt.tprintf("%v failed to encode as an unsigned LEB128 value, got %v", unsigned, encode_err)
+				expect(t, encode_err == .None, msg)
+
+				decoded, decode_size, decode_err := varint.decode_uleb128(buf[:])
+				msg = fmt.tprintf("Expected %02x to decode as %v, got %v", buf[:encode_size], unsigned, decoded)
+				expect(t, decode_err == .None && decode_size == encode_size && decoded == unsigned, msg)
+			}
+
+			{
+				encode_size, encode_err := varint.encode_ileb128(buf[:], signed)
+				msg := fmt.tprintf("%v failed to encode as a signed LEB128 value, got %v", signed, encode_err)
+				expect(t, encode_err == .None, msg)
+
+				decoded, decode_size, decode_err := varint.decode_ileb128(buf[:])
+				msg = fmt.tprintf("Expected %02x to decode as %v, got %v, err: %v", buf[:encode_size], signed, decoded, decode_err)
+				expect(t, decode_err == .None && decode_size == encode_size && decoded == signed, msg)
+			}
+		}
+	}
+}
+
+get_random :: proc(byte_count: uint) -> (u: u128, i: i128) {
+	assert(byte_count >= 0 && byte_count <= size_of(u128))
+
+	for _ in 1..byte_count {
+		u <<= 8
+		u |= u128(rand.uint32() & 0xff)
+	}
+
+	bias := i128(1 << (byte_count * 7)) - 1
+	i     = i128(u) - bias
+
+	return
+}
+
+ULEB_Test_Vector :: struct {
+	encoded: []u8,
+	value:   u128,
+	size:    int,
+	error:   varint.Error,
+}
+
+ULEB_Vectors :: []ULEB_Test_Vector{
+	{ []u8{0x00},             0,         1, .None },
+	{ []u8{0x7f},             127,       1, .None },
+	{ []u8{0xE5, 0x8E, 0x26}, 624485,    3, .None },
+	{ []u8{0x80},             0,         0, .Buffer_Too_Small },
+	{ []u8{},                 0,         0, .Buffer_Too_Small },
+
+	{ []u8{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03}, max(u128), 19, .None },
+}
+
+ILEB_Test_Vector :: struct {
+	encoded: []u8,
+	value:   i128,
+	size:    int,
+	error:   varint.Error,
+}
+
+ILEB_Vectors :: []ILEB_Test_Vector{
+	{ []u8{0x00},             0,       1, .None },
+	{ []u8{0x3f},             63,      1, .None },
+	{ []u8{0x40},             -64,     1, .None },
+	{ []u8{0xC0, 0xBB, 0x78}, -123456, 3, .None },
+	{ []u8{},                 0,       0, .Buffer_Too_Small },
+
+	{ []u8{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7e}, min(i128), 19, .None },
+	{ []u8{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01}, max(i128), 19, .None },
+}
\ No newline at end of file
diff --git a/tests/core/hash/test_core_hash.odin b/tests/core/hash/test_core_hash.odin
index b81af01a5..607642339 100644
--- a/tests/core/hash/test_core_hash.odin
+++ b/tests/core/hash/test_core_hash.odin
@@ -5,6 +5,7 @@ import "core:hash"
 import "core:time"
 import "core:testing"
 import "core:fmt"
+import "core:os"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -17,12 +18,13 @@ when ODIN_TEST {
 		TEST_count += 1
 		if !condition {
 			TEST_fail += 1
-			fmt.printf("[%v] %v", loc, message)
+			fmt.printf("[%v] %v\n", loc, message)
 			return
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
@@ -31,7 +33,10 @@ main :: proc() {
 	test_benchmark_runner(&t)
 	test_xxhash_vectors(&t)
 	test_crc64_vectors(&t)
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 /*
diff --git a/tests/core/image/test_core_image.odin b/tests/core/image/test_core_image.odin
index 48d9ca1d2..0c11ca5ae 100644
--- a/tests/core/image/test_core_image.odin
+++ b/tests/core/image/test_core_image.odin
@@ -5,7 +5,7 @@
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
 
-	A test suite for PNG.
+	A test suite for PNG + QOI.
 */
 package test_core_image
 
@@ -14,6 +14,7 @@ import "core:testing"
 import "core:compress"
 import "core:image"
 import "core:image/png"
+import "core:image/qoi"
 
 import "core:bytes"
 import "core:hash"
@@ -25,8 +26,8 @@ import "core:time"
 
 import "core:runtime"
 
-WRITE_PPM_ON_FAIL     :: #config(WRITE_PPM_ON_FAIL, false)
-TEST_FILE_PATH_PREFIX :: "tests/core/assets/PNG"
+WRITE_PPM_ON_FAIL :: #config(WRITE_PPM_ON_FAIL, false)
+TEST_SUITE_PATH   :: "assets/PNG"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -44,30 +45,20 @@ when ODIN_TEST {
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
-
 I_Error :: image.Error
 
 main :: proc() {
 	t := testing.T{}
 	png_test(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
-}
-
-test_file_path :: proc(filename: string, extension := "png") -> (path: string) {
-
-	path = fmt.tprintf("%v%v/%v.%v", ODIN_ROOT, TEST_FILE_PATH_PREFIX, filename, extension)
-	temp := transmute([]u8)path
-
-	for r, i in path {
-		if r == '\\' {
-			temp[i] = '/'
-		}
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
 	}
-	return path
 }
 
 PNG_Test :: struct {
@@ -1472,7 +1463,7 @@ run_png_suite :: proc(t: ^testing.T, suite: []PNG_Test) -> (subtotal: int) {
 	context = runtime.default_context()
 
 	for file in suite {
-		test_file := test_file_path(file.file)
+		test_file := fmt.tprintf("%v/%v.png", TEST_SUITE_PATH, file.file)
 
 		img: ^png.Image
 		err: png.Error
@@ -1509,11 +1500,34 @@ run_png_suite :: proc(t: ^testing.T, suite: []PNG_Test) -> (subtotal: int) {
 
 				passed &= dims_pass
 
-				hash   := hash.crc32(pixels)
-				error  = fmt.tprintf("%v test %v hash is %08x, expected %08x.", file.file, count, hash, test.hash)
-				expect(t, test.hash == hash, error)
+				png_hash   := hash.crc32(pixels)
+				error  = fmt.tprintf("%v test %v hash is %08x, expected %08x with %v.", file.file, count, png_hash, test.hash, test.options)
+				expect(t, test.hash == png_hash, error)
+
+				passed &= test.hash == png_hash
+
+				// Roundtrip through QOI to test the QOI encoder and decoder.
+				if passed && img.depth == 8 && (img.channels == 3 || img.channels == 4) {
+					qoi_buffer: bytes.Buffer
+					defer bytes.buffer_destroy(&qoi_buffer)
+					qoi_save_err := qoi.save(&qoi_buffer, img)
+
+					error  = fmt.tprintf("%v test %v QOI save failed with %v.", file.file, count, qoi_save_err)
+					expect(t, qoi_save_err == nil, error)
+
+					if qoi_save_err == nil {
+						qoi_img, qoi_load_err := qoi.load(qoi_buffer.buf[:])
+						defer qoi.destroy(qoi_img)
+
+						error  = fmt.tprintf("%v test %v QOI load failed with %v.", file.file, count, qoi_load_err)
+						expect(t, qoi_load_err == nil, error)
+
+						qoi_hash := hash.crc32(qoi_img.pixels.buf[:])
+						error  = fmt.tprintf("%v test %v QOI load hash is %08x, expected it match PNG's %08x with %v.", file.file, count, qoi_hash, png_hash, test.options)
+						expect(t, qoi_hash == png_hash, error)
+					}
+				}
 
-				passed &= test.hash == hash
 				if .return_metadata in test.options {
 
 					if v, ok := img.metadata.(^image.PNG_Info); ok {
@@ -1778,7 +1792,7 @@ write_image_as_ppm :: proc(filename: string, image: ^image.Image) -> (success: b
 	img := image
 
 	// PBM 16-bit images are big endian
-	when ODIN_ENDIAN == "little" {
+	when ODIN_ENDIAN == .Little {
 		if img.depth == 16 {
 			// The pixel components are in Big Endian. Let's byteswap back.
 			input  := mem.slice_data_cast([]u16,   img.pixels.buf[:])
@@ -1796,7 +1810,7 @@ write_image_as_ppm :: proc(filename: string, image: ^image.Image) -> (success: b
 	}
 
 	mode: int = 0
-	when ODIN_OS == "linux" || ODIN_OS == "darwin" {
+	when ODIN_OS == .Linux || ODIN_OS == .Darwin {
 		// NOTE(justasd): 644 (owner read, write; group read; others read)
 		mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
 	}
diff --git a/tests/core/math/big/build.bat b/tests/core/math/big/build.bat
index e383cdfc1..ad199d775 100644
--- a/tests/core/math/big/build.bat
+++ b/tests/core/math/big/build.bat
@@ -4,14 +4,11 @@ set PATH_TO_ODIN==..\..\..\..\odin
 set TEST_ARGS=-fast-tests

 set TEST_ARGS=-no-random

 set TEST_ARGS=

-set OUT_NAME=math_big_test_library

+set OUT_NAME=math_big_test_library.dll

 set COMMON=-build-mode:shared -show-timings -no-bounds-check -define:MATH_BIG_EXE=false -vet -strict-style

 echo ---

 echo Running core:math/big tests

 echo ---

 

-rem Fails

-:%PATH_TO_ODIN% build . %COMMON% -o:speed -out:%OUT_NAME%

-rem Passes

-%PATH_TO_ODIN% build . %COMMON% -o:size -out:%OUT_NAME%

+%PATH_TO_ODIN% build . %COMMON% -o:speed -out:%OUT_NAME%

 python3 test.py %TEST_ARGS%
\ No newline at end of file
diff --git a/tests/core/math/big/test.odin b/tests/core/math/big/test.odin
index 07fa0364b..a289c89dd 100644
--- a/tests/core/math/big/test.odin
+++ b/tests/core/math/big/test.odin
@@ -32,9 +32,9 @@ print_to_buffer :: proc(val: ^big.Int) -> cstring {
 
 @export test_initialize_constants :: proc "c" () -> (res: u64) {
 	context = runtime.default_context()
-	res = u64(big.initialize_constants())
-	//assert(MUL_KARATSUBA_CUTOFF >= 40);
-	return res
+	_  = big.initialize_constants()
+
+	return u64(big._DIGIT_NAILS)
 }
 
 @export test_error_string :: proc "c" (err: big.Error) -> (res: cstring) {
@@ -208,7 +208,7 @@ print_to_buffer :: proc(val: ^big.Int) -> cstring {
 /*
 	dest = shr_digit(src, digits)
 */
-@export test_shr_digit :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
+@export test_shr_leg :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
 	context = runtime.default_context()
 	err: big.Error
 
@@ -216,7 +216,7 @@ print_to_buffer :: proc(val: ^big.Int) -> cstring {
 	defer big.internal_destroy(src)
 
 	if err = big.atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err} }
-	if err = #force_inline big.internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err} }
+	if err = #force_inline big._private_int_shr_leg(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err} }
 
 	r := print_to_buffer(src)
 	return PyRes{res = r, err = nil}
@@ -225,7 +225,7 @@ print_to_buffer :: proc(val: ^big.Int) -> cstring {
 /*
 	dest = shl_digit(src, digits)
 */
-@export test_shl_digit :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
+@export test_shl_leg :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
 	context = runtime.default_context()
 	err: big.Error
 
@@ -233,7 +233,7 @@ print_to_buffer :: proc(val: ^big.Int) -> cstring {
 	defer big.internal_destroy(src)
 
 	if err = big.atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err} }
-	if err = #force_inline big.internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err} }
+	if err = #force_inline big._private_int_shl_leg(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err} }
 
 	r := print_to_buffer(src)
 	return PyRes{res = r, err = nil}
diff --git a/tests/core/math/big/test.py b/tests/core/math/big/test.py
index 6b17336bc..d4724edb8 100644
--- a/tests/core/math/big/test.py
+++ b/tests/core/math/big/test.py
@@ -17,7 +17,6 @@ import gc
 from enum import Enum

 import argparse

 

-

 parser = argparse.ArgumentParser(

 	description     = "Odin core:math/big test suite",

 	epilog          = "By default we run regression and random tests with preset parameters.",

@@ -127,17 +126,22 @@ def we_iterate():
 # Error enum values

 #

 class Error(Enum):

-	Okay                   = 0

-	Out_Of_Memory          = 1

-	Invalid_Pointer        = 2

-	Invalid_Argument       = 3

-	Unknown_Error          = 4

-	Max_Iterations_Reached = 5

-	Buffer_Overflow        = 6

-	Integer_Overflow       = 7

-	Division_by_Zero       = 8

-	Math_Domain_Error      = 9

-	Unimplemented          = 127

+	Okay                    = 0

+	Out_Of_Memory           = 1

+	Invalid_Pointer         = 2

+	Invalid_Argument        = 3

+	Unknown_Error           = 4

+	Assignment_To_Immutable = 10

+	Max_Iterations_Reached  = 11

+	Buffer_Overflow         = 12

+	Integer_Overflow        = 13

+	Integer_Underflow       = 14

+	Division_by_Zero        = 30

+	Math_Domain_Error       = 31

+	Cannot_Open_File        = 50

+	Cannot_Read_File        = 51

+	Cannot_Write_File       = 52

+	Unimplemented           = 127

 

 #

 # Disable garbage collection

@@ -158,6 +162,8 @@ def load(export_name, args, res):
 	export_name.restype  = res

 	return export_name

 

+

+

 #

 # Result values will be passed in a struct { res: cstring, err: Error }

 #

@@ -165,7 +171,11 @@ class Res(Structure):
 	_fields_ = [("res", c_char_p), ("err", c_uint64)]

 

 initialize_constants = load(l.test_initialize_constants, [], c_uint64)

-print("initialize_constants: ", initialize_constants())

+

+NAILS    = initialize_constants()

+LEG_BITS = 64 - NAILS

+

+print("LEG BITS: ", LEG_BITS)

 

 error_string = load(l.test_error_string, [c_byte], c_char_p)

 

@@ -182,8 +192,8 @@ int_sqrt   =     load(l.test_sqrt,       [c_char_p            ], Res)
 int_root_n =     load(l.test_root_n,     [c_char_p, c_longlong], Res)

 

 # Logical operations

-int_shl_digit  = load(l.test_shl_digit,  [c_char_p, c_longlong], Res)

-int_shr_digit  = load(l.test_shr_digit,  [c_char_p, c_longlong], Res)

+int_shl_leg    = load(l.test_shl_leg,    [c_char_p, c_longlong], Res)

+int_shr_leg    = load(l.test_shr_leg,    [c_char_p, c_longlong], Res)

 int_shl        = load(l.test_shl,        [c_char_p, c_longlong], Res)

 int_shr        = load(l.test_shr,        [c_char_p, c_longlong], Res)

 int_shr_signed = load(l.test_shr_signed, [c_char_p, c_longlong], Res)

@@ -397,26 +407,26 @@ def test_root_n(number = 0, root = 0, expected_error = Error.Okay):
 

 	return test("test_root_n", res, [number, root], expected_error, expected_result)

 

-def test_shl_digit(a = 0, digits = 0, expected_error = Error.Okay):

+def test_shl_leg(a = 0, digits = 0, expected_error = Error.Okay):

 	args  = [arg_to_odin(a), digits]

-	res   = int_shl_digit(*args)

+	res   = int_shl_leg(*args)

 	expected_result = None

 	if expected_error == Error.Okay:

-		expected_result = a << (digits * 60)

-	return test("test_shl_digit", res, [a, digits], expected_error, expected_result)

+		expected_result = a << (digits * LEG_BITS)

+	return test("test_shl_leg", res, [a, digits], expected_error, expected_result)

 

-def test_shr_digit(a = 0, digits = 0, expected_error = Error.Okay):

+def test_shr_leg(a = 0, digits = 0, expected_error = Error.Okay):

 	args  = [arg_to_odin(a), digits]

-	res   = int_shr_digit(*args)

+	res   = int_shr_leg(*args)

 	expected_result = None

 	if expected_error == Error.Okay:

 		if a < 0:

 			# Don't pass negative numbers. We have a shr_signed.

 			return False

 		else:

-			expected_result = a >> (digits * 60)

+			expected_result = a >> (digits * LEG_BITS)

 		

-	return test("test_shr_digit", res, [a, digits], expected_error, expected_result)

+	return test("test_shr_leg", res, [a, digits], expected_error, expected_result)

 

 def test_shl(a = 0, bits = 0, expected_error = Error.Okay):

 	args  = [arg_to_odin(a), bits]

@@ -551,12 +561,12 @@ TESTS = {
 	test_root_n: [

 		[  1298074214633706907132624082305024, 2, Error.Okay, ],	

 	],

-	test_shl_digit: [

+	test_shl_leg: [

 		[ 3192,			1 ],

 		[ 1298074214633706907132624082305024, 2 ],

 		[ 1024,			3 ],

 	],

-	test_shr_digit: [

+	test_shr_leg: [

 		[ 3680125442705055547392, 1 ],

 		[ 1725436586697640946858688965569256363112777243042596638790631055949824, 2 ],

 		[ 219504133884436710204395031992179571, 2 ],

@@ -614,10 +624,10 @@ total_failures = 0
 # test_shr_signed also tests shr, so we're not going to test shr randomly.

 #

 RANDOM_TESTS = [

-	test_add, test_sub, test_mul, test_sqr, test_div,

-	test_log, test_pow, test_sqrt, test_root_n,

-	test_shl_digit, test_shr_digit, test_shl, test_shr_signed,

-	test_gcd, test_lcm, test_is_square,

+	test_add,     test_sub,     test_mul,       test_sqr,

+	test_log,     test_pow,     test_sqrt,      test_root_n,

+	test_shl_leg, test_shr_leg, test_shl,       test_shr_signed,

+	test_gcd,     test_lcm,     test_is_square, test_div,

 ]

 SKIP_LARGE   = [

 	test_pow, test_root_n, # test_gcd,

@@ -714,9 +724,9 @@ if __name__ == '__main__':
 					a = randint(1, 1 << BITS)

 					b = TEST_ROOT_N_PARAMS[index]

 					index = (index + 1) % len(TEST_ROOT_N_PARAMS)

-				elif test_proc == test_shl_digit:

+				elif test_proc == test_shl_leg:

 					b = randint(0, 10);

-				elif test_proc == test_shr_digit:

+				elif test_proc == test_shr_leg:

 					a = abs(a)

 					b = randint(0, 10);

 				elif test_proc == test_shl:

diff --git a/tests/core/math/linalg/glsl/test_linalg_glsl_math.odin b/tests/core/math/linalg/glsl/test_linalg_glsl_math.odin
new file mode 100644
index 000000000..e0b4f5145
--- /dev/null
+++ b/tests/core/math/linalg/glsl/test_linalg_glsl_math.odin
@@ -0,0 +1,85 @@
+// Tests "linalg_glsl_math.odin" in "core:math/linalg/glsl".
+// Must be run with `-collection:tests=` flag, e.g.
+// ./odin run tests/core/math/linalg/glsl/test_linalg_glsl_math.odin -collection:tests=./tests
+package test_core_math_linalg_glsl_math
+
+import glsl "core:math/linalg/glsl"
+
+import "core:fmt"
+import "core:math"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+
+    t := testing.T{}
+
+	test_fract_f32(&t)
+	test_fract_f64(&t)
+
+	tc.report(&t)
+}
+
+@test
+test_fract_f32 :: proc(t: ^testing.T) {
+
+	using math
+
+	r: f32
+
+	Datum :: struct {
+		i: int,
+		v: f32,
+		e: f32,
+	}
+	@static data := []Datum{
+		{ 0, 10.5, 0.5 }, // Issue #1574 fract in linalg/glm is broken
+		{ 1, -10.5, -0.5 },
+		{ 2, F32_MIN, F32_MIN }, // 0x1p-126
+		{ 3, -F32_MIN, -F32_MIN },
+		{ 4, 0.0, 0.0 },
+		{ 5, -0.0, -0.0 },
+		{ 6, 1, 0.0 },
+		{ 7, -1, -0.0 },
+		{ 8, 0h3F80_0001, 0h3400_0000 }, // 0x1.000002p+0, 0x1p-23
+		{ 9, -0h3F80_0001, -0h3400_0000 },
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = glsl.fract(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%v (%h)) -> %v (%h) != %v", i, #procedure, d.v, d.v, r, r, d.e))
+	}
+}
+
+@test
+test_fract_f64 :: proc(t: ^testing.T) {
+
+	using math
+
+	r: f64
+
+	Datum :: struct {
+		i: int,
+		v: f64,
+		e: f64,
+	}
+	@static data := []Datum{
+		{ 0, 10.5, 0.5 }, // Issue #1574 fract in linalg/glm is broken
+		{ 1, -10.5, -0.5 },
+		{ 2, F64_MIN, F64_MIN }, // 0x1p-1022
+		{ 3, -F64_MIN, -F64_MIN },
+		{ 4, 0.0, 0.0 },
+		{ 5, -0.0, -0.0 },
+		{ 6, 1, 0.0 },
+		{ 7, -1, -0.0 },
+		{ 8, 0h3FF0_0000_0000_0001, 0h3CB0_0000_0000_0000 }, // 0x1.0000000000001p+0, 0x1p-52
+		{ 9, -0h3FF0_0000_0000_0001, -0h3CB0_0000_0000_0000 },
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = glsl.fract(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%v (%h)) -> %v (%h) != %v", i, #procedure, d.v, d.v, r, r, d.e))
+	}
+}
diff --git a/tests/core/math/noise/test_core_math_noise.odin b/tests/core/math/noise/test_core_math_noise.odin
new file mode 100644
index 000000000..a0360e695
--- /dev/null
+++ b/tests/core/math/noise/test_core_math_noise.odin
@@ -0,0 +1,151 @@
+package test_core_math_noise
+
+import "core:testing"
+import "core:math/noise"
+import "core:fmt"
+import "core:os"
+
+TEST_count := 0
+TEST_fail  := 0
+
+V2 :: noise.Vec2
+V3 :: noise.Vec3
+V4 :: noise.Vec4
+
+when ODIN_TEST {
+	expect  :: testing.expect
+	log     :: testing.log
+} else {
+	expect  :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
+		TEST_count += 1
+		if !condition {
+			TEST_fail += 1
+			fmt.printf("[%v] %v\n", loc, message)
+			return
+		}
+	}
+	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
+	}
+}
+
+main :: proc() {
+	t := testing.T{}
+	noise_test(&t)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
+}
+
+Test_Vector :: struct {
+	seed:      i64,
+	coord:     union {V2, V3, V4},
+	expected:  f32,
+
+	test_proc: union {
+		proc(_: i64, _: V2) -> f32,
+		proc(_: i64, _: V3) -> f32,
+		proc(_: i64, _: V4) -> f32,
+	},
+}
+
+SEED_1 :: 2324223232
+SEED_2 :: 932466901
+SEED_3 :: 9321
+
+COORD_1 :: V4{  242.0,  3433.0,      920.0,    222312.0}
+COORD_2 :: V4{  590.0,  9411.0,     5201.0, 942124256.0}
+COORD_3 :: V4{12090.0, 19411.0, 81950901.0,   4224219.0}
+
+Noise_Tests := []Test_Vector{
+	/*
+		`noise_2d` tests.
+	*/
+	{SEED_1, COORD_1.xy,   0.25010583,  noise.noise_2d},
+	{SEED_2, COORD_2.xy,  -0.92513955,  noise.noise_2d},
+	{SEED_3, COORD_3.xy,   0.67327416,  noise.noise_2d},
+
+	/*
+		`noise_2d_improve_x` tests.
+	*/
+	{SEED_1, COORD_1.xy,   0.17074019,  noise.noise_2d_improve_x},
+	{SEED_2, COORD_2.xy,   0.72330487,  noise.noise_2d_improve_x},
+	{SEED_3, COORD_3.xy,  -0.032076947, noise.noise_2d_improve_x},
+
+	/*
+		`noise_3d_improve_xy` tests.
+	*/
+	{SEED_1, COORD_1.xyz,  0.14819577,  noise.noise_3d_improve_xy},
+	{SEED_2, COORD_2.xyz, -0.065345764, noise.noise_3d_improve_xy},
+	{SEED_3, COORD_3.xyz, -0.37761918,  noise.noise_3d_improve_xy},
+
+	/*
+		`noise_3d_improve_xz` tests.
+	*/
+	{SEED_1, COORD_1.xyz, -0.50075006,  noise.noise_3d_improve_xz},
+	{SEED_2, COORD_2.xyz, -0.36039603,  noise.noise_3d_improve_xz},
+	{SEED_3, COORD_3.xyz, -0.3479203,   noise.noise_3d_improve_xz},
+
+	/*
+		`noise_3d_fallback` tests.
+	*/
+	{SEED_1, COORD_1.xyz,  0.6557345,   noise.noise_3d_fallback},
+	{SEED_2, COORD_2.xyz,  0.55452216,  noise.noise_3d_fallback},
+	{SEED_3, COORD_3.xyz, -0.26408964,  noise.noise_3d_fallback},
+
+	/*
+		`noise_3d_fallback` tests.
+	*/
+	{SEED_1, COORD_1.xyz,  0.6557345,   noise.noise_3d_fallback},
+	{SEED_2, COORD_2.xyz,  0.55452216,  noise.noise_3d_fallback},
+	{SEED_3, COORD_3.xyz, -0.26408964,  noise.noise_3d_fallback},
+
+	/*
+		`noise_4d_improve_xyz_improve_xy` tests.
+	*/
+	{SEED_1, COORD_1,      0.44929826,  noise.noise_4d_improve_xyz_improve_xy},
+	{SEED_2, COORD_2,     -0.13270882,  noise.noise_4d_improve_xyz_improve_xy},
+	{SEED_3, COORD_3,      0.10298563,  noise.noise_4d_improve_xyz_improve_xy},
+
+	/*
+		`noise_4d_improve_xyz_improve_xz` tests.
+	*/
+	{SEED_1, COORD_1,    -0.078514606,  noise.noise_4d_improve_xyz_improve_xz},
+	{SEED_2, COORD_2,    -0.032157656,  noise.noise_4d_improve_xyz_improve_xz},
+	{SEED_3, COORD_3,     -0.38607058,  noise.noise_4d_improve_xyz_improve_xz},
+
+	/*
+		`noise_4d_improve_xyz` tests.
+	*/
+	{SEED_1, COORD_1,      -0.4442258,  noise.noise_4d_improve_xyz},
+	{SEED_2, COORD_2,      0.36822623,  noise.noise_4d_improve_xyz},
+	{SEED_3, COORD_3,      0.22628775,  noise.noise_4d_improve_xyz},
+
+	/*
+		`noise_4d_fallback` tests.
+	*/
+	{SEED_1, COORD_1,     -0.14233987,  noise.noise_4d_fallback},
+	{SEED_2, COORD_2,      0.1354035,  noise.noise_4d_fallback},
+	{SEED_3, COORD_3,      0.14565045,  noise.noise_4d_fallback},
+
+}
+
+noise_test :: proc(t: ^testing.T) {
+	for test in Noise_Tests {
+		output: f32
+
+		switch coord in test.coord {
+		case V2:
+			output = test.test_proc.(proc(_: i64, _: V2) -> f32)(test.seed, test.coord.(V2))
+		case V3:
+			output = test.test_proc.(proc(_: i64, _: V3) -> f32)(test.seed, test.coord.(V3))
+		case V4:
+			output = test.test_proc.(proc(_: i64, _: V4) -> f32)(test.seed, test.coord.(V4))
+		}
+	
+		error  := fmt.tprintf("Seed %v, Coord: %v, Expected: %3.8f. Got %3.8f", test.seed, test.coord, test.expected, output)
+		expect(t, test.expected == output, error)
+	}
+}
\ No newline at end of file
diff --git a/tests/core/math/test_core_math.odin b/tests/core/math/test_core_math.odin
new file mode 100644
index 000000000..57da27002
--- /dev/null
+++ b/tests/core/math/test_core_math.odin
@@ -0,0 +1,310 @@
+// Tests "math.odin" in "core:math".
+// Must be run with `-collection:tests=` flag, e.g.
+// ./odin run tests/core/math/test_core_math.odin -collection:tests=./tests
+package test_core_math
+
+import "core:fmt"
+import "core:math"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+    t := testing.T{}
+
+	test_classify_f16(&t)
+	test_classify_f32(&t)
+	test_classify_f64(&t)
+
+	test_trunc_f16(&t)
+	test_trunc_f32(&t)
+	test_trunc_f64(&t)
+
+	tc.report(&t)
+}
+
+@test
+test_classify_f16 :: proc(t: ^testing.T) {
+
+	using math
+	using Float_Class
+
+	r: Float_Class
+
+	Datum :: struct {
+		i: int,
+		v: f16,
+		e: math.Float_Class,
+	}
+	@static data := []Datum{
+		{ 0, 1.2, Normal },
+		{ 1, 0h0001, Subnormal },
+		{ 2, 0.0, Zero },
+		{ 3, -0.0, Neg_Zero },
+		{ 4, SNAN_F16, NaN },
+		{ 5, QNAN_F16, NaN },
+		{ 6, INF_F16, Inf },
+		{ 7, NEG_INF_F16, Neg_Inf },
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = classify_f16(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
+	}
+
+	/* Check all subnormals (exponent 0, 10-bit significand non-zero) */
+	for i :u16 = 1; i < 0x400; i += 1 {
+		v :f16 = transmute(f16)i
+		r = classify_f16(v)
+		e :Float_Class: Subnormal
+		tc.expect(t, r == e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, v, r, e))
+	}
+}
+
+@test
+test_classify_f32 :: proc(t: ^testing.T) {
+
+	using math
+	using Float_Class
+
+	r: Float_Class
+
+	Datum :: struct {
+		i: int,
+		v: f32,
+		e: math.Float_Class,
+	}
+	@static data := []Datum{
+		{ 0, 1.2, Normal },
+		{ 1, 0h0000_0001, Subnormal },
+		{ 2, 0.0, Zero },
+		{ 3, -0.0, Neg_Zero },
+		{ 4, SNAN_F32, NaN },
+		{ 5, QNAN_F32, NaN },
+		{ 6, INF_F32, Inf },
+		{ 7, NEG_INF_F32, Neg_Inf },
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = classify_f32(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
+	}
+}
+
+@test
+test_classify_f64 :: proc(t: ^testing.T) {
+
+	using math
+	using Float_Class
+
+	r: Float_Class
+
+	Datum :: struct {
+		i: int,
+		v: f64,
+		e: math.Float_Class,
+	}
+	@static data := []Datum{
+		{ 0, 1.2, Normal },
+		{ 1, 0h0000_0000_0000_0001, Subnormal },
+		{ 2, 0.0, Zero },
+		{ 3, -0.0, Neg_Zero },
+		{ 4, SNAN_F64, NaN },
+		{ 5, QNAN_F64, NaN },
+		{ 6, INF_F64, Inf },
+		{ 7, NEG_INF_F64, Neg_Inf },
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = classify_f64(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
+	}
+}
+
+@test
+test_trunc_f16 :: proc(t: ^testing.T) {
+
+	using math
+
+	r, v: f16
+
+	Datum :: struct {
+		i: int,
+		v: f16,
+		e: f16,
+	}
+	@static data := []Datum{
+		{ 0, 10.5, 10 }, // Issue #1574 fract in linalg/glm is broken
+		{ 1, -10.5, -10 },
+
+		{ 2, F16_MAX, F16_MAX },
+		{ 3, -F16_MAX, -F16_MAX },
+		{ 4, F16_MIN, 0.0 },
+		{ 5, -F16_MIN, -0.0 },
+		{ 6, 0.0, 0.0 },
+		{ 7, -0.0, -0.0 },
+		{ 8, 1, 1 },
+		{ 9, -1, -1 },
+		{ 10, INF_F16, INF_F16 },
+		{ 11, NEG_INF_F16, NEG_INF_F16 },
+
+		/* From https://en.wikipedia.org/wiki/Half-precision_floating-point_format */
+		{ 12, 0h3C01, 1 }, // 0x1.004p+0 (smallest > 1)
+		{ 13, -0h3C01, -1 },
+		{ 14, 0h3BFF, 0.0 }, // 0x1.ffcp-1 (largest < 1)
+		{ 15, -0h3BFF, -0.0 },
+		{ 16, 0h0001, 0.0 }, // 0x0.004p-14 (smallest subnormal)
+		{ 17, -0h0001, -0.0 },
+		{ 18, 0h03FF, 0.0 }, // 0x0.ffcp-14 (largest subnormal)
+		{ 19, -0h03FF, -0.0 },
+
+		{ 20, 0hC809, -8 }, // -0x1.024p+3
+		{ 21, 0h4458, 4 }, // 0x1.16p+2
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = trunc_f16(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
+	}
+
+	v = SNAN_F16
+	r = trunc_f16(v)
+	tc.expect(t, is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+
+	v = QNAN_F16
+	r = trunc_f16(v)
+	tc.expect(t, is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+}
+
+@test
+test_trunc_f32 :: proc(t: ^testing.T) {
+
+	using math
+
+	r, v: f32
+
+	Datum :: struct {
+		i: int,
+		v: f32,
+		e: f32,
+	}
+	@static data := []Datum{
+		{ 0, 10.5, 10 }, // Issue #1574 fract in linalg/glm is broken
+		{ 1, -10.5, -10 },
+
+		{ 2, F32_MAX, F32_MAX },
+		{ 3, -F32_MAX, -F32_MAX },
+		{ 4, F32_MIN, 0.0 },
+		{ 5, -F32_MIN, -0.0 },
+		{ 6, 0.0, 0.0 },
+		{ 7, -0.0, -0.0 },
+		{ 8, 1, 1 },
+		{ 9, -1, -1 },
+		{ 10, INF_F32, INF_F32 },
+		{ 11, NEG_INF_F32, NEG_INF_F32 },
+
+		/* From https://en.wikipedia.org/wiki/Single-precision_floating-point_format */
+		{ 12, 0h3F80_0001, 1 }, // 0x1.000002p+0 (smallest > 1)
+		{ 13, -0h3F80_0001, -1 },
+		{ 14, 0h3F7F_FFFF, 0.0 }, // 0x1.fffffep-1 (largest < 1)
+		{ 15, -0h3F7F_FFFF, -0.0 },
+		{ 16, 0h0000_0001, 0.0 }, // 0x0.000002p-126 (smallest subnormal)
+		{ 17, -0h0000_0001, -0.0 },
+		{ 18, 0h007F_FFFF, 0.0 }, // 0x0.fffffep-126 (largest subnormal)
+		{ 19, -0h007F_FFFF, -0.0 },
+
+		/* From libc-test src/math/sanity/truncf.h */
+		{ 20, 0hC101_11D0, -8 }, // -0x1.0223ap+3
+		{ 21, 0h408B_0C34, 4 }, // 0x1.161868p+2
+		{ 22, 0hC106_1A5A, -8 }, // -0x1.0c34b4p+3
+		{ 23, 0hC0D1_0378, -6 }, // -0x1.a206fp+2
+		{ 24, 0h4114_45DE, 9 }, // 0x1.288bbcp+3
+		{ 25, 0h3F29_77E8, 0.0 }, // 0x1.52efdp-1
+		{ 26, 0hBED0_2E64, -0.0 }, // -0x1.a05cc8p-2
+		{ 27, 0h3F0F_CF7D, 0.0 }, // 0x1.1f9efap-1
+		{ 28, 0h3F46_2ED8, 0.0 }, // 0x1.8c5dbp-1
+		{ 29, 0hBF2D_C375, -0.0 }, // -0x1.5b86eap-1
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = trunc_f32(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
+	}
+
+	v = SNAN_F32
+	r = trunc_f32(v)
+	tc.expect(t, is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+
+	v = QNAN_F32
+	r = trunc_f32(v)
+	tc.expect(t, is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+}
+
+@test
+test_trunc_f64 :: proc(t: ^testing.T) {
+
+	using math
+
+	r, v: f64
+
+	Datum :: struct {
+		i: int,
+		v: f64,
+		e: f64,
+	}
+	data := []Datum{
+		{ 0, 10.5, 10 }, // Issue #1574 fract in linalg/glm is broken
+		{ 1, -10.5, -10 },
+
+		{ 2, F64_MAX, F64_MAX },
+		{ 3, -F64_MAX, -F64_MAX },
+		{ 4, F64_MIN, 0.0 },
+		{ 5, -F64_MIN, -0.0 },
+		{ 6, 0.0, 0.0 },
+		{ 7, -0.0, -0.0 },
+		{ 8, 1, 1 },
+		{ 9, -1, -1 },
+		{ 10, INF_F64, INF_F64 },
+		{ 11, NEG_INF_F64, NEG_INF_F64 },
+
+		/* From https://en.wikipedia.org/wiki/Double-precision_floating-point_format */
+		{ 12, 0h3FF0_0000_0000_0001, 1 }, // 0x1.0000000000001p+0 (smallest > 1)
+		{ 13, -0h3FF0_0000_0000_0001, -1 },
+		{ 14, 0h3FEF_FFFF_FFFF_FFFF, 0.0 }, // 0x1.fffffffffffffp-1 (largest < 1)
+		{ 15, -0h3FEF_FFFF_FFFF_FFFF, -0.0 },
+		{ 16, 0h0000_0000_0000_0001, 0.0 }, // 0x0.0000000000001p-1022 (smallest subnormal)
+		{ 17, -0h0000_0000_0000_0001, -0.0 },
+		{ 18, 0h000F_FFFF_FFFF_FFFF, 0.0 }, // 0x0.fffffffffffffp-1022 (largest subnormal)
+		{ 19, -0h000F_FFFF_FFFF_FFFF, -0.0 },
+
+		/* From libc-test src/math/sanity/trunc.h */
+		{ 20, 0hC020_2239_F3C6_A8F1, -8 }, // -0x1.02239f3c6a8f1p+3
+		{ 21, 0h4011_6186_8E18_BC67, 4 }, // 0x1.161868e18bc67p+2
+		{ 22, 0hC020_C34B_3E01_E6E7, -8 }, // -0x1.0c34b3e01e6e7p+3
+		{ 23, 0hC01A_206F_0A19_DCC4, -6 }, // -0x1.a206f0a19dcc4p+2
+		{ 24, 0h4022_88BB_B0D6_A1E6, 9 }, // 0x1.288bbb0d6a1e6p+3
+		{ 25, 0h3FE5_2EFD_0CD8_0497, 0.0 }, // 0x1.52efd0cd80497p-1
+		{ 26, 0hBFDA_05CC_7544_81D1, -0.0 }, // -0x1.a05cc754481d1p-2
+		{ 27, 0h3FE1_F9EF_9347_45CB, 0.0 }, // 0x1.1f9ef934745cbp-1
+		{ 28, 0h3FE8_C5DB_097F_7442, 0.0 }, // 0x1.8c5db097f7442p-1
+		{ 29, 0hBFE5_B86E_A811_8A0E, -0.0 }, // -0x1.5b86ea8118a0ep-1
+	}
+
+	for d, i in data {
+		assert(i == d.i)
+		r = trunc_f64(d.v)
+		tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
+	}
+
+	v = SNAN_F64
+	r = trunc_f64(v)
+	tc.expect(t, is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+
+	v = QNAN_F64
+	r = trunc_f64(v)
+	tc.expect(t, is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
+}
diff --git a/tests/core/odin/test_parser.odin b/tests/core/odin/test_parser.odin
index 53711d3ec..3837436bc 100644
--- a/tests/core/odin/test_parser.odin
+++ b/tests/core/odin/test_parser.odin
@@ -2,7 +2,7 @@ package test_core_odin_parser
 
 import "core:testing"
 import "core:fmt"
-
+import "core:os"
 import "core:odin/parser"
 
 
@@ -22,7 +22,8 @@ when ODIN_TEST {
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
@@ -30,9 +31,13 @@ main :: proc() {
 	t := testing.T{}
 	test_parse_demo(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
+
 @test
 test_parse_demo :: proc(t: ^testing.T) {
 	pkg, ok := parser.parse_package_from_path("examples/demo")
@@ -42,4 +47,4 @@ test_parse_demo :: proc(t: ^testing.T) {
 	for key, value in pkg.files {
 		expect(t, value.syntax_error_count == 0, fmt.tprintf("%v should contain zero errors", key))
 	}
-}
+}
\ No newline at end of file
diff --git a/tests/core/os/test_core_os_exit.odin b/tests/core/os/test_core_os_exit.odin
new file mode 100644
index 000000000..2ab274f5e
--- /dev/null
+++ b/tests/core/os/test_core_os_exit.odin
@@ -0,0 +1,10 @@
+// Tests that Odin run returns exit code of built executable on Unix
+// Needs exit status to be inverted to return 0 on success, e.g.
+// $(./odin run tests/core/os/test_core_os_exit.odin && exit 1 || exit 0)
+package test_core_os_exit
+
+import "core:os"
+
+main :: proc() {
+	os.exit(1)
+}
diff --git a/tests/core/path/filepath/test_core_filepath.odin b/tests/core/path/filepath/test_core_filepath.odin
new file mode 100644
index 000000000..0268fb62c
--- /dev/null
+++ b/tests/core/path/filepath/test_core_filepath.odin
@@ -0,0 +1,123 @@
+// Tests "path.odin" in "core:path/filepath".
+// Must be run with `-collection:tests=` flag, e.g.
+// ./odin run tests/core/path/filepath/test_core_filepath.odin -collection:tests=tests
+package test_core_filepath
+
+import "core:fmt"
+import "core:path/filepath"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+	t := testing.T{}
+
+	when ODIN_OS == .Windows {
+		test_split_list_windows(&t)
+	} else {
+		test_split_list_unix(&t)
+	}
+
+	tc.report(&t)
+}
+
+@test
+test_split_list_windows :: proc(t: ^testing.T) {
+
+	using filepath
+
+	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 := split_list(d.v)
+		defer delete(r)
+		tc.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 {
+				tc.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 := split_list(v)
+		tc.expect(t, r == nil, fmt.tprintf("%s(%s) -> %v != nil", #procedure, v, r))
+	}
+	{
+		v := "a"
+		r := split_list(v)
+		defer delete(r)
+		tc.expect(t, len(r) == 1, fmt.tprintf("%s(%s) len(r) %d != 1", #procedure, v, len(r)))
+		if len(r) == 1 {
+			tc.expect(t, r[0] == "a", fmt.tprintf("%s(%v) -> %v[0] != a", #procedure, v, r[0]))
+		}
+	}
+}
+
+@test
+test_split_list_unix :: proc(t: ^testing.T) {
+
+	using filepath
+
+	Datum :: struct {
+		i: int,
+		v: string,
+		e: [3]string,
+	}
+	@static data := []Datum{
+		{ 0, "/opt/butler:/home/fancykillerpanda/Projects/Odin/Odin:/usr/local/sbin",
+			[3]string{"/opt/butler", "/home/fancykillerpanda/Projects/Odin/Odin", "/usr/local/sbin"} }, // 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 := split_list(d.v)
+		defer delete(r)
+		tc.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 {
+				tc.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 := split_list(v)
+		tc.expect(t, r == nil, fmt.tprintf("%s(%s) -> %v != nil", #procedure, v, r))
+	}
+	{
+		v := "a"
+		r := split_list(v)
+		defer delete(r)
+		tc.expect(t, len(r) == 1, fmt.tprintf("%s(%s) len(r) %d != 1", #procedure, v, len(r)))
+		if len(r) == 1 {
+			tc.expect(t, r[0] == "a", fmt.tprintf("%s(%v) -> %v[0] != a", #procedure, v, r[0]))
+		}
+	}
+}
diff --git a/tests/core/reflect/test_core_reflect.odin b/tests/core/reflect/test_core_reflect.odin
new file mode 100644
index 000000000..039501735
--- /dev/null
+++ b/tests/core/reflect/test_core_reflect.odin
@@ -0,0 +1,288 @@
+// Tests "core:reflect/reflect".
+// Must be run with `-collection:tests=` flag, e.g.
+// ./odin run tests/core/reflect/test_core_reflect.odin -out=tests/core/test_core_reflect -collection:tests=./tests
+package test_core_reflect
+
+import "core:fmt"
+import "core:reflect"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+    t := testing.T{}
+
+	test_as_u64(&t)
+	test_as_f64(&t)
+
+	tc.report(&t)
+}
+
+@test
+test_as_u64 :: proc(t: ^testing.T) {
+	using reflect
+
+	{
+		/* i8 */
+		Datum :: struct { i: int, v: i8, e: u64 }
+		@static data := []Datum{
+			{ 0, 0x7F, 0x7F },
+			{ 1, -1, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 2, -0x80, 0xFFFF_FFFF_FFFF_FF80 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i8 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i8 %v) -> %v (0x%X) != %v (0x%X)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* i16 */
+		Datum :: struct { i: int, v: i16, e: u64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF, 0x7FFF },
+			{ 1, -1, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 2, -0x8000, 0xFFFF_FFFF_FFFF_8000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i16 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i16 %v) -> %v (0x%X) != %v (0x%X)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* i32 */
+		Datum :: struct { i: int, v: i32, e: u64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF, 0x7FFF_FFFF },
+			{ 1, -1, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 2, -0x8000_0000, 0xFFFF_FFFF_8000_0000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i32 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i32 %v) -> %v (0x%X) != %v (0x%X)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* i64 */
+		Datum :: struct { i: int, v: i64, e: u64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF_FFFF_FFFF, 0x7FFF_FFFF_FFFF_FFFF },
+			{ 1, -1, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 2, -0x8000_0000_0000_0000, 0x8000_0000_0000_0000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i64 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i64 %v) -> %v (0x%X) != %v (0x%X)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* i128 */
+		Datum :: struct { i: int, v: i128, e: u64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 1, -1, 0xFFFF_FFFF_FFFF_FFFF },
+			{ 2, 0x8000_0000_0000_0000, 0x8000_0000_0000_0000 },
+			{ 3, -0x8000_0000_0000_0000, 0x8000_0000_0000_0000 },
+			{ 4, 0x0001_0000_0000_0000_0000, 0 },
+			{ 5, -0x8000_0000_0000_0000_0000_0000_0000_0000, 0 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i128 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i128 %v) -> %v (0x%X) != %v (0x%X)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* f16 */
+		Datum :: struct { i: int, v: f16, e: u64 }
+		@static data := []Datum{
+			{ 0, 1.2, 1 },
+			{ 1, 123.12, 123 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f16 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f16 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* f32 */
+		Datum :: struct { i: int, v: f32, e: u64 }
+		@static data := []Datum{
+			{ 0, 123.3415, 123 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f32 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f32 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* f64 */
+		Datum :: struct { i: int, v: f64, e: u64 }
+		@static data := []Datum{
+			{ 0, 12345345345.3415234234, 12345345345 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_u64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f64 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f64 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+}
+
+@test
+test_as_f64 :: proc(t: ^testing.T) {
+	using reflect
+
+	{
+		/* i8 */
+		Datum :: struct { i: int, v: i8, e: f64 }
+		@static data := []Datum{
+			{ 0, 0x7F, 0x7F },
+			{ 1, -1, -1 },
+			{ 2, -0x80, -0x80 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i8 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i8 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* i16 */
+		Datum :: struct { i: int, v: i16, e: f64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF, 0x7FFF },
+			{ 1, -1, -1 },
+			{ 2, -0x8000, -0x8000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i16 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i16 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* i32 */
+		Datum :: struct { i: int, v: i32, e: f64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF, 0x7FFF_FFFF },
+			{ 1, -1, -1 },
+			{ 2, -0x8000_0000, -0x8000_0000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i32 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i32 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* i64 */
+		Datum :: struct { i: int, v: i64, e: f64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF_FFFF_FFFF, 0x7FFF_FFFF_FFFF_FFFF },
+			{ 1, -1, -1 },
+			{ 2, -0x8000_0000_0000_0000, -0x8000_0000_0000_0000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i64 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i64 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+	{
+		/* i128 */
+		Datum :: struct { i: int, v: i128, e: f64 }
+		@static data := []Datum{
+			{ 0, 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF, 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF },
+			{ 1, -1, -1 },
+			{ 2, 0x8000_0000_0000_0000_0000_0000_0000, 0x8000_0000_0000_0000_0000_0000_0000 },
+			{ 3, -0x8000_0000_0000_0000_0000_0000_0000_0000, -0x8000_0000_0000_0000_0000_0000_0000_0000 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(i128 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(i128 %v) -> %v (%H) != %v (%H)\n",
+												i, #procedure, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* f16 */
+		Datum :: struct { i: int, v: f16, e: f64 }
+		@static data := []Datum{
+			{ 0, 1.2, 0h3FF3_3400_0000_0000 }, // Precision difference TODO: check
+			{ 1, 123.12, 0h405E_C800_0000_0000 }, // Precision difference TODO: check
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f16 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f16 %v (%H)) -> %v (%H) != %v (%H)\n",
+												i, #procedure, d.v, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* f32 */
+		Datum :: struct { i: int, v: f32, e: f64 }
+		@static data := []Datum{
+			{ 0, 123.3415, 0h405E_D5DB_2000_0000 }, // Precision difference TODO: check
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f32 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f32 %v (%H)) -> %v (%H) != %v (%H)\n",
+												i, #procedure, d.v, d.v, r, r, d.e, d.e))
+		}
+	}
+	{
+		/* f64 */
+		Datum :: struct { i: int, v: f64, e: f64 }
+		@static data := []Datum{
+			{ 0, 12345345345.3415234234, 12345345345.3415234234 },
+		}
+
+		for d, i in data {
+			assert(i == d.i)
+			r, valid := as_f64(d.v)
+			tc.expect(t, valid, fmt.tprintf("i:%d %s(f64 %v) !valid\n", i, #procedure, d.v))
+			tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(f64 %v) -> %v != %v\n", i, #procedure, d.v, r, d.e))
+		}
+	}
+}
diff --git a/tests/core/strings/test_core_strings.odin b/tests/core/strings/test_core_strings.odin
index c5436f5c1..e97734dda 100644
--- a/tests/core/strings/test_core_strings.odin
+++ b/tests/core/strings/test_core_strings.odin
@@ -1,8 +1,9 @@
-package test_core_image
+package test_core_strings
 
 import "core:strings"
 import "core:testing"
 import "core:fmt"
+import "core:os"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -20,7 +21,8 @@ when ODIN_TEST {
 		}
 	}
 	log     :: proc(t: ^testing.T, v: any, loc := #caller_location) {
-		fmt.printf("[%v] LOG:\n\t%v\n", loc, v)
+		fmt.printf("[%v] ", loc)
+		fmt.printf("log: %v\n", v)
 	}
 }
 
@@ -30,14 +32,17 @@ main :: proc() {
 	test_index_any_larger_string_not_found(&t)
 	test_index_any_small_string_found(&t)
 	test_index_any_larger_string_found(&t)
+	test_cut(&t)
 
-	fmt.printf("\n%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 @test
 test_index_any_small_string_not_found :: proc(t: ^testing.T) {
 	index := strings.index_any(".", "/:\"")
-	log(t, index)
 	expect(t, index == -1, "index_any should be negative")
 }
 
@@ -58,3 +63,30 @@ test_index_any_larger_string_found :: proc(t: ^testing.T) {
 	index := strings.index_any("aaaaaaaa:aaaaaaaa", "/:\"")
 	expect(t, index == 8, "index_any should be 8")
 }
+
+Cut_Test :: struct {
+	input:  string,
+	offset: int,
+	length: int,
+	output: string,
+}
+
+cut_tests :: []Cut_Test{
+	{"some example text", 0, 4, "some"        },
+	{"some example text", 2, 2, "me"          },
+	{"some example text", 5, 7, "example"     },
+	{"some example text", 5, 0, "example text"},
+	{"恥ずべきフクロウ",        4, 0, "フクロウ"       },
+}
+
+@test
+test_cut :: proc(t: ^testing.T) {
+	for test in cut_tests {
+		res := strings.cut(test.input, test.offset, test.length)
+		defer delete(res)
+
+		msg := fmt.tprintf("cut(\"%v\", %v, %v) expected to return \"%v\", got \"%v\"",
+			test.input, test.offset, test.length, test.output, res)
+		expect(t, res == test.output, msg)
+	}
+}
\ No newline at end of file
diff --git a/tests/issues/run.bat b/tests/issues/run.bat
new file mode 100644
index 000000000..a7078ae0f
--- /dev/null
+++ b/tests/issues/run.bat
@@ -0,0 +1,17 @@
+@echo off
+
+if not exist "build\" mkdir build
+
+set COMMON=-collection:tests=.. -out:build\test_issue.exe
+
+@echo on
+
+..\..\odin build test_issue_829.odin %COMMON% -file
+build\test_issue
+
+..\..\odin build test_issue_1592.odin %COMMON% -file
+build\test_issue
+
+@echo off
+
+rmdir /S /Q build
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
new file mode 100755
index 000000000..ec0804bac
--- /dev/null
+++ b/tests/issues/run.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -eu
+
+mkdir -p build
+ODIN=../../odin
+COMMON="-collection:tests=.. -out:build/test_issue"
+
+set -x
+
+$ODIN build test_issue_829.odin $COMMON -file
+./build/test_issue
+
+$ODIN build test_issue_1592.odin $COMMON -file
+./build/test_issue
+
+set +x
+
+rm -rf build
diff --git a/tests/issues/test_issue_1592.odin b/tests/issues/test_issue_1592.odin
new file mode 100644
index 000000000..bb350a30b
--- /dev/null
+++ b/tests/issues/test_issue_1592.odin
@@ -0,0 +1,489 @@
+// Tests issue #1592 https://github.com/odin-lang/Odin/issues/1592
+package test_issues
+
+import "core:fmt"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+	t := testing.T{}
+
+	/* This won't short-circuit */
+	test_orig()
+
+	/* These will short-circuit */
+	test_simple_const_false(&t)
+	test_simple_const_true(&t)
+
+	/* These won't short-circuit */
+	test_simple_proc_false(&t)
+	test_simple_proc_true(&t)
+
+	/* These won't short-circuit */
+	test_const_false_const_false(&t)
+	test_const_false_const_true(&t)
+	test_const_true_const_false(&t)
+	test_const_true_const_true(&t)
+
+	/* These won't short-circuit */
+	test_proc_false_const_false(&t)
+	test_proc_false_const_true(&t)
+	test_proc_true_const_false(&t)
+	test_proc_true_const_true(&t)
+
+	tc.report(&t)
+}
+
+/* Original issue #1592 example */
+
+// I get a LLVM code gen error when this constant is false, but it works when it is true
+CONSTANT_BOOL :: false
+
+bool_result :: proc() -> bool {
+	return false
+}
+
+@test
+test_orig :: proc() {
+	if bool_result() || CONSTANT_BOOL {
+	}
+}
+
+CONSTANT_FALSE :: false
+CONSTANT_TRUE :: true
+
+false_result :: proc() -> bool {
+	return false
+}
+true_result :: proc() -> bool {
+	return true
+}
+
+@test
+test_simple_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if (!CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !!CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE == true {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE == false {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE == true) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE == false) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_simple_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if (CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (!CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (!CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !!CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE == true {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE == false {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE == true) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE == false) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_simple_proc_false :: proc(t: ^testing.T) {
+	if false_result() {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !false_result() {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_simple_proc_true :: proc(t: ^testing.T) {
+	if true_result() {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !true_result() {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_const_false_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_FALSE || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_FALSE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_FALSE || !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_FALSE && !CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_FALSE || CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_false_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_FALSE && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_FALSE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_FALSE && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if CONSTANT_FALSE || !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE && !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_FALSE || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_FALSE && CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_true_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_TRUE || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !CONSTANT_TRUE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_TRUE || !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !(CONSTANT_TRUE || CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_true_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !CONSTANT_TRUE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_TRUE && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_TRUE || !CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_TRUE || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE && CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_proc_false_const_false :: proc(t: ^testing.T) {
+	if false_result() || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if false_result() && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(false_result() || CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(false_result() && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_false_const_true :: proc(t: ^testing.T) {
+	if false_result() || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if false_result() && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(false_result() || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(false_result() && CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_true_const_false :: proc(t: ^testing.T) {
+	if true_result() || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if true_result() && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(true_result() || CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(true_result() && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_true_const_true :: proc(t: ^testing.T) {
+	if true_result() || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if true_result() && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !(true_result() || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(true_result() && CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
diff --git a/tests/issues/test_issue_829.odin b/tests/issues/test_issue_829.odin
new file mode 100644
index 000000000..4ff3d71f1
--- /dev/null
+++ b/tests/issues/test_issue_829.odin
@@ -0,0 +1,33 @@
+// Tests issue #829 https://github.com/odin-lang/Odin/issues/829
+package test_issues
+
+import "core:fmt"
+import "core:testing"
+import tc "tests:common"
+
+/* Original issue #829 example */
+
+env : map[string]proc(a, b : int) -> int = {
+	"+" = proc(a, b : int) -> int {
+		return a + b
+	},
+}
+
+test_orig :: proc() {
+	fmt.println(env["+"](1, 2))
+}
+
+main :: proc() {
+	t := testing.T{}
+
+	test_orig()
+
+	test_orig_ret(&t)
+
+	tc.report(&t)
+}
+
+test_orig_ret :: proc(t: ^testing.T) {
+	r := fmt.tprint(env["+"](1, 2))
+	tc.expect(t, r == "3", fmt.tprintf("%s: \"%s\" != \"3\"\n", #procedure, r))
+}
diff --git a/tests/vendor/Makefile b/tests/vendor/Makefile
index f0a456bae..6c68d7908 100644
--- a/tests/vendor/Makefile
+++ b/tests/vendor/Makefile
@@ -1,6 +1,13 @@
 ODIN=../../odin
+ODINFLAGS=
+
+OS=$(shell uname)
+
+ifeq ($(OS), OpenBSD)
+    ODINFLAGS:=$(ODINFLAGS) -extra-linker-flags:-L/usr/local/lib
+endif
 
 all: botan_test
 
 botan_test:
-	$(ODIN) run botan -out=botan_hash -o:speed -no-bounds-check
\ No newline at end of file
+	$(ODIN) run botan -o:speed -no-bounds-check $(ODINFLAGS) -out=vendor_botan
diff --git a/tests/vendor/botan/test_vendor_botan.odin b/tests/vendor/botan/test_vendor_botan.odin
index e92410621..f0ff44ac9 100644
--- a/tests/vendor/botan/test_vendor_botan.odin
+++ b/tests/vendor/botan/test_vendor_botan.odin
@@ -14,6 +14,7 @@ package test_vendor_botan
 
 import "core:testing"
 import "core:fmt"
+import "core:os"
 
 import "vendor:botan/md4"
 import "vendor:botan/md5"
@@ -30,6 +31,7 @@ import "vendor:botan/gost"
 import "vendor:botan/streebog"
 import "vendor:botan/sm3"
 import "vendor:botan/skein512"
+import "vendor:botan/siphash"
 
 TEST_count := 0
 TEST_fail  := 0
@@ -82,8 +84,12 @@ main :: proc() {
     test_sm3(&t)
     test_skein512_256(&t)
     test_skein512_512(&t)
+    test_siphash_2_4(&t)
 
     fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+    if TEST_fail > 0 {
+        os.exit(1)
+    }
 }
 
 TestHash :: struct {
@@ -575,3 +581,44 @@ test_skein512_512 :: proc(t: ^testing.T) {
         expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
     }
 }
+
+@(test)
+test_siphash_2_4 :: proc(t: ^testing.T) {
+    // Test vectors from 
+    // https://github.com/veorq/SipHash/blob/master/vectors.h
+    test_vectors := [?]u64 {
+        0x726fdb47dd0e0e31, 0x74f839c593dc67fd, 0x0d6c8009d9a94f5a, 0x85676696d7fb7e2d,
+        0xcf2794e0277187b7, 0x18765564cd99a68d, 0xcbc9466e58fee3ce, 0xab0200f58b01d137,
+        0x93f5f5799a932462, 0x9e0082df0ba9e4b0, 0x7a5dbbc594ddb9f3, 0xf4b32f46226bada7,
+        0x751e8fbc860ee5fb, 0x14ea5627c0843d90, 0xf723ca908e7af2ee, 0xa129ca6149be45e5,
+        0x3f2acc7f57c29bdb, 0x699ae9f52cbe4794, 0x4bc1b3f0968dd39c, 0xbb6dc91da77961bd,
+        0xbed65cf21aa2ee98, 0xd0f2cbb02e3b67c7, 0x93536795e3a33e88, 0xa80c038ccd5ccec8,
+        0xb8ad50c6f649af94, 0xbce192de8a85b8ea, 0x17d835b85bbb15f3, 0x2f2e6163076bcfad,
+        0xde4daaaca71dc9a5, 0xa6a2506687956571, 0xad87a3535c49ef28, 0x32d892fad841c342,
+        0x7127512f72f27cce, 0xa7f32346f95978e3, 0x12e0b01abb051238, 0x15e034d40fa197ae,
+        0x314dffbe0815a3b4, 0x027990f029623981, 0xcadcd4e59ef40c4d, 0x9abfd8766a33735c,
+        0x0e3ea96b5304a7d0, 0xad0c42d6fc585992, 0x187306c89bc215a9, 0xd4a60abcf3792b95,
+        0xf935451de4f21df2, 0xa9538f0419755787, 0xdb9acddff56ca510, 0xd06c98cd5c0975eb,
+        0xe612a3cb9ecba951, 0xc766e62cfcadaf96, 0xee64435a9752fe72, 0xa192d576b245165a,
+        0x0a8787bf8ecb74b2, 0x81b3e73d20b49b6f, 0x7fa8220ba3b2ecea, 0x245731c13ca42499,
+        0xb78dbfaf3a8d83bd, 0xea1ad565322a1a0b, 0x60e61c23a3795013, 0x6606d7e446282b93,
+        0x6ca4ecb15c5f91e1, 0x9f626da15c9625f3, 0xe51b38608ef25f57, 0x958a324ceb064572,
+    }
+
+    key: [16]byte
+    for i in 0..<16 {
+        key[i] = byte(i)
+    }
+
+    for i in 0..<len(test_vectors) {
+        data := make([]byte, i)
+        for j in 0..<i {
+            data[j] = byte(j)
+        }
+
+        vector   := test_vectors[i]
+        computed := siphash.sum_2_4(data[:], key[:])
+
+        expect(t, computed == vector, fmt.tprintf("Expected: 0x%x for input of %v, but got 0x%x instead", vector, data, computed))
+    }  
+}
\ No newline at end of file
diff --git a/tests/vendor/build.bat b/tests/vendor/build.bat
index e70d9f1d5..d92a5eaea 100644
--- a/tests/vendor/build.bat
+++ b/tests/vendor/build.bat
@@ -5,9 +5,9 @@ set PATH_TO_ODIN==..\..\odin
 echo ---

 echo Running vendor:botan tests

 echo ---

-%PATH_TO_ODIN% run botan %COMMON%

+%PATH_TO_ODIN% run botan %COMMON% -out:vendor_botan.exe

 

 echo ---

 echo Running vendor:glfw tests

 echo ---

-%PATH_TO_ODIN% run glfw %COMMON%
\ No newline at end of file
+%PATH_TO_ODIN% run glfw %COMMON% -out:vendor_glfw.exe
\ No newline at end of file
diff --git a/tests/vendor/glfw/test_vendor_glfw.odin b/tests/vendor/glfw/test_vendor_glfw.odin
index 252df2033..baf46aa7e 100644
--- a/tests/vendor/glfw/test_vendor_glfw.odin
+++ b/tests/vendor/glfw/test_vendor_glfw.odin
@@ -3,6 +3,7 @@ package test_vendor_glfw
 import "core:testing"
 import "core:fmt"
 import "vendor:glfw"
+import "core:os"
 
 GLFW_MAJOR :: 3
 GLFW_MINOR :: 3
@@ -36,6 +37,9 @@ main :: proc() {
 	test_glfw(&t)
 
 	fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
+	if TEST_fail > 0 {
+		os.exit(1)
+	}
 }
 
 @(test)