Commit 6ab9f0a1 authored by Ricardo Domingos's avatar Ricardo Domingos Committed by Felix Lange

accounts/abi: improve test coverage (#16044)

parent 7aad81f8
...@@ -25,23 +25,23 @@ import ( ...@@ -25,23 +25,23 @@ import (
) )
var ( var (
big_t = reflect.TypeOf(&big.Int{}) bigT = reflect.TypeOf(&big.Int{})
derefbig_t = reflect.TypeOf(big.Int{}) derefbigT = reflect.TypeOf(big.Int{})
uint8_t = reflect.TypeOf(uint8(0)) uint8T = reflect.TypeOf(uint8(0))
uint16_t = reflect.TypeOf(uint16(0)) uint16T = reflect.TypeOf(uint16(0))
uint32_t = reflect.TypeOf(uint32(0)) uint32T = reflect.TypeOf(uint32(0))
uint64_t = reflect.TypeOf(uint64(0)) uint64T = reflect.TypeOf(uint64(0))
int_t = reflect.TypeOf(int(0)) intT = reflect.TypeOf(int(0))
int8_t = reflect.TypeOf(int8(0)) int8T = reflect.TypeOf(int8(0))
int16_t = reflect.TypeOf(int16(0)) int16T = reflect.TypeOf(int16(0))
int32_t = reflect.TypeOf(int32(0)) int32T = reflect.TypeOf(int32(0))
int64_t = reflect.TypeOf(int64(0)) int64T = reflect.TypeOf(int64(0))
address_t = reflect.TypeOf(common.Address{}) addressT = reflect.TypeOf(common.Address{})
int_ts = reflect.TypeOf([]int(nil)) intTS = reflect.TypeOf([]int(nil))
int8_ts = reflect.TypeOf([]int8(nil)) int8TS = reflect.TypeOf([]int8(nil))
int16_ts = reflect.TypeOf([]int16(nil)) int16TS = reflect.TypeOf([]int16(nil))
int32_ts = reflect.TypeOf([]int32(nil)) int32TS = reflect.TypeOf([]int32(nil))
int64_ts = reflect.TypeOf([]int64(nil)) int64TS = reflect.TypeOf([]int64(nil))
) )
// U256 converts a big Int into a 256bit EVM number. // U256 converts a big Int into a 256bit EVM number.
...@@ -52,7 +52,7 @@ func U256(n *big.Int) []byte { ...@@ -52,7 +52,7 @@ func U256(n *big.Int) []byte {
// checks whether the given reflect value is signed. This also works for slices with a number type // checks whether the given reflect value is signed. This also works for slices with a number type
func isSigned(v reflect.Value) bool { func isSigned(v reflect.Value) bool {
switch v.Type() { switch v.Type() {
case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t: case intTS, int8TS, int16TS, int32TS, int64TS, intT, int8T, int16T, int32T, int64T:
return true return true
} }
return false return false
......
...@@ -24,7 +24,7 @@ import ( ...@@ -24,7 +24,7 @@ import (
// indirect recursively dereferences the value until it either gets the value // indirect recursively dereferences the value until it either gets the value
// or finds a big.Int // or finds a big.Int
func indirect(v reflect.Value) reflect.Value { func indirect(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbig_t { if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbigT {
return indirect(v.Elem()) return indirect(v.Elem())
} }
return v return v
...@@ -36,26 +36,26 @@ func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) ...@@ -36,26 +36,26 @@ func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type)
switch size { switch size {
case 8: case 8:
if unsigned { if unsigned {
return reflect.Uint8, uint8_t return reflect.Uint8, uint8T
} }
return reflect.Int8, int8_t return reflect.Int8, int8T
case 16: case 16:
if unsigned { if unsigned {
return reflect.Uint16, uint16_t return reflect.Uint16, uint16T
} }
return reflect.Int16, int16_t return reflect.Int16, int16T
case 32: case 32:
if unsigned { if unsigned {
return reflect.Uint32, uint32_t return reflect.Uint32, uint32T
} }
return reflect.Int32, int32_t return reflect.Int32, int32T
case 64: case 64:
if unsigned { if unsigned {
return reflect.Uint64, uint64_t return reflect.Uint64, uint64T
} }
return reflect.Int64, int64_t return reflect.Int64, int64T
} }
return reflect.Ptr, big_t return reflect.Ptr, bigT
} }
// mustArrayToBytesSlice creates a new byte slice with the exact same size as value // mustArrayToBytesSlice creates a new byte slice with the exact same size as value
......
...@@ -135,7 +135,7 @@ func NewType(t string) (typ Type, err error) { ...@@ -135,7 +135,7 @@ func NewType(t string) (typ Type, err error) {
typ.Type = reflect.TypeOf(bool(false)) typ.Type = reflect.TypeOf(bool(false))
case "address": case "address":
typ.Kind = reflect.Array typ.Kind = reflect.Array
typ.Type = address_t typ.Type = addressT
typ.Size = 20 typ.Size = 20
typ.T = AddressTy typ.T = AddressTy
case "string": case "string":
......
This diff is collapsed.
...@@ -56,6 +56,23 @@ var unpackTests = []unpackTest{ ...@@ -56,6 +56,23 @@ var unpackTests = []unpackTest{
enc: "0000000000000000000000000000000000000000000000000000000000000001", enc: "0000000000000000000000000000000000000000000000000000000000000001",
want: true, want: true,
}, },
{
def: `[{ "type": "bool" }]`,
enc: "0000000000000000000000000000000000000000000000000000000000000000",
want: false,
},
{
def: `[{ "type": "bool" }]`,
enc: "0000000000000000000000000000000000000000000000000001000000000001",
want: false,
err: "abi: improperly encoded boolean value",
},
{
def: `[{ "type": "bool" }]`,
enc: "0000000000000000000000000000000000000000000000000000000000000003",
want: false,
err: "abi: improperly encoded boolean value",
},
{ {
def: `[{"type": "uint32"}]`, def: `[{"type": "uint32"}]`,
enc: "0000000000000000000000000000000000000000000000000000000000000001", enc: "0000000000000000000000000000000000000000000000000000000000000001",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment