neoneo-go/pkg/compiler/convert_test.go
2021-02-08 11:02:45 +03:00

131 lines
2.7 KiB
Go

package compiler_test
import (
"fmt"
"math/big"
"testing"
)
type convertTestCase struct {
returnType string
argValue string
result interface{}
}
func getFunctionName(typ string) string {
switch typ {
case "bool":
return "Bool"
case "[]byte":
return "ByteArray"
case "int64":
return "Integer"
}
panic("invalid type")
}
func TestConvert(t *testing.T) {
srcTmpl := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/convert"
func Main() %s {
arg := %s
return convert.To%s(arg)
}`
convertTestCases := []convertTestCase{
{"bool", "true", true},
{"bool", "false", false},
{"bool", "12", true},
{"bool", "0", false},
{"bool", "[]byte{0, 1, 0}", true},
{"bool", "[]byte{0}", true},
{"bool", `""`, false},
{"int64", "true", big.NewInt(1)},
{"int64", "false", big.NewInt(0)},
{"int64", "12", big.NewInt(12)},
{"int64", "0", big.NewInt(0)},
{"int64", "[]byte{0, 1, 0}", big.NewInt(256)},
{"int64", "[]byte{0}", big.NewInt(0)},
{"[]byte", "true", []byte{1}},
{"[]byte", "false", []byte{0}},
{"[]byte", "12", []byte{0x0C}},
{"[]byte", "0", []byte{}},
{"[]byte", "[]byte{0, 1, 0}", []byte{0, 1, 0}},
}
for _, tc := range convertTestCases {
name := getFunctionName(tc.returnType)
t.Run(tc.argValue+"->"+name, func(t *testing.T) {
src := fmt.Sprintf(srcTmpl, tc.returnType, tc.argValue, name)
eval(t, src, tc.result)
})
}
}
func TestTypeAssertion(t *testing.T) {
src := `package foo
func Main() int {
a := []byte{1}
var u interface{}
u = a
return u.(int)
}`
eval(t, src, big.NewInt(1))
}
func TestTypeConversion(t *testing.T) {
src := `package foo
type myInt int
func Main() int32 {
var a int32 = 41
b := myInt(a)
incMy := func(x myInt) myInt { return x + 1 }
c := incMy(b)
return int32(c)
}`
eval(t, src, big.NewInt(42))
}
func TestSelectorTypeConversion(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/compiler/testdata/types"
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
import "github.com/nspcc-dev/neo-go/pkg/interop"
func Main() int {
var a int
if util.Equals(types.Buffer(nil), nil) {
a += 1
}
// Buffer != ByteArray
if util.Equals(types.Buffer("\x12"), "\x12") {
a += 10
}
tmp := []byte{0x23}
if util.Equals(types.ByteString(tmp), "\x23") {
a += 100
}
addr := "aaaaaaaaaaaaaaaaaaaa"
buf := []byte(addr)
if util.Equals(interop.Hash160(addr), interop.Hash160(buf)) {
a += 1000
}
return a
}`
eval(t, src, big.NewInt(1101))
}
func TestTypeConversionString(t *testing.T) {
src := `package foo
type mystr string
func Main() mystr {
b := []byte{'l', 'a', 'm', 'a', 'o'}
s := mystr(b)
b[0] = 'u'
return s
}`
eval(t, src, []byte("lamao"))
}