diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index f84f14f76..7fe7513e0 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -50,7 +50,7 @@ jobs:
         run: |
           mkdir dist
           cp odin dist
-          cp libLLVM*.so dist
+          cp libLLVM* dist
           cp -r shared dist
           cp -r core dist
           cp -r vendor dist
diff --git a/.gitignore b/.gitignore
index deccccbbd..67314e23a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -271,7 +271,7 @@ odin
 odin.dSYM
 *.bin
 demo.bin
-libLLVM*.so
+libLLVM*.so*
 
 # shared collection
 shared/
diff --git a/build_odin.sh b/build_odin.sh
index b7462106b..4d2e461dd 100755
--- a/build_odin.sh
+++ b/build_odin.sh
@@ -100,7 +100,11 @@ config_linux() {
 	LDFLAGS="$LDFLAGS -ldl"
 	CXXFLAGS="$CXXFLAGS $($LLVM_CONFIG --cxxflags --ldflags)"
 	LDFLAGS="$LDFLAGS $($LLVM_CONFIG  --libs core native --system-libs --libfiles) -Wl,-rpath=\$ORIGIN"
-	cp $($LLVM_CONFIG --libfiles) ./
+
+	# Creates a copy of the llvm library in the build dir, this is meant to support compiler explorer.
+	# The annoyance is that this copy can be cluttering the development folder. TODO: split staging folders
+	# for development and compiler explorer builds
+	cp $(readlink -f $($LLVM_CONFIG --libfiles)) ./
 }
 
 build_odin() {
diff --git a/core/encoding/json/unmarshal.odin b/core/encoding/json/unmarshal.odin
index 062649b58..19288a294 100644
--- a/core/encoding/json/unmarshal.odin
+++ b/core/encoding/json/unmarshal.odin
@@ -380,20 +380,18 @@ unmarshal_object :: proc(p: ^Parser, v: any, end_token: Token_Kind) -> (err: Unm
 				field := any{field_ptr, type.id}
 				unmarshal_value(p, field) or_return
 					
+				if parse_comma(p) {
+					break struct_loop
+				}
+				continue struct_loop
+			} else {
+				// allows skipping unused struct fields
+				parse_value(p) or_return
 				if parse_comma(p) {
 					break struct_loop
 				}
 				continue struct_loop
 			}
-			
-			// NOTE(bill, 2022-09-14): Previously this would not be allowed
-			//         {"foo": 123, "bar": 456}
-			//         T :: struct{foo: int}
-			// `T` is missing the `bar` field
-			// The line below is commented out to ignore fields in an object which
-			// do not have a corresponding target field
-			//
-			// return Unsupported_Type_Error{v.id, p.curr_token}
 		}
 		
 	case reflect.Type_Info_Map:
diff --git a/core/strconv/strconv.odin b/core/strconv/strconv.odin
index c2d48be7a..ae89722bf 100644
--- a/core/strconv/strconv.odin
+++ b/core/strconv/strconv.odin
@@ -567,7 +567,7 @@ parse_f32 :: proc(s: string, n: ^int = nil) -> (value: f32, ok: bool) {
 // ```
 parse_f64 :: proc(str: string, n: ^int = nil) -> (value: f64, ok: bool) {
 	s := str
-	defer if n != nil { n^ = len(str)-len(s) }
+	defer if n != nil { n^ = len(str) - len(s) }
 	if s == "" {
 		return
 	}
@@ -588,6 +588,38 @@ parse_f64 :: proc(str: string, n: ^int = nil) -> (value: f64, ok: bool) {
 
 		v := _digit_value(r)
 		if v >= 10 {
+			if r == '.' || r == 'e' || r == 'E' { // Skip parsing NaN and Inf if it's probably a regular float
+				break
+			}
+			if len(s) >= 3 + i {
+				buf: [4]u8
+				copy(buf[:], s[i:][:3])
+
+				v2 := transmute(u32)buf
+				v2 &= 0xDFDFDFDF // Knock out lower-case bits
+
+				buf = transmute([4]u8)v2
+
+				when ODIN_ENDIAN == .Little {
+					if v2 == 0x464e49 { // "INF"
+						s = s[3+i:]
+						value = 0h7ff00000_00000000 if sign == 1 else 0hfff00000_00000000
+						return value, len(s) == 0
+					} else if v2 == 0x4e414e { // "NAN"
+						s = s[3+i:]
+						return 0h7ff80000_00000001, len(s) == 0
+					}
+				} else {
+					if v2 == 0x494e4600 { // "\0FNI"
+						s = s[3+i:]
+						value = 0h7ff00000_00000000 if sign == 1 else 0hfff00000_00000000
+						return value, len(s) == 0
+					} else if v2 == 0x4e414e00 { // "\0NAN"
+						s = s[3+i:]
+						return 0h7ff80000_00000001, len(s) == 0
+					}
+				}
+			}
 			break
 		}
 		value *= 10
diff --git a/tests/issues/run.bat b/tests/issues/run.bat
index a7078ae0f..2ecd14d95 100644
--- a/tests/issues/run.bat
+++ b/tests/issues/run.bat
@@ -2,15 +2,13 @@
 
 if not exist "build\" mkdir build
 
-set COMMON=-collection:tests=.. -out:build\test_issue.exe
+set COMMON=-collection:tests=..
 
 @echo on
 
-..\..\odin build test_issue_829.odin %COMMON% -file
-build\test_issue
-
-..\..\odin build test_issue_1592.odin %COMMON% -file
-build\test_issue
+..\..\odin test test_issue_829.odin %COMMON% -file
+..\..\odin test test_issue_1592.odin %COMMON% -file
+..\..\odin test test_issue_2087.odin %COMMON% -file
 
 @echo off
 
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
index ec0804bac..f781c8278 100755
--- a/tests/issues/run.sh
+++ b/tests/issues/run.sh
@@ -3,15 +3,13 @@ set -eu
 
 mkdir -p build
 ODIN=../../odin
-COMMON="-collection:tests=.. -out:build/test_issue"
+COMMON="-collection:tests=.."
 
 set -x
 
-$ODIN build test_issue_829.odin $COMMON -file
-./build/test_issue
-
-$ODIN build test_issue_1592.odin $COMMON -file
-./build/test_issue
+$ODIN test test_issue_829.odin  $COMMON -file
+$ODIN test test_issue_1592.odin $COMMON -file
+$ODIN test test_issue_2087.odin $COMMON -file
 
 set +x
 
diff --git a/tests/issues/test_issue_1592.odin b/tests/issues/test_issue_1592.odin
index bb350a30b..800314a93 100644
--- a/tests/issues/test_issue_1592.odin
+++ b/tests/issues/test_issue_1592.odin
@@ -3,36 +3,6 @@ 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 */
 
@@ -43,7 +13,6 @@ bool_result :: proc() -> bool {
 	return false
 }
 
-@test
 test_orig :: proc() {
 	if bool_result() || CONSTANT_BOOL {
 	}
@@ -62,428 +31,428 @@ true_result :: proc() -> bool {
 @test
 test_simple_const_false :: proc(t: ^testing.T) {
 	if CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if (CONSTANT_FALSE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !CONSTANT_FALSE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if (!CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !(CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !!CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if CONSTANT_FALSE == true {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if CONSTANT_FALSE == false {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !(CONSTANT_FALSE == true) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !(CONSTANT_FALSE == false) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if (CONSTANT_TRUE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if (!CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if (!CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !!CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE == true {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE == false {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_TRUE == true) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_TRUE == false) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !false_result() {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !true_result() {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.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))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if CONSTANT_FALSE && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !CONSTANT_FALSE || CONSTANT_FALSE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !CONSTANT_FALSE && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if CONSTANT_FALSE || !CONSTANT_FALSE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_FALSE && !CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(CONSTANT_FALSE || CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !(CONSTANT_FALSE && CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_FALSE && CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !CONSTANT_FALSE || CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !CONSTANT_FALSE && CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 
 	if CONSTANT_FALSE || !CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if CONSTANT_FALSE && !CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(CONSTANT_FALSE || CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_FALSE && CONSTANT_TRUE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !CONSTANT_TRUE || CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !CONSTANT_TRUE && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if CONSTANT_TRUE || !CONSTANT_FALSE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE && !CONSTANT_FALSE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 
 	if !(CONSTANT_TRUE || CONSTANT_FALSE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_TRUE && CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE && CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 
 	if !CONSTANT_TRUE || CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !CONSTANT_TRUE && CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if CONSTANT_TRUE || !CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if CONSTANT_TRUE && !CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(CONSTANT_TRUE || CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(CONSTANT_TRUE && CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.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))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if false_result() && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(false_result() || CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if !(false_result() && CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if false_result() && CONSTANT_TRUE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(false_result() || CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(false_result() && CONSTANT_TRUE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if true_result() && CONSTANT_FALSE {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 
 	if !(true_result() || CONSTANT_FALSE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(true_result() && CONSTANT_FALSE) {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.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))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 	if true_result() && CONSTANT_TRUE {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	} else {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	}
 
 	if !(true_result() || CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 	if !(true_result() && CONSTANT_TRUE) {
-		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+		testing.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
 	} else {
-		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+		testing.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
 	}
 }
diff --git a/tests/issues/test_issue_2087.odin b/tests/issues/test_issue_2087.odin
new file mode 100644
index 000000000..19181bfca
--- /dev/null
+++ b/tests/issues/test_issue_2087.odin
@@ -0,0 +1,58 @@
+// Tests issue #2087 https://github.com/odin-lang/Odin/issues/2087
+package test_issues
+
+import "core:math"
+import "core:strconv"
+import "core:testing"
+
+@(test)
+test_parse_float :: proc(t: ^testing.T) {
+	{
+		f, ok := strconv.parse_f64("1.2")
+		testing.expect(t, ok && f == 1.2, "expected f64(1.2), fully consumed")
+
+		f, ok = strconv.parse_f64("1.2a")
+		testing.expect(t, !ok && f == 1.2, "expected f64(1.2), partially consumed")
+
+		f, ok = strconv.parse_f64("inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Inf, "expected f64(+inf), fully consumed")
+		f, ok = strconv.parse_f64("+inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Inf, "expected f64(+inf), fully consumed")
+		f, ok = strconv.parse_f64("-inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Neg_Inf, "expected f64(-inf), fully consumed")
+		f, ok = strconv.parse_f64("inFinity")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Inf, "expected f64(+inf), partially consumed")
+		f, ok = strconv.parse_f64("+InFinity")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Inf, "expected f64(+inf), partially consumed")
+		f, ok = strconv.parse_f64("-InfiniTy")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Neg_Inf, "expected f64(-inf), partially consumed")
+		f, ok = strconv.parse_f64("nan")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.NaN, "expected f64(nan), fully consumed")
+		f, ok = strconv.parse_f64("nAN")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.NaN, "expected f64(nan), fully consumed")
+	}
+	{
+		f, ok := strconv.parse_f32("1.2")
+		testing.expect(t, ok && f == 1.2, "expected f32(1.2), fully consumed")
+
+		f, ok = strconv.parse_f32("1.2a")
+		testing.expect(t, !ok && f == 1.2, "expected f32(1.2), partially consumed")
+
+		f, ok = strconv.parse_f32("inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Inf, "expected f32(+inf), fully consumed")
+		f, ok = strconv.parse_f32("+inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Inf, "expected f32(+inf), fully consumed")
+		f, ok = strconv.parse_f32("-inf")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.Neg_Inf, "expected f32(-inf), fully consumed")
+		f, ok = strconv.parse_f32("inFinity")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Inf, "expected f32(+inf), partially consumed")
+		f, ok = strconv.parse_f32("+InFinity")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Inf, "expected f32(+inf), partially consumed")
+		f, ok = strconv.parse_f32("-InfiniTy")
+		testing.expect(t, !ok && math.classify(f) == math.Float_Class.Neg_Inf, "expected f32(-inf), partially consumed")
+		f, ok = strconv.parse_f32("nan")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.NaN, "expected f32(nan), fully consumed")
+		f, ok = strconv.parse_f32("nAN")
+		testing.expect(t, ok && math.classify(f) == math.Float_Class.NaN, "expected f32(nan), fully consumed")
+	}
+}
\ No newline at end of file
diff --git a/tests/issues/test_issue_829.odin b/tests/issues/test_issue_829.odin
index 4ff3d71f1..273b3b3b5 100644
--- a/tests/issues/test_issue_829.odin
+++ b/tests/issues/test_issue_829.odin
@@ -3,31 +3,16 @@ 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)
 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))
+	testing.expect(t, r == "3", fmt.tprintf("%s: \"%s\" != \"3\"\n", #procedure, r))
 }