d304da3803
This commit makes the wrapper types more generally applicable. encoding.TextMarshaler is supported by most codec implementations (e.g. for yaml). The tests now ensure that package json actually recognizes the custom marshaler implementation irrespective of how it is implemented. The Uint type has new tests, too. These are tricky because uint size depends on the CPU word size. Turns out that there was one incorrect case where decoding returned ErrUint64Range instead of ErrUintRange.
340 lines
9.6 KiB
Go
340 lines
9.6 KiB
Go
// Copyright 2016 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package hexutil
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"math/big"
|
|
"testing"
|
|
)
|
|
|
|
func checkError(t *testing.T, input string, got, want error) bool {
|
|
if got == nil {
|
|
if want != nil {
|
|
t.Errorf("input %s: got no error, want %q", input, want)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
if want == nil {
|
|
t.Errorf("input %s: unexpected error %q", input, got)
|
|
} else if got.Error() != want.Error() {
|
|
t.Errorf("input %s: got error %q, want %q", input, got, want)
|
|
}
|
|
return false
|
|
}
|
|
|
|
func referenceBig(s string) *big.Int {
|
|
b, ok := new(big.Int).SetString(s, 16)
|
|
if !ok {
|
|
panic("invalid")
|
|
}
|
|
return b
|
|
}
|
|
|
|
func referenceBytes(s string) []byte {
|
|
b, err := hex.DecodeString(s)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
var errJSONEOF = errors.New("unexpected end of JSON input")
|
|
|
|
var unmarshalBytesTests = []unmarshalTest{
|
|
// invalid encoding
|
|
{input: "", wantErr: errJSONEOF},
|
|
{input: "null", wantErr: errNonString},
|
|
{input: "10", wantErr: errNonString},
|
|
{input: `"0"`, wantErr: ErrMissingPrefix},
|
|
{input: `"0x0"`, wantErr: ErrOddLength},
|
|
{input: `"0xxx"`, wantErr: ErrSyntax},
|
|
{input: `"0x01zz01"`, wantErr: ErrSyntax},
|
|
|
|
// valid encoding
|
|
{input: `""`, want: referenceBytes("")},
|
|
{input: `"0x"`, want: referenceBytes("")},
|
|
{input: `"0x02"`, want: referenceBytes("02")},
|
|
{input: `"0X02"`, want: referenceBytes("02")},
|
|
{input: `"0xffffffffff"`, want: referenceBytes("ffffffffff")},
|
|
{
|
|
input: `"0xffffffffffffffffffffffffffffffffffff"`,
|
|
want: referenceBytes("ffffffffffffffffffffffffffffffffffff"),
|
|
},
|
|
}
|
|
|
|
func TestUnmarshalBytes(t *testing.T) {
|
|
for _, test := range unmarshalBytesTests {
|
|
var v Bytes
|
|
err := json.Unmarshal([]byte(test.input), &v)
|
|
if !checkError(t, test.input, err, test.wantErr) {
|
|
continue
|
|
}
|
|
if !bytes.Equal(test.want.([]byte), []byte(v)) {
|
|
t.Errorf("input %s: value mismatch: got %x, want %x", test.input, &v, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnmarshalBytes(b *testing.B) {
|
|
input := []byte(`"0x123456789abcdef123456789abcdef"`)
|
|
for i := 0; i < b.N; i++ {
|
|
var v Bytes
|
|
if err := v.UnmarshalJSON(input); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMarshalBytes(t *testing.T) {
|
|
for _, test := range encodeBytesTests {
|
|
in := test.input.([]byte)
|
|
out, err := json.Marshal(Bytes(in))
|
|
if err != nil {
|
|
t.Errorf("%x: %v", in, err)
|
|
continue
|
|
}
|
|
if want := `"` + test.want + `"`; string(out) != want {
|
|
t.Errorf("%x: MarshalJSON output mismatch: got %q, want %q", in, out, want)
|
|
continue
|
|
}
|
|
if out := Bytes(in).String(); out != test.want {
|
|
t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
var unmarshalBigTests = []unmarshalTest{
|
|
// invalid encoding
|
|
{input: "", wantErr: errJSONEOF},
|
|
{input: "null", wantErr: errNonString},
|
|
{input: "10", wantErr: errNonString},
|
|
{input: `"0"`, wantErr: ErrMissingPrefix},
|
|
{input: `"0x"`, wantErr: ErrEmptyNumber},
|
|
{input: `"0x01"`, wantErr: ErrLeadingZero},
|
|
{input: `"0xx"`, wantErr: ErrSyntax},
|
|
{input: `"0x1zz01"`, wantErr: ErrSyntax},
|
|
{
|
|
input: `"0x10000000000000000000000000000000000000000000000000000000000000000"`,
|
|
wantErr: ErrBig256Range,
|
|
},
|
|
|
|
// valid encoding
|
|
{input: `""`, want: big.NewInt(0)},
|
|
{input: `"0x0"`, want: big.NewInt(0)},
|
|
{input: `"0x2"`, want: big.NewInt(0x2)},
|
|
{input: `"0x2F2"`, want: big.NewInt(0x2f2)},
|
|
{input: `"0X2F2"`, want: big.NewInt(0x2f2)},
|
|
{input: `"0x1122aaff"`, want: big.NewInt(0x1122aaff)},
|
|
{input: `"0xbBb"`, want: big.NewInt(0xbbb)},
|
|
{input: `"0xfffffffff"`, want: big.NewInt(0xfffffffff)},
|
|
{
|
|
input: `"0x112233445566778899aabbccddeeff"`,
|
|
want: referenceBig("112233445566778899aabbccddeeff"),
|
|
},
|
|
{
|
|
input: `"0xffffffffffffffffffffffffffffffffffff"`,
|
|
want: referenceBig("ffffffffffffffffffffffffffffffffffff"),
|
|
},
|
|
{
|
|
input: `"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"`,
|
|
want: referenceBig("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
|
},
|
|
}
|
|
|
|
func TestUnmarshalBig(t *testing.T) {
|
|
for _, test := range unmarshalBigTests {
|
|
var v Big
|
|
err := json.Unmarshal([]byte(test.input), &v)
|
|
if !checkError(t, test.input, err, test.wantErr) {
|
|
continue
|
|
}
|
|
if test.want != nil && test.want.(*big.Int).Cmp((*big.Int)(&v)) != 0 {
|
|
t.Errorf("input %s: value mismatch: got %x, want %x", test.input, (*big.Int)(&v), test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnmarshalBig(b *testing.B) {
|
|
input := []byte(`"0x123456789abcdef123456789abcdef"`)
|
|
for i := 0; i < b.N; i++ {
|
|
var v Big
|
|
if err := v.UnmarshalJSON(input); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMarshalBig(t *testing.T) {
|
|
for _, test := range encodeBigTests {
|
|
in := test.input.(*big.Int)
|
|
out, err := json.Marshal((*Big)(in))
|
|
if err != nil {
|
|
t.Errorf("%d: %v", in, err)
|
|
continue
|
|
}
|
|
if want := `"` + test.want + `"`; string(out) != want {
|
|
t.Errorf("%d: MarshalJSON output mismatch: got %q, want %q", in, out, want)
|
|
continue
|
|
}
|
|
if out := (*Big)(in).String(); out != test.want {
|
|
t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
var unmarshalUint64Tests = []unmarshalTest{
|
|
// invalid encoding
|
|
{input: "", wantErr: errJSONEOF},
|
|
{input: "null", wantErr: errNonString},
|
|
{input: "10", wantErr: errNonString},
|
|
{input: `"0"`, wantErr: ErrMissingPrefix},
|
|
{input: `"0x"`, wantErr: ErrEmptyNumber},
|
|
{input: `"0x01"`, wantErr: ErrLeadingZero},
|
|
{input: `"0xfffffffffffffffff"`, wantErr: ErrUint64Range},
|
|
{input: `"0xx"`, wantErr: ErrSyntax},
|
|
{input: `"0x1zz01"`, wantErr: ErrSyntax},
|
|
|
|
// valid encoding
|
|
{input: `""`, want: uint64(0)},
|
|
{input: `"0x0"`, want: uint64(0)},
|
|
{input: `"0x2"`, want: uint64(0x2)},
|
|
{input: `"0x2F2"`, want: uint64(0x2f2)},
|
|
{input: `"0X2F2"`, want: uint64(0x2f2)},
|
|
{input: `"0x1122aaff"`, want: uint64(0x1122aaff)},
|
|
{input: `"0xbbb"`, want: uint64(0xbbb)},
|
|
{input: `"0xffffffffffffffff"`, want: uint64(0xffffffffffffffff)},
|
|
}
|
|
|
|
func TestUnmarshalUint64(t *testing.T) {
|
|
for _, test := range unmarshalUint64Tests {
|
|
var v Uint64
|
|
err := json.Unmarshal([]byte(test.input), &v)
|
|
if !checkError(t, test.input, err, test.wantErr) {
|
|
continue
|
|
}
|
|
if uint64(v) != test.want.(uint64) {
|
|
t.Errorf("input %s: value mismatch: got %d, want %d", test.input, v, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnmarshalUint64(b *testing.B) {
|
|
input := []byte(`"0x123456789abcdf"`)
|
|
for i := 0; i < b.N; i++ {
|
|
var v Uint64
|
|
v.UnmarshalJSON(input)
|
|
}
|
|
}
|
|
|
|
func TestMarshalUint64(t *testing.T) {
|
|
for _, test := range encodeUint64Tests {
|
|
in := test.input.(uint64)
|
|
out, err := json.Marshal(Uint64(in))
|
|
if err != nil {
|
|
t.Errorf("%d: %v", in, err)
|
|
continue
|
|
}
|
|
if want := `"` + test.want + `"`; string(out) != want {
|
|
t.Errorf("%d: MarshalJSON output mismatch: got %q, want %q", in, out, want)
|
|
continue
|
|
}
|
|
if out := (Uint64)(in).String(); out != test.want {
|
|
t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMarshalUint(t *testing.T) {
|
|
for _, test := range encodeUintTests {
|
|
in := test.input.(uint)
|
|
out, err := json.Marshal(Uint(in))
|
|
if err != nil {
|
|
t.Errorf("%d: %v", in, err)
|
|
continue
|
|
}
|
|
if want := `"` + test.want + `"`; string(out) != want {
|
|
t.Errorf("%d: MarshalJSON output mismatch: got %q, want %q", in, out, want)
|
|
continue
|
|
}
|
|
if out := (Uint)(in).String(); out != test.want {
|
|
t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
var (
|
|
// These are variables (not constants) to avoid constant overflow
|
|
// checks in the compiler on 32bit platforms.
|
|
maxUint33bits = uint64(^uint32(0)) + 1
|
|
maxUint64bits = ^uint64(0)
|
|
)
|
|
|
|
var unmarshalUintTests = []unmarshalTest{
|
|
// invalid encoding
|
|
{input: "", wantErr: errJSONEOF},
|
|
{input: "null", wantErr: errNonString},
|
|
{input: "10", wantErr: errNonString},
|
|
{input: `"0"`, wantErr: ErrMissingPrefix},
|
|
{input: `"0x"`, wantErr: ErrEmptyNumber},
|
|
{input: `"0x01"`, wantErr: ErrLeadingZero},
|
|
{input: `"0x100000000"`, want: uint(maxUint33bits), wantErr32bit: ErrUintRange},
|
|
{input: `"0xfffffffffffffffff"`, wantErr: ErrUintRange},
|
|
{input: `"0xx"`, wantErr: ErrSyntax},
|
|
{input: `"0x1zz01"`, wantErr: ErrSyntax},
|
|
|
|
// valid encoding
|
|
{input: `""`, want: uint(0)},
|
|
{input: `"0x0"`, want: uint(0)},
|
|
{input: `"0x2"`, want: uint(0x2)},
|
|
{input: `"0x2F2"`, want: uint(0x2f2)},
|
|
{input: `"0X2F2"`, want: uint(0x2f2)},
|
|
{input: `"0x1122aaff"`, want: uint(0x1122aaff)},
|
|
{input: `"0xbbb"`, want: uint(0xbbb)},
|
|
{input: `"0xffffffff"`, want: uint(0xffffffff)},
|
|
{input: `"0xffffffffffffffff"`, want: uint(maxUint64bits), wantErr32bit: ErrUintRange},
|
|
}
|
|
|
|
func TestUnmarshalUint(t *testing.T) {
|
|
for _, test := range unmarshalUintTests {
|
|
var v Uint
|
|
err := json.Unmarshal([]byte(test.input), &v)
|
|
if uintBits == 32 && test.wantErr32bit != nil {
|
|
checkError(t, test.input, err, test.wantErr32bit)
|
|
continue
|
|
}
|
|
if !checkError(t, test.input, err, test.wantErr) {
|
|
continue
|
|
}
|
|
if uint(v) != test.want.(uint) {
|
|
t.Errorf("input %s: value mismatch: got %d, want %d", test.input, v, test.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|