github.com/alexdevranger/node-1.8.27@v0.0.0-20221128213301-aa5841e41d2d/accounts/abi/type_test.go (about)

     1  // Copyright 2016 The go-ethereum Authors
     2  // This file is part of the go-dubxcoin library.
     3  //
     4  // The go-dubxcoin library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-dubxcoin library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-dubxcoin library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package abi
    18  
    19  import (
    20  	"math/big"
    21  	"reflect"
    22  	"testing"
    23  
    24  	"github.com/davecgh/go-spew/spew"
    25  	"github.com/alexdevranger/node-1.8.27/common"
    26  )
    27  
    28  // typeWithoutStringer is a alias for the Type type which simply doesn't implement
    29  // the stringer interface to allow printing type details in the tests below.
    30  type typeWithoutStringer Type
    31  
    32  // Tests that all allowed types get recognized by the type parser.
    33  func TestTypeRegexp(t *testing.T) {
    34  	tests := []struct {
    35  		blob       string
    36  		components []ArgumentMarshaling
    37  		kind       Type
    38  	}{
    39  		{"bool", nil, Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}},
    40  		{"bool[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool(nil)), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}},
    41  		{"bool[2]", nil, Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}},
    42  		{"bool[2][]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}},
    43  		{"bool[][]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}},
    44  		{"bool[][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}},
    45  		{"bool[2][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}},
    46  		{"bool[2][][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][][2]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}, stringKind: "bool[2][][2]"}},
    47  		{"bool[2][2][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}, stringKind: "bool[2][2][2]"}},
    48  		{"bool[][][]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}, stringKind: "bool[][][]"}},
    49  		{"bool[][2][]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][2][]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}, stringKind: "bool[][2][]"}},
    50  		{"int8", nil, Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}},
    51  		{"int16", nil, Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}},
    52  		{"int32", nil, Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}},
    53  		{"int64", nil, Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}},
    54  		{"int256", nil, Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}},
    55  		{"int8[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}},
    56  		{"int8[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}},
    57  		{"int16[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}},
    58  		{"int16[2]", nil, Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}},
    59  		{"int32[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}},
    60  		{"int32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}},
    61  		{"int64[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}},
    62  		{"int64[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}},
    63  		{"int256[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}},
    64  		{"int256[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}},
    65  		{"uint8", nil, Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}},
    66  		{"uint16", nil, Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}},
    67  		{"uint32", nil, Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}},
    68  		{"uint64", nil, Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}},
    69  		{"uint256", nil, Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}},
    70  		{"uint8[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}},
    71  		{"uint8[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}},
    72  		{"uint16[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}},
    73  		{"uint16[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}},
    74  		{"uint32[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}},
    75  		{"uint32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}},
    76  		{"uint64[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}},
    77  		{"uint64[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}},
    78  		{"uint256[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}},
    79  		{"uint256[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]*big.Int{}), Size: 2, Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}},
    80  		{"bytes32", nil, Type{Kind: reflect.Array, T: FixedBytesTy, Size: 32, Type: reflect.TypeOf([32]byte{}), stringKind: "bytes32"}},
    81  		{"bytes[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]byte{}), Elem: &Type{Kind: reflect.Slice, Type: reflect.TypeOf([]byte{}), T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}},
    82  		{"bytes[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]byte{}), Elem: &Type{T: BytesTy, Type: reflect.TypeOf([]byte{}), Kind: reflect.Slice, stringKind: "bytes"}, stringKind: "bytes[2]"}},
    83  		{"bytes32[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][32]byte{}), Elem: &Type{Kind: reflect.Array, Type: reflect.TypeOf([32]byte{}), T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[]"}},
    84  		{"bytes32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][32]byte{}), Elem: &Type{Kind: reflect.Array, T: FixedBytesTy, Size: 32, Type: reflect.TypeOf([32]byte{}), stringKind: "bytes32"}, stringKind: "bytes32[2]"}},
    85  		{"string", nil, Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}},
    86  		{"string[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]string{}), Elem: &Type{Kind: reflect.String, Type: reflect.TypeOf(""), T: StringTy, stringKind: "string"}, stringKind: "string[]"}},
    87  		{"string[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]string{}), Elem: &Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}, stringKind: "string[2]"}},
    88  		{"address", nil, Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}},
    89  		{"address[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}},
    90  		{"address[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}},
    91  		// TODO when fixed types are implemented properly
    92  		// {"fixed", nil, Type{}},
    93  		// {"fixed128x128", nil, Type{}},
    94  		// {"fixed[]", nil, Type{}},
    95  		// {"fixed[2]", nil, Type{}},
    96  		// {"fixed128x128[]", nil, Type{}},
    97  		// {"fixed128x128[2]", nil, Type{}},
    98  		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "int64"}}, Type{Kind: reflect.Struct, T: TupleTy, Type: reflect.TypeOf(struct{ A int64 }{}), stringKind: "(int64)",
    99  			TupleElems: []*Type{{Kind: reflect.Int64, T: IntTy, Type: reflect.TypeOf(int64(0)), Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"a"}}},
   100  	}
   101  
   102  	for _, tt := range tests {
   103  		typ, err := NewType(tt.blob, tt.components)
   104  		if err != nil {
   105  			t.Errorf("type %q: failed to parse type string: %v", tt.blob, err)
   106  		}
   107  		if !reflect.DeepEqual(typ, tt.kind) {
   108  			t.Errorf("type %q: parsed type mismatch:\nGOT %s\nWANT %s ", tt.blob, spew.Sdump(typeWithoutStringer(typ)), spew.Sdump(typeWithoutStringer(tt.kind)))
   109  		}
   110  	}
   111  }
   112  
   113  func TestTypeCheck(t *testing.T) {
   114  	for i, test := range []struct {
   115  		typ        string
   116  		components []ArgumentMarshaling
   117  		input      interface{}
   118  		err        string
   119  	}{
   120  		{"uint", nil, big.NewInt(1), "unsupported arg type: uint"},
   121  		{"int", nil, big.NewInt(1), "unsupported arg type: int"},
   122  		{"uint256", nil, big.NewInt(1), ""},
   123  		{"uint256[][3][]", nil, [][3][]*big.Int{{{}}}, ""},
   124  		{"uint256[][][3]", nil, [3][][]*big.Int{{{}}}, ""},
   125  		{"uint256[3][][]", nil, [][][3]*big.Int{{{}}}, ""},
   126  		{"uint256[3][3][3]", nil, [3][3][3]*big.Int{{{}}}, ""},
   127  		{"uint8[][]", nil, [][]uint8{}, ""},
   128  		{"int256", nil, big.NewInt(1), ""},
   129  		{"uint8", nil, uint8(1), ""},
   130  		{"uint16", nil, uint16(1), ""},
   131  		{"uint32", nil, uint32(1), ""},
   132  		{"uint64", nil, uint64(1), ""},
   133  		{"int8", nil, int8(1), ""},
   134  		{"int16", nil, int16(1), ""},
   135  		{"int32", nil, int32(1), ""},
   136  		{"int64", nil, int64(1), ""},
   137  		{"uint24", nil, big.NewInt(1), ""},
   138  		{"uint40", nil, big.NewInt(1), ""},
   139  		{"uint48", nil, big.NewInt(1), ""},
   140  		{"uint56", nil, big.NewInt(1), ""},
   141  		{"uint72", nil, big.NewInt(1), ""},
   142  		{"uint80", nil, big.NewInt(1), ""},
   143  		{"uint88", nil, big.NewInt(1), ""},
   144  		{"uint96", nil, big.NewInt(1), ""},
   145  		{"uint104", nil, big.NewInt(1), ""},
   146  		{"uint112", nil, big.NewInt(1), ""},
   147  		{"uint120", nil, big.NewInt(1), ""},
   148  		{"uint128", nil, big.NewInt(1), ""},
   149  		{"uint136", nil, big.NewInt(1), ""},
   150  		{"uint144", nil, big.NewInt(1), ""},
   151  		{"uint152", nil, big.NewInt(1), ""},
   152  		{"uint160", nil, big.NewInt(1), ""},
   153  		{"uint168", nil, big.NewInt(1), ""},
   154  		{"uint176", nil, big.NewInt(1), ""},
   155  		{"uint184", nil, big.NewInt(1), ""},
   156  		{"uint192", nil, big.NewInt(1), ""},
   157  		{"uint200", nil, big.NewInt(1), ""},
   158  		{"uint208", nil, big.NewInt(1), ""},
   159  		{"uint216", nil, big.NewInt(1), ""},
   160  		{"uint224", nil, big.NewInt(1), ""},
   161  		{"uint232", nil, big.NewInt(1), ""},
   162  		{"uint240", nil, big.NewInt(1), ""},
   163  		{"uint248", nil, big.NewInt(1), ""},
   164  		{"int24", nil, big.NewInt(1), ""},
   165  		{"int40", nil, big.NewInt(1), ""},
   166  		{"int48", nil, big.NewInt(1), ""},
   167  		{"int56", nil, big.NewInt(1), ""},
   168  		{"int72", nil, big.NewInt(1), ""},
   169  		{"int80", nil, big.NewInt(1), ""},
   170  		{"int88", nil, big.NewInt(1), ""},
   171  		{"int96", nil, big.NewInt(1), ""},
   172  		{"int104", nil, big.NewInt(1), ""},
   173  		{"int112", nil, big.NewInt(1), ""},
   174  		{"int120", nil, big.NewInt(1), ""},
   175  		{"int128", nil, big.NewInt(1), ""},
   176  		{"int136", nil, big.NewInt(1), ""},
   177  		{"int144", nil, big.NewInt(1), ""},
   178  		{"int152", nil, big.NewInt(1), ""},
   179  		{"int160", nil, big.NewInt(1), ""},
   180  		{"int168", nil, big.NewInt(1), ""},
   181  		{"int176", nil, big.NewInt(1), ""},
   182  		{"int184", nil, big.NewInt(1), ""},
   183  		{"int192", nil, big.NewInt(1), ""},
   184  		{"int200", nil, big.NewInt(1), ""},
   185  		{"int208", nil, big.NewInt(1), ""},
   186  		{"int216", nil, big.NewInt(1), ""},
   187  		{"int224", nil, big.NewInt(1), ""},
   188  		{"int232", nil, big.NewInt(1), ""},
   189  		{"int240", nil, big.NewInt(1), ""},
   190  		{"int248", nil, big.NewInt(1), ""},
   191  		{"uint30", nil, uint8(1), "abi: cannot use uint8 as type ptr as argument"},
   192  		{"uint8", nil, uint16(1), "abi: cannot use uint16 as type uint8 as argument"},
   193  		{"uint8", nil, uint32(1), "abi: cannot use uint32 as type uint8 as argument"},
   194  		{"uint8", nil, uint64(1), "abi: cannot use uint64 as type uint8 as argument"},
   195  		{"uint8", nil, int8(1), "abi: cannot use int8 as type uint8 as argument"},
   196  		{"uint8", nil, int16(1), "abi: cannot use int16 as type uint8 as argument"},
   197  		{"uint8", nil, int32(1), "abi: cannot use int32 as type uint8 as argument"},
   198  		{"uint8", nil, int64(1), "abi: cannot use int64 as type uint8 as argument"},
   199  		{"uint16", nil, uint16(1), ""},
   200  		{"uint16", nil, uint8(1), "abi: cannot use uint8 as type uint16 as argument"},
   201  		{"uint16[]", nil, []uint16{1, 2, 3}, ""},
   202  		{"uint16[]", nil, [3]uint16{1, 2, 3}, ""},
   203  		{"uint16[]", nil, []uint32{1, 2, 3}, "abi: cannot use []uint32 as type [0]uint16 as argument"},
   204  		{"uint16[3]", nil, [3]uint32{1, 2, 3}, "abi: cannot use [3]uint32 as type [3]uint16 as argument"},
   205  		{"uint16[3]", nil, [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
   206  		{"uint16[3]", nil, []uint16{1, 2, 3}, ""},
   207  		{"uint16[3]", nil, []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
   208  		{"address[]", nil, []common.Address{{1}}, ""},
   209  		{"address[1]", nil, []common.Address{{1}}, ""},
   210  		{"address[1]", nil, [1]common.Address{{1}}, ""},
   211  		{"address[2]", nil, [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
   212  		{"bytes32", nil, [32]byte{}, ""},
   213  		{"bytes31", nil, [31]byte{}, ""},
   214  		{"bytes30", nil, [30]byte{}, ""},
   215  		{"bytes29", nil, [29]byte{}, ""},
   216  		{"bytes28", nil, [28]byte{}, ""},
   217  		{"bytes27", nil, [27]byte{}, ""},
   218  		{"bytes26", nil, [26]byte{}, ""},
   219  		{"bytes25", nil, [25]byte{}, ""},
   220  		{"bytes24", nil, [24]byte{}, ""},
   221  		{"bytes23", nil, [23]byte{}, ""},
   222  		{"bytes22", nil, [22]byte{}, ""},
   223  		{"bytes21", nil, [21]byte{}, ""},
   224  		{"bytes20", nil, [20]byte{}, ""},
   225  		{"bytes19", nil, [19]byte{}, ""},
   226  		{"bytes18", nil, [18]byte{}, ""},
   227  		{"bytes17", nil, [17]byte{}, ""},
   228  		{"bytes16", nil, [16]byte{}, ""},
   229  		{"bytes15", nil, [15]byte{}, ""},
   230  		{"bytes14", nil, [14]byte{}, ""},
   231  		{"bytes13", nil, [13]byte{}, ""},
   232  		{"bytes12", nil, [12]byte{}, ""},
   233  		{"bytes11", nil, [11]byte{}, ""},
   234  		{"bytes10", nil, [10]byte{}, ""},
   235  		{"bytes9", nil, [9]byte{}, ""},
   236  		{"bytes8", nil, [8]byte{}, ""},
   237  		{"bytes7", nil, [7]byte{}, ""},
   238  		{"bytes6", nil, [6]byte{}, ""},
   239  		{"bytes5", nil, [5]byte{}, ""},
   240  		{"bytes4", nil, [4]byte{}, ""},
   241  		{"bytes3", nil, [3]byte{}, ""},
   242  		{"bytes2", nil, [2]byte{}, ""},
   243  		{"bytes1", nil, [1]byte{}, ""},
   244  		{"bytes32", nil, [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
   245  		{"bytes32", nil, common.Hash{1}, ""},
   246  		{"bytes31", nil, common.Hash{1}, "abi: cannot use common.Hash as type [31]uint8 as argument"},
   247  		{"bytes31", nil, [32]byte{}, "abi: cannot use [32]uint8 as type [31]uint8 as argument"},
   248  		{"bytes", nil, []byte{0, 1}, ""},
   249  		{"bytes", nil, [2]byte{0, 1}, "abi: cannot use array as type slice as argument"},
   250  		{"bytes", nil, common.Hash{1}, "abi: cannot use array as type slice as argument"},
   251  		{"string", nil, "hello world", ""},
   252  		{"string", nil, string(""), ""},
   253  		{"string", nil, []byte{}, "abi: cannot use slice as type string as argument"},
   254  		{"bytes32[]", nil, [][32]byte{{}}, ""},
   255  		{"function", nil, [24]byte{}, ""},
   256  		{"bytes20", nil, common.Address{}, ""},
   257  		{"address", nil, [20]byte{}, ""},
   258  		{"address", nil, common.Address{}, ""},
   259  		{"bytes32[]]", nil, "", "invalid arg type in abi"},
   260  		{"invalidType", nil, "", "unsupported arg type: invalidType"},
   261  		{"invalidSlice[]", nil, "", "unsupported arg type: invalidSlice"},
   262  		// simple tuple
   263  		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, struct {
   264  			A *big.Int
   265  			B *big.Int
   266  		}{}, ""},
   267  		// tuple slice
   268  		{"tuple[]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
   269  			A *big.Int
   270  			B *big.Int
   271  		}{}, ""},
   272  		// tuple array
   273  		{"tuple[2]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
   274  			A *big.Int
   275  			B *big.Int
   276  		}{{big.NewInt(0), big.NewInt(0)}, {big.NewInt(0), big.NewInt(0)}}, ""},
   277  	} {
   278  		typ, err := NewType(test.typ, test.components)
   279  		if err != nil && len(test.err) == 0 {
   280  			t.Fatal("unexpected parse error:", err)
   281  		} else if err != nil && len(test.err) != 0 {
   282  			if err.Error() != test.err {
   283  				t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
   284  			}
   285  			continue
   286  		}
   287  
   288  		err = typeCheck(typ, reflect.ValueOf(test.input))
   289  		if err != nil && len(test.err) == 0 {
   290  			t.Errorf("%d failed. Expected no err but got: %v", i, err)
   291  			continue
   292  		}
   293  		if err == nil && len(test.err) != 0 {
   294  			t.Errorf("%d failed. Expected err: %v but got none", i, test.err)
   295  			continue
   296  		}
   297  
   298  		if err != nil && len(test.err) != 0 && err.Error() != test.err {
   299  			t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
   300  		}
   301  	}
   302  }