mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-07-26 06:38:42 +00:00
reflect: use TestConvert from all_test.go and make it pass
This PR removes convert_test.go which was a minimal version of this test.
This commit is contained in:
Damian Gryski
committed by
Damian Gryski
Damian Gryski
parent
3abe58448b
commit
1c0c26b8b7
@@ -760,11 +760,6 @@ func (r *RawType) ConvertibleTo(u *RawType) bool {
|
||||
|
||||
// This logic is mostly copied from Value.CanConvert
|
||||
|
||||
// Don't need to do anything
|
||||
if r.underlying() == u.underlying() {
|
||||
return true
|
||||
}
|
||||
|
||||
switch r.Kind() {
|
||||
case Int, Int8, Int16, Int32, Int64:
|
||||
switch u.Kind() {
|
||||
@@ -812,13 +807,13 @@ func (r *RawType) ConvertibleTo(u *RawType) bool {
|
||||
|
||||
case Pointer:
|
||||
// This may fail at runtime if there isn't room
|
||||
if u.elem().Kind() == Array {
|
||||
if u.elem().Kind() == Array && r.elem() == u.elem().elem() {
|
||||
return true
|
||||
}
|
||||
|
||||
case String:
|
||||
// bytes or runes
|
||||
if r.elem().Kind() == Uint8 || r.elem().Kind() == Int32 {
|
||||
if !r.elem().isNamed() && (r.elem().Kind() == Uint8 || r.elem().Kind() == Int32) {
|
||||
return true
|
||||
}
|
||||
|
||||
@@ -826,16 +821,27 @@ func (r *RawType) ConvertibleTo(u *RawType) bool {
|
||||
|
||||
case String:
|
||||
// bytes or runes
|
||||
if u.elem().Kind() == Uint8 || u.elem().Kind() == Int32 {
|
||||
if u.Kind() == Slice && !u.elem().isNamed() && (u.elem().Kind() == Uint8 || u.elem().Kind() == Int32) {
|
||||
return true
|
||||
}
|
||||
|
||||
case Pointer:
|
||||
if !r.isNamed() && u.Kind() == Pointer && !u.isNamed() && r.elem().underlying() == u.elem().underlying() {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
if r.underlying() == u.underlying() {
|
||||
return true
|
||||
}
|
||||
|
||||
if u.Kind() == Interface && u.NumMethod() == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
// TODO(dgryski): Unimplemented
|
||||
// struct types
|
||||
// channels
|
||||
//
|
||||
|
||||
return false
|
||||
|
||||
|
||||
@@ -47,12 +47,20 @@ func (v Value) isExported() bool {
|
||||
return v.flags&valueFlagExported != 0
|
||||
}
|
||||
|
||||
func (v Value) isRO() bool {
|
||||
func (v Value) IsRO() bool {
|
||||
return v.flags&(valueFlagRO) != 0
|
||||
}
|
||||
|
||||
func (v *Value) MakeRO(ro bool) {
|
||||
if ro {
|
||||
v.flags |= valueFlagRO
|
||||
} else {
|
||||
v.flags &^= valueFlagRO
|
||||
}
|
||||
}
|
||||
|
||||
func (v Value) checkRO() {
|
||||
if v.isRO() {
|
||||
if v.IsRO() {
|
||||
panic("reflect: value is not settable")
|
||||
}
|
||||
}
|
||||
@@ -297,7 +305,7 @@ func (v Value) IsValid() bool {
|
||||
}
|
||||
|
||||
func (v Value) CanInterface() bool {
|
||||
return v.isExported() && !v.isRO()
|
||||
return v.isExported() && !v.IsRO()
|
||||
}
|
||||
|
||||
func (v Value) CanAddr() bool {
|
||||
@@ -1532,6 +1540,12 @@ func convertOp(src Value, typ Type) (Value, bool) {
|
||||
return cvtStringRunes(src, rtype), true
|
||||
}
|
||||
}
|
||||
|
||||
case Pointer:
|
||||
rtype := typ.(*RawType)
|
||||
if rtype.Kind() == Pointer && !rtype.isNamed() {
|
||||
return cvtDirect(src, rtype), true
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(dgryski): Unimplemented:
|
||||
@@ -1576,6 +1590,14 @@ func cvtFloat(v Value, t *RawType) Value {
|
||||
return makeFloat(v.flags, v.Float(), t)
|
||||
}
|
||||
|
||||
func cvtDirect(v Value, t *RawType) Value {
|
||||
return Value{
|
||||
typecode: t,
|
||||
value: v.value,
|
||||
flags: v.flags,
|
||||
}
|
||||
}
|
||||
|
||||
func cvtComplex(v Value, t *RawType) Value {
|
||||
return makeComplex(v.flags, v.Complex(), t)
|
||||
}
|
||||
@@ -1697,7 +1719,7 @@ func cvtIntString(v Value, t *RawType) Value {
|
||||
return Value{
|
||||
typecode: t,
|
||||
value: unsafe.Pointer(&s),
|
||||
flags: v.flags | valueFlagRO,
|
||||
flags: v.flags,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1710,7 +1732,7 @@ func cvtUintString(v Value, t *RawType) Value {
|
||||
return Value{
|
||||
typecode: t,
|
||||
value: unsafe.Pointer(&s),
|
||||
flags: v.flags | valueFlagRO,
|
||||
flags: v.flags,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+85
-68
@@ -4249,8 +4249,6 @@ type BytesChan chan []byte
|
||||
type BytesChanRecv <-chan []byte
|
||||
type BytesChanSend chan<- []byte
|
||||
|
||||
/*
|
||||
|
||||
var convertTests = []struct {
|
||||
in Value
|
||||
out Value
|
||||
@@ -4286,7 +4284,7 @@ var convertTests = []struct {
|
||||
}
|
||||
}
|
||||
}
|
||||
*/ /*
|
||||
*/
|
||||
{V(int8(1)), V(int8(1))},
|
||||
{V(int8(2)), V(uint8(2))},
|
||||
{V(uint8(3)), V(int8(3))},
|
||||
@@ -4602,37 +4600,41 @@ var convertTests = []struct {
|
||||
{V((func())(nil)), V(MyFunc(nil))},
|
||||
{V((MyFunc)(nil)), V((func())(nil))},
|
||||
|
||||
// structs with different tags
|
||||
{V(struct {
|
||||
x int `some:"foo"`
|
||||
}{}), V(struct {
|
||||
x int `some:"bar"`
|
||||
}{})},
|
||||
/*
|
||||
|
||||
{V(struct {
|
||||
x int `some:"bar"`
|
||||
}{}), V(struct {
|
||||
x int `some:"foo"`
|
||||
}{})},
|
||||
// structs with different tags
|
||||
{V(struct {
|
||||
x int `some:"foo"`
|
||||
}{}), V(struct {
|
||||
x int `some:"bar"`
|
||||
}{})},
|
||||
|
||||
{V(MyStruct{}), V(struct {
|
||||
x int `some:"foo"`
|
||||
}{})},
|
||||
{V(struct {
|
||||
x int `some:"bar"`
|
||||
}{}), V(struct {
|
||||
x int `some:"foo"`
|
||||
}{})},
|
||||
|
||||
{V(struct {
|
||||
x int `some:"foo"`
|
||||
}{}), V(MyStruct{})},
|
||||
{V(MyStruct{}), V(struct {
|
||||
x int `some:"foo"`
|
||||
}{})},
|
||||
|
||||
{V(MyStruct{}), V(struct {
|
||||
x int `some:"bar"`
|
||||
}{})},
|
||||
{V(struct {
|
||||
x int `some:"foo"`
|
||||
}{}), V(MyStruct{})},
|
||||
|
||||
{V(struct {
|
||||
x int `some:"bar"`
|
||||
}{}), V(MyStruct{})},
|
||||
{V(MyStruct{}), V(struct {
|
||||
x int `some:"bar"`
|
||||
}{})},
|
||||
|
||||
{V(MyStruct1{}), V(MyStruct2{})},
|
||||
{V(MyStruct2{}), V(MyStruct1{})},
|
||||
{V(struct {
|
||||
x int `some:"bar"`
|
||||
}{}), V(MyStruct{})},
|
||||
|
||||
|
||||
{V(MyStruct1{}), V(MyStruct2{})},
|
||||
{V(MyStruct2{}), V(MyStruct1{})},
|
||||
*/
|
||||
|
||||
// can convert *byte and *MyByte
|
||||
{V((*byte)(nil)), V((*MyByte)(nil))},
|
||||
@@ -4674,46 +4676,59 @@ var convertTests = []struct {
|
||||
{V(new(io.Reader)), V(new(io.Reader))},
|
||||
{V(new(io.Writer)), V(new(io.Writer))},
|
||||
|
||||
// channels
|
||||
{V(IntChan(nil)), V((chan<- int)(nil))},
|
||||
{V(IntChan(nil)), V((<-chan int)(nil))},
|
||||
{V((chan int)(nil)), V(IntChanRecv(nil))},
|
||||
{V((chan int)(nil)), V(IntChanSend(nil))},
|
||||
{V(IntChanRecv(nil)), V((<-chan int)(nil))},
|
||||
{V((<-chan int)(nil)), V(IntChanRecv(nil))},
|
||||
{V(IntChanSend(nil)), V((chan<- int)(nil))},
|
||||
{V((chan<- int)(nil)), V(IntChanSend(nil))},
|
||||
{V(IntChan(nil)), V((chan int)(nil))},
|
||||
{V((chan int)(nil)), V(IntChan(nil))},
|
||||
{V((chan int)(nil)), V((<-chan int)(nil))},
|
||||
{V((chan int)(nil)), V((chan<- int)(nil))},
|
||||
{V(BytesChan(nil)), V((chan<- []byte)(nil))},
|
||||
{V(BytesChan(nil)), V((<-chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChanRecv(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChanSend(nil))},
|
||||
{V(BytesChanRecv(nil)), V((<-chan []byte)(nil))},
|
||||
{V((<-chan []byte)(nil)), V(BytesChanRecv(nil))},
|
||||
{V(BytesChanSend(nil)), V((chan<- []byte)(nil))},
|
||||
{V((chan<- []byte)(nil)), V(BytesChanSend(nil))},
|
||||
{V(BytesChan(nil)), V((chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChan(nil))},
|
||||
{V((chan []byte)(nil)), V((<-chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V((chan<- []byte)(nil))},
|
||||
/*
|
||||
|
||||
// cannot convert other instances (channels)
|
||||
{V(IntChan(nil)), V(IntChan(nil))},
|
||||
{V(IntChanRecv(nil)), V(IntChanRecv(nil))},
|
||||
{V(IntChanSend(nil)), V(IntChanSend(nil))},
|
||||
{V(BytesChan(nil)), V(BytesChan(nil))},
|
||||
{V(BytesChanRecv(nil)), V(BytesChanRecv(nil))},
|
||||
{V(BytesChanSend(nil)), V(BytesChanSend(nil))},
|
||||
// channels
|
||||
{V(IntChan(nil)), V((chan<- int)(nil))},
|
||||
{V(IntChan(nil)), V((<-chan int)(nil))},
|
||||
{V((chan int)(nil)), V(IntChanRecv(nil))},
|
||||
{V((chan int)(nil)), V(IntChanSend(nil))},
|
||||
{V(IntChanRecv(nil)), V((<-chan int)(nil))},
|
||||
{V((<-chan int)(nil)), V(IntChanRecv(nil))},
|
||||
{V(IntChanSend(nil)), V((chan<- int)(nil))},
|
||||
{V((chan<- int)(nil)), V(IntChanSend(nil))},
|
||||
{V(IntChan(nil)), V((chan int)(nil))},
|
||||
{V((chan int)(nil)), V(IntChan(nil))},
|
||||
{V((chan int)(nil)), V((<-chan int)(nil))},
|
||||
{V((chan int)(nil)), V((chan<- int)(nil))},
|
||||
{V(BytesChan(nil)), V((chan<- []byte)(nil))},
|
||||
{V(BytesChan(nil)), V((<-chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChanRecv(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChanSend(nil))},
|
||||
{V(BytesChanRecv(nil)), V((<-chan []byte)(nil))},
|
||||
{V((<-chan []byte)(nil)), V(BytesChanRecv(nil))},
|
||||
{V(BytesChanSend(nil)), V((chan<- []byte)(nil))},
|
||||
{V((chan<- []byte)(nil)), V(BytesChanSend(nil))},
|
||||
{V(BytesChan(nil)), V((chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V(BytesChan(nil))},
|
||||
{V((chan []byte)(nil)), V((<-chan []byte)(nil))},
|
||||
{V((chan []byte)(nil)), V((chan<- []byte)(nil))},
|
||||
|
||||
// interfaces
|
||||
{V(int(1)), EmptyInterfaceV(int(1))},
|
||||
{V(string("hello")), EmptyInterfaceV(string("hello"))},
|
||||
{V(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
|
||||
{ReadWriterV(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
|
||||
{V(new(bytes.Buffer)), ReadWriterV(new(bytes.Buffer))},
|
||||
// cannot convert other instances (channels)
|
||||
{V(IntChan(nil)), V(IntChan(nil))},
|
||||
{V(IntChanRecv(nil)), V(IntChanRecv(nil))},
|
||||
{V(IntChanSend(nil)), V(IntChanSend(nil))},
|
||||
{V(BytesChan(nil)), V(BytesChan(nil))},
|
||||
{V(BytesChanRecv(nil)), V(BytesChanRecv(nil))},
|
||||
{V(BytesChanSend(nil)), V(BytesChanSend(nil))},
|
||||
|
||||
// interfaces
|
||||
{V(int(1)), EmptyInterfaceV(int(1))},
|
||||
{V(string("hello")), EmptyInterfaceV(string("hello"))},
|
||||
{V(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
|
||||
{ReadWriterV(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
|
||||
{V(new(bytes.Buffer)), ReadWriterV(new(bytes.Buffer))},
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
func IsRO(v Value) bool {
|
||||
return v.IsRO()
|
||||
}
|
||||
|
||||
func MakeRO(v Value) Value {
|
||||
v.MakeRO(true)
|
||||
return v
|
||||
}
|
||||
|
||||
func TestConvert(t *testing.T) {
|
||||
@@ -4804,6 +4819,8 @@ func TestConvert(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
func TestConvertPanic(t *testing.T) {
|
||||
s := make([]byte, 4)
|
||||
p := new([8]byte)
|
||||
@@ -4848,6 +4865,8 @@ func TestConvertSlice2Array(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
var gFloat32 float32
|
||||
|
||||
const snan uint32 = 0x7f800001
|
||||
@@ -4870,8 +4889,6 @@ func TestConvertNaNs(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
type ComparableStruct struct {
|
||||
X int
|
||||
}
|
||||
|
||||
@@ -1,325 +0,0 @@
|
||||
package reflect_test
|
||||
|
||||
import (
|
||||
. "reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTinyConvert(t *testing.T) {
|
||||
|
||||
V := ValueOf
|
||||
|
||||
var tests = []struct {
|
||||
have, want Value
|
||||
}{
|
||||
{V(int8(1)), V(int8(1))},
|
||||
{V(int8(2)), V(uint8(2))},
|
||||
{V(uint8(3)), V(int8(3))},
|
||||
{V(int8(4)), V(int16(4))},
|
||||
{V(int16(5)), V(int8(5))},
|
||||
{V(int8(6)), V(uint16(6))},
|
||||
{V(uint16(7)), V(int8(7))},
|
||||
{V(int8(8)), V(int32(8))},
|
||||
{V(int32(9)), V(int8(9))},
|
||||
{V(int8(10)), V(uint32(10))},
|
||||
{V(uint32(11)), V(int8(11))},
|
||||
{V(int8(12)), V(int64(12))},
|
||||
{V(int64(13)), V(int8(13))},
|
||||
{V(int8(14)), V(uint64(14))},
|
||||
{V(uint64(15)), V(int8(15))},
|
||||
{V(int8(16)), V(int(16))},
|
||||
{V(int(17)), V(int8(17))},
|
||||
{V(int8(18)), V(uint(18))},
|
||||
{V(uint(19)), V(int8(19))},
|
||||
{V(int8(20)), V(uintptr(20))},
|
||||
{V(uintptr(21)), V(int8(21))},
|
||||
{V(int8(22)), V(float32(22))},
|
||||
{V(float32(23)), V(int8(23))},
|
||||
{V(int8(24)), V(float64(24))},
|
||||
{V(float64(25)), V(int8(25))},
|
||||
{V(uint8(26)), V(uint8(26))},
|
||||
{V(uint8(27)), V(int16(27))},
|
||||
{V(int16(28)), V(uint8(28))},
|
||||
{V(uint8(29)), V(uint16(29))},
|
||||
{V(uint16(30)), V(uint8(30))},
|
||||
{V(uint8(31)), V(int32(31))},
|
||||
{V(int32(32)), V(uint8(32))},
|
||||
{V(uint8(33)), V(uint32(33))},
|
||||
{V(uint32(34)), V(uint8(34))},
|
||||
{V(uint8(35)), V(int64(35))},
|
||||
{V(int64(36)), V(uint8(36))},
|
||||
{V(uint8(37)), V(uint64(37))},
|
||||
{V(uint64(38)), V(uint8(38))},
|
||||
{V(uint8(39)), V(int(39))},
|
||||
{V(int(40)), V(uint8(40))},
|
||||
{V(uint8(41)), V(uint(41))},
|
||||
{V(uint(42)), V(uint8(42))},
|
||||
{V(uint8(43)), V(uintptr(43))},
|
||||
{V(uintptr(44)), V(uint8(44))},
|
||||
{V(uint8(45)), V(float32(45))},
|
||||
{V(float32(46)), V(uint8(46))},
|
||||
{V(uint8(47)), V(float64(47))},
|
||||
{V(float64(48)), V(uint8(48))},
|
||||
{V(int16(49)), V(int16(49))},
|
||||
{V(int16(50)), V(uint16(50))},
|
||||
{V(uint16(51)), V(int16(51))},
|
||||
{V(int16(52)), V(int32(52))},
|
||||
{V(int32(53)), V(int16(53))},
|
||||
{V(int16(54)), V(uint32(54))},
|
||||
{V(uint32(55)), V(int16(55))},
|
||||
{V(int16(56)), V(int64(56))},
|
||||
{V(int64(57)), V(int16(57))},
|
||||
{V(int16(58)), V(uint64(58))},
|
||||
{V(uint64(59)), V(int16(59))},
|
||||
{V(int16(60)), V(int(60))},
|
||||
{V(int(61)), V(int16(61))},
|
||||
{V(int16(62)), V(uint(62))},
|
||||
{V(uint(63)), V(int16(63))},
|
||||
{V(int16(64)), V(uintptr(64))},
|
||||
{V(uintptr(65)), V(int16(65))},
|
||||
{V(int16(66)), V(float32(66))},
|
||||
{V(float32(67)), V(int16(67))},
|
||||
{V(int16(68)), V(float64(68))},
|
||||
{V(float64(69)), V(int16(69))},
|
||||
{V(uint16(70)), V(uint16(70))},
|
||||
{V(uint16(71)), V(int32(71))},
|
||||
{V(int32(72)), V(uint16(72))},
|
||||
{V(uint16(73)), V(uint32(73))},
|
||||
{V(uint32(74)), V(uint16(74))},
|
||||
{V(uint16(75)), V(int64(75))},
|
||||
{V(int64(76)), V(uint16(76))},
|
||||
{V(uint16(77)), V(uint64(77))},
|
||||
{V(uint64(78)), V(uint16(78))},
|
||||
{V(uint16(79)), V(int(79))},
|
||||
{V(int(80)), V(uint16(80))},
|
||||
{V(uint16(81)), V(uint(81))},
|
||||
{V(uint(82)), V(uint16(82))},
|
||||
{V(uint16(83)), V(uintptr(83))},
|
||||
{V(uintptr(84)), V(uint16(84))},
|
||||
{V(uint16(85)), V(float32(85))},
|
||||
{V(float32(86)), V(uint16(86))},
|
||||
{V(uint16(87)), V(float64(87))},
|
||||
{V(float64(88)), V(uint16(88))},
|
||||
{V(int32(89)), V(int32(89))},
|
||||
{V(int32(90)), V(uint32(90))},
|
||||
{V(uint32(91)), V(int32(91))},
|
||||
{V(int32(92)), V(int64(92))},
|
||||
{V(int64(93)), V(int32(93))},
|
||||
{V(int32(94)), V(uint64(94))},
|
||||
{V(uint64(95)), V(int32(95))},
|
||||
{V(int32(96)), V(int(96))},
|
||||
{V(int(97)), V(int32(97))},
|
||||
{V(int32(98)), V(uint(98))},
|
||||
{V(uint(99)), V(int32(99))},
|
||||
{V(int32(100)), V(uintptr(100))},
|
||||
{V(uintptr(101)), V(int32(101))},
|
||||
{V(int32(102)), V(float32(102))},
|
||||
{V(float32(103)), V(int32(103))},
|
||||
{V(int32(104)), V(float64(104))},
|
||||
{V(float64(105)), V(int32(105))},
|
||||
{V(uint32(106)), V(uint32(106))},
|
||||
{V(uint32(107)), V(int64(107))},
|
||||
{V(int64(108)), V(uint32(108))},
|
||||
{V(uint32(109)), V(uint64(109))},
|
||||
{V(uint64(110)), V(uint32(110))},
|
||||
{V(uint32(111)), V(int(111))},
|
||||
{V(int(112)), V(uint32(112))},
|
||||
{V(uint32(113)), V(uint(113))},
|
||||
{V(uint(114)), V(uint32(114))},
|
||||
{V(uint32(115)), V(uintptr(115))},
|
||||
{V(uintptr(116)), V(uint32(116))},
|
||||
{V(uint32(117)), V(float32(117))},
|
||||
{V(float32(118)), V(uint32(118))},
|
||||
{V(uint32(119)), V(float64(119))},
|
||||
{V(float64(120)), V(uint32(120))},
|
||||
{V(int64(121)), V(int64(121))},
|
||||
{V(int64(122)), V(uint64(122))},
|
||||
{V(uint64(123)), V(int64(123))},
|
||||
{V(int64(124)), V(int(124))},
|
||||
{V(int(125)), V(int64(125))},
|
||||
{V(int64(126)), V(uint(126))},
|
||||
{V(uint(127)), V(int64(127))},
|
||||
{V(int64(128)), V(uintptr(128))},
|
||||
{V(uintptr(129)), V(int64(129))},
|
||||
{V(int64(130)), V(float32(130))},
|
||||
{V(float32(131)), V(int64(131))},
|
||||
{V(int64(132)), V(float64(132))},
|
||||
{V(float64(133)), V(int64(133))},
|
||||
{V(uint64(134)), V(uint64(134))},
|
||||
{V(uint64(135)), V(int(135))},
|
||||
{V(int(136)), V(uint64(136))},
|
||||
{V(uint64(137)), V(uint(137))},
|
||||
{V(uint(138)), V(uint64(138))},
|
||||
{V(uint64(139)), V(uintptr(139))},
|
||||
{V(uintptr(140)), V(uint64(140))},
|
||||
{V(uint64(141)), V(float32(141))},
|
||||
{V(float32(142)), V(uint64(142))},
|
||||
{V(uint64(143)), V(float64(143))},
|
||||
{V(float64(144)), V(uint64(144))},
|
||||
{V(int(145)), V(int(145))},
|
||||
{V(int(146)), V(uint(146))},
|
||||
{V(uint(147)), V(int(147))},
|
||||
{V(int(148)), V(uintptr(148))},
|
||||
{V(uintptr(149)), V(int(149))},
|
||||
{V(int(150)), V(float32(150))},
|
||||
{V(float32(151)), V(int(151))},
|
||||
{V(int(152)), V(float64(152))},
|
||||
{V(float64(153)), V(int(153))},
|
||||
{V(uint(154)), V(uint(154))},
|
||||
{V(uint(155)), V(uintptr(155))},
|
||||
{V(uintptr(156)), V(uint(156))},
|
||||
{V(uint(157)), V(float32(157))},
|
||||
{V(float32(158)), V(uint(158))},
|
||||
{V(uint(159)), V(float64(159))},
|
||||
{V(float64(160)), V(uint(160))},
|
||||
{V(uintptr(161)), V(uintptr(161))},
|
||||
{V(uintptr(162)), V(float32(162))},
|
||||
{V(float32(163)), V(uintptr(163))},
|
||||
{V(uintptr(164)), V(float64(164))},
|
||||
{V(float64(165)), V(uintptr(165))},
|
||||
{V(float32(166)), V(float32(166))},
|
||||
{V(float32(167)), V(float64(167))},
|
||||
{V(float64(168)), V(float32(168))},
|
||||
{V(float64(169)), V(float64(169))},
|
||||
|
||||
{V(float64(1.5)), V(int(1))},
|
||||
|
||||
// complex
|
||||
{V(complex64(1i)), V(complex64(1i))},
|
||||
{V(complex64(2i)), V(complex128(2i))},
|
||||
{V(complex128(3i)), V(complex64(3i))},
|
||||
{V(complex128(4i)), V(complex128(4i))},
|
||||
|
||||
// string
|
||||
{V(string("hello")), V(string("hello"))},
|
||||
{V(string("bytes1")), V([]byte("bytes1"))},
|
||||
{V([]byte("bytes2")), V(string("bytes2"))},
|
||||
{V([]byte("bytes3")), V([]byte("bytes3"))},
|
||||
{V(string("runes♝")), V([]rune("runes♝"))},
|
||||
{V([]rune("runes♕")), V(string("runes♕"))},
|
||||
{V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
|
||||
{V(int('a')), V(string("a"))},
|
||||
{V(int8('a')), V(string("a"))},
|
||||
{V(int16('a')), V(string("a"))},
|
||||
{V(int32('a')), V(string("a"))},
|
||||
{V(int64('a')), V(string("a"))},
|
||||
{V(uint('a')), V(string("a"))},
|
||||
{V(uint8('a')), V(string("a"))},
|
||||
{V(uint16('a')), V(string("a"))},
|
||||
{V(uint32('a')), V(string("a"))},
|
||||
{V(uint64('a')), V(string("a"))},
|
||||
{V(uintptr('a')), V(string("a"))},
|
||||
{V(int(-1)), V(string("\uFFFD"))},
|
||||
{V(int8(-2)), V(string("\uFFFD"))},
|
||||
{V(int16(-3)), V(string("\uFFFD"))},
|
||||
{V(int32(-4)), V(string("\uFFFD"))},
|
||||
{V(int64(-5)), V(string("\uFFFD"))},
|
||||
{V(int64(-1 << 32)), V(string("\uFFFD"))},
|
||||
{V(int64(1 << 32)), V(string("\uFFFD"))},
|
||||
{V(uint(0x110001)), V(string("\uFFFD"))},
|
||||
{V(uint32(0x110002)), V(string("\uFFFD"))},
|
||||
{V(uint64(0x110003)), V(string("\uFFFD"))},
|
||||
{V(uint64(1 << 32)), V(string("\uFFFD"))},
|
||||
{V(uintptr(0x110004)), V(string("\uFFFD"))},
|
||||
|
||||
// named string
|
||||
{V(MyString("hello")), V(string("hello"))},
|
||||
{V(string("hello")), V(MyString("hello"))},
|
||||
{V(string("hello")), V(string("hello"))},
|
||||
{V(MyString("hello")), V(MyString("hello"))},
|
||||
{V(MyString("bytes1")), V([]byte("bytes1"))},
|
||||
{V([]byte("bytes2")), V(MyString("bytes2"))},
|
||||
{V([]byte("bytes3")), V([]byte("bytes3"))},
|
||||
{V(MyString("runes♝")), V([]rune("runes♝"))},
|
||||
{V([]rune("runes♕")), V(MyString("runes♕"))},
|
||||
{V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
|
||||
{V([]rune("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
|
||||
{V(MyRunes("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
|
||||
{V(int('a')), V(MyString("a"))},
|
||||
{V(int8('a')), V(MyString("a"))},
|
||||
{V(int16('a')), V(MyString("a"))},
|
||||
{V(int32('a')), V(MyString("a"))},
|
||||
{V(int64('a')), V(MyString("a"))},
|
||||
{V(uint('a')), V(MyString("a"))},
|
||||
{V(uint8('a')), V(MyString("a"))},
|
||||
{V(uint16('a')), V(MyString("a"))},
|
||||
{V(uint32('a')), V(MyString("a"))},
|
||||
{V(uint64('a')), V(MyString("a"))},
|
||||
{V(uintptr('a')), V(MyString("a"))},
|
||||
{V(int(-1)), V(MyString("\uFFFD"))},
|
||||
{V(int8(-2)), V(MyString("\uFFFD"))},
|
||||
{V(int16(-3)), V(MyString("\uFFFD"))},
|
||||
{V(int32(-4)), V(MyString("\uFFFD"))},
|
||||
{V(int64(-5)), V(MyString("\uFFFD"))},
|
||||
{V(uint(0x110001)), V(MyString("\uFFFD"))},
|
||||
{V(uint32(0x110002)), V(MyString("\uFFFD"))},
|
||||
{V(uint64(0x110003)), V(MyString("\uFFFD"))},
|
||||
{V(uintptr(0x110004)), V(MyString("\uFFFD"))},
|
||||
|
||||
// named []byte
|
||||
{V(string("bytes1")), V(MyBytes("bytes1"))},
|
||||
{V(MyBytes("bytes2")), V(string("bytes2"))},
|
||||
{V(MyBytes("bytes3")), V(MyBytes("bytes3"))},
|
||||
{V(MyString("bytes1")), V(MyBytes("bytes1"))},
|
||||
{V(MyBytes("bytes2")), V(MyString("bytes2"))},
|
||||
|
||||
// named []rune
|
||||
{V(string("runes♝")), V(MyRunes("runes♝"))},
|
||||
{V(MyRunes("runes♕")), V(string("runes♕"))},
|
||||
{V(MyRunes("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
|
||||
{V(MyString("runes♝")), V(MyRunes("runes♝"))},
|
||||
{V(MyRunes("runes♕")), V(MyString("runes♕"))},
|
||||
|
||||
// slice to array
|
||||
{V([]byte(nil)), V([0]byte{})},
|
||||
{V([]byte{}), V([0]byte{})},
|
||||
{V([]byte{1}), V([1]byte{1})},
|
||||
{V([]byte{1, 2}), V([2]byte{1, 2})},
|
||||
{V([]byte{1, 2, 3}), V([3]byte{1, 2, 3})},
|
||||
{V(MyBytes([]byte(nil))), V([0]byte{})},
|
||||
{V(MyBytes{}), V([0]byte{})},
|
||||
{V(MyBytes{1}), V([1]byte{1})},
|
||||
{V(MyBytes{1, 2}), V([2]byte{1, 2})},
|
||||
{V(MyBytes{1, 2, 3}), V([3]byte{1, 2, 3})},
|
||||
{V([]byte(nil)), V(MyBytesArray0{})},
|
||||
{V([]byte{}), V(MyBytesArray0([0]byte{}))},
|
||||
{V([]byte{1, 2, 3, 4}), V(MyBytesArray([4]byte{1, 2, 3, 4}))},
|
||||
{V(MyBytes{}), V(MyBytesArray0([0]byte{}))},
|
||||
{V(MyBytes{5, 6, 7, 8}), V(MyBytesArray([4]byte{5, 6, 7, 8}))},
|
||||
{V([]MyByte{}), V([0]MyByte{})},
|
||||
{V([]MyByte{1, 2}), V([2]MyByte{1, 2})},
|
||||
|
||||
// slice to array pointer
|
||||
{V([]byte(nil)), V((*[0]byte)(nil))},
|
||||
{V([]byte{}), V(new([0]byte))},
|
||||
{V([]byte{7}), V(&[1]byte{7})},
|
||||
{V(MyBytes([]byte(nil))), V((*[0]byte)(nil))},
|
||||
{V(MyBytes([]byte{})), V(new([0]byte))},
|
||||
{V(MyBytes([]byte{9})), V(&[1]byte{9})},
|
||||
{V([]byte(nil)), V(MyBytesArrayPtr0(nil))},
|
||||
{V([]byte{}), V(MyBytesArrayPtr0(new([0]byte)))},
|
||||
{V([]byte{1, 2, 3, 4}), V(MyBytesArrayPtr(&[4]byte{1, 2, 3, 4}))},
|
||||
{V(MyBytes([]byte{})), V(MyBytesArrayPtr0(new([0]byte)))},
|
||||
{V(MyBytes([]byte{5, 6, 7, 8})), V(MyBytesArrayPtr(&[4]byte{5, 6, 7, 8}))},
|
||||
|
||||
{V([]byte(nil)), V((*MyBytesArray0)(nil))},
|
||||
{V([]byte{}), V((*MyBytesArray0)(new([0]byte)))},
|
||||
{V([]byte{1, 2, 3, 4}), V(&MyBytesArray{1, 2, 3, 4})},
|
||||
{V(MyBytes([]byte(nil))), V((*MyBytesArray0)(nil))},
|
||||
{V(MyBytes([]byte{})), V((*MyBytesArray0)(new([0]byte)))},
|
||||
{V(MyBytes([]byte{5, 6, 7, 8})), V(&MyBytesArray{5, 6, 7, 8})},
|
||||
/*
|
||||
{V(new([0]byte)), V(new(MyBytesArray0))},
|
||||
{V(new(MyBytesArray0)), V(new([0]byte))},
|
||||
{V(MyBytesArrayPtr0(nil)), V((*[0]byte)(nil))},
|
||||
{V((*[0]byte)(nil)), V(MyBytesArrayPtr0(nil))},
|
||||
*/
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
got := tt.have.Convert(tt.want.Type())
|
||||
if !DeepEqual(got.Interface(), tt.want.Interface()) {
|
||||
t.Errorf("Failed to Convert() %T(%v) -> %T(%v), got %T(%v)", tt.have.Interface(), tt.have, tt.want.Interface(), tt.want, got.Interface(), got)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -628,7 +628,7 @@ func TestAssignableTo(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestConvert(t *testing.T) {
|
||||
func TestConvertBasic(t *testing.T) {
|
||||
v := ValueOf(int64(3))
|
||||
c := v.Convert(TypeOf(byte(0)))
|
||||
|
||||
|
||||
Reference in New Issue
Block a user