mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-06-01 08:21:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
hikari
2022-10-01 17:12:57 +03:00
parent a728047281 775c9648f9
commit b7fd91817e
10 changed files with 261 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/nightly.yml vendored
View File

@@ -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

2
.gitignore vendored
View File

@@ -271,7 +271,7 @@ odin
odin.dSYM
*.bin
demo.bin
libLLVM*.so
libLLVM*.so*
# shared collection
shared/

6
build_odin.sh
View File

@@ -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() {

16
core/encoding/json/unmarshal.odin
View File

@@ -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:

34
core/strconv/strconv.odin
View File

@@ -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

10
tests/issues/run.bat
View File

@@ -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

10
tests/issues/run.sh
View File

@@ -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

323
tests/issues/test_issue_1592.odin
View File

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

58
tests/issues/test_issue_2087.odin Normal file
View File

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

19
tests/issues/test_issue_829.odin
View File

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