[strconv] Add parsing of Inf & NaN

5 files changed, 214 insertions, 206 deletions

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