@@ -62,12 +62,12 @@ var errJSONEOF = errors.New("unexpected end of JSON input")
62
62
var unmarshalBytesTests = []unmarshalTest {
63
63
// invalid encoding
64
64
{input : "" , wantErr : errJSONEOF },
65
- {input : "null" , wantErr : errNonString },
66
- {input : "10" , wantErr : errNonString },
67
- {input : `"0"` , wantErr : ErrMissingPrefix },
68
- {input : `"0x0"` , wantErr : ErrOddLength },
69
- {input : `"0xxx"` , wantErr : ErrSyntax },
70
- {input : `"0x01zz01"` , wantErr : ErrSyntax },
65
+ {input : "null" , wantErr : errNonString ( bytesT ) },
66
+ {input : "10" , wantErr : errNonString ( bytesT ) },
67
+ {input : `"0"` , wantErr : wrapTypeError ( ErrMissingPrefix , bytesT ) },
68
+ {input : `"0x0"` , wantErr : wrapTypeError ( ErrOddLength , bytesT ) },
69
+ {input : `"0xxx"` , wantErr : wrapTypeError ( ErrSyntax , bytesT ) },
70
+ {input : `"0x01zz01"` , wantErr : wrapTypeError ( ErrSyntax , bytesT ) },
71
71
72
72
// valid encoding
73
73
{input : `""` , want : referenceBytes ("" )},
@@ -127,16 +127,16 @@ func TestMarshalBytes(t *testing.T) {
127
127
var unmarshalBigTests = []unmarshalTest {
128
128
// invalid encoding
129
129
{input : "" , wantErr : errJSONEOF },
130
- {input : "null" , wantErr : errNonString },
131
- {input : "10" , wantErr : errNonString },
132
- {input : `"0"` , wantErr : ErrMissingPrefix },
133
- {input : `"0x"` , wantErr : ErrEmptyNumber },
134
- {input : `"0x01"` , wantErr : ErrLeadingZero },
135
- {input : `"0xx"` , wantErr : ErrSyntax },
136
- {input : `"0x1zz01"` , wantErr : ErrSyntax },
130
+ {input : "null" , wantErr : errNonString ( bigT ) },
131
+ {input : "10" , wantErr : errNonString ( bigT ) },
132
+ {input : `"0"` , wantErr : wrapTypeError ( ErrMissingPrefix , bigT ) },
133
+ {input : `"0x"` , wantErr : wrapTypeError ( ErrEmptyNumber , bigT ) },
134
+ {input : `"0x01"` , wantErr : wrapTypeError ( ErrLeadingZero , bigT ) },
135
+ {input : `"0xx"` , wantErr : wrapTypeError ( ErrSyntax , bigT ) },
136
+ {input : `"0x1zz01"` , wantErr : wrapTypeError ( ErrSyntax , bigT ) },
137
137
{
138
138
input : `"0x10000000000000000000000000000000000000000000000000000000000000000"` ,
139
- wantErr : ErrBig256Range ,
139
+ wantErr : wrapTypeError ( ErrBig256Range , bigT ) ,
140
140
},
141
141
142
142
// valid encoding
@@ -208,14 +208,14 @@ func TestMarshalBig(t *testing.T) {
208
208
var unmarshalUint64Tests = []unmarshalTest {
209
209
// invalid encoding
210
210
{input : "" , wantErr : errJSONEOF },
211
- {input : "null" , wantErr : errNonString },
212
- {input : "10" , wantErr : errNonString },
213
- {input : `"0"` , wantErr : ErrMissingPrefix },
214
- {input : `"0x"` , wantErr : ErrEmptyNumber },
215
- {input : `"0x01"` , wantErr : ErrLeadingZero },
216
- {input : `"0xfffffffffffffffff"` , wantErr : ErrUint64Range },
217
- {input : `"0xx"` , wantErr : ErrSyntax },
218
- {input : `"0x1zz01"` , wantErr : ErrSyntax },
211
+ {input : "null" , wantErr : errNonString ( uint64T ) },
212
+ {input : "10" , wantErr : errNonString ( uint64T ) },
213
+ {input : `"0"` , wantErr : wrapTypeError ( ErrMissingPrefix , uint64T ) },
214
+ {input : `"0x"` , wantErr : wrapTypeError ( ErrEmptyNumber , uint64T ) },
215
+ {input : `"0x01"` , wantErr : wrapTypeError ( ErrLeadingZero , uint64T ) },
216
+ {input : `"0xfffffffffffffffff"` , wantErr : wrapTypeError ( ErrUint64Range , uint64T ) },
217
+ {input : `"0xx"` , wantErr : wrapTypeError ( ErrSyntax , uint64T ) },
218
+ {input : `"0x1zz01"` , wantErr : wrapTypeError ( ErrSyntax , uint64T ) },
219
219
220
220
// valid encoding
221
221
{input : `""` , want : uint64 (0 )},
@@ -298,15 +298,15 @@ var (
298
298
var unmarshalUintTests = []unmarshalTest {
299
299
// invalid encoding
300
300
{input : "" , wantErr : errJSONEOF },
301
- {input : "null" , wantErr : errNonString },
302
- {input : "10" , wantErr : errNonString },
303
- {input : `"0"` , wantErr : ErrMissingPrefix },
304
- {input : `"0x"` , wantErr : ErrEmptyNumber },
305
- {input : `"0x01"` , wantErr : ErrLeadingZero },
306
- {input : `"0x100000000"` , want : uint (maxUint33bits ), wantErr32bit : ErrUintRange },
307
- {input : `"0xfffffffffffffffff"` , wantErr : ErrUintRange },
308
- {input : `"0xx"` , wantErr : ErrSyntax },
309
- {input : `"0x1zz01"` , wantErr : ErrSyntax },
301
+ {input : "null" , wantErr : errNonString ( uintT ) },
302
+ {input : "10" , wantErr : errNonString ( uintT ) },
303
+ {input : `"0"` , wantErr : wrapTypeError ( ErrMissingPrefix , uintT ) },
304
+ {input : `"0x"` , wantErr : wrapTypeError ( ErrEmptyNumber , uintT ) },
305
+ {input : `"0x01"` , wantErr : wrapTypeError ( ErrLeadingZero , uintT ) },
306
+ {input : `"0x100000000"` , want : uint (maxUint33bits ), wantErr32bit : wrapTypeError ( ErrUintRange , uintT ) },
307
+ {input : `"0xfffffffffffffffff"` , wantErr : wrapTypeError ( ErrUintRange , uintT ) },
308
+ {input : `"0xx"` , wantErr : wrapTypeError ( ErrSyntax , uintT ) },
309
+ {input : `"0x1zz01"` , wantErr : wrapTypeError ( ErrSyntax , uintT ) },
310
310
311
311
// valid encoding
312
312
{input : `""` , want : uint (0 )},
@@ -317,7 +317,7 @@ var unmarshalUintTests = []unmarshalTest{
317
317
{input : `"0x1122aaff"` , want : uint (0x1122aaff )},
318
318
{input : `"0xbbb"` , want : uint (0xbbb )},
319
319
{input : `"0xffffffff"` , want : uint (0xffffffff )},
320
- {input : `"0xffffffffffffffff"` , want : uint (maxUint64bits ), wantErr32bit : ErrUintRange },
320
+ {input : `"0xffffffffffffffff"` , want : uint (maxUint64bits ), wantErr32bit : wrapTypeError ( ErrUintRange , uintT ) },
321
321
}
322
322
323
323
func TestUnmarshalUint (t * testing.T ) {
0 commit comments