mirror of https://github.com/status-im/op-geth.git
528 lines
15 KiB
Go
528 lines
15 KiB
Go
package rlp
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/ethutil"
|
|
)
|
|
|
|
func TestStreamKind(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
wantKind Kind
|
|
wantLen uint64
|
|
}{
|
|
{"00", Byte, 0},
|
|
{"01", Byte, 0},
|
|
{"7F", Byte, 0},
|
|
{"80", String, 0},
|
|
{"B7", String, 55},
|
|
{"B800", String, 0},
|
|
{"B90400", String, 1024},
|
|
{"BA000400", String, 1024},
|
|
{"BB00000400", String, 1024},
|
|
{"BFFFFFFFFFFFFFFFFF", String, ^uint64(0)},
|
|
{"C0", List, 0},
|
|
{"C8", List, 8},
|
|
{"F7", List, 55},
|
|
{"F800", List, 0},
|
|
{"F804", List, 4},
|
|
{"F90400", List, 1024},
|
|
{"FFFFFFFFFFFFFFFFFF", List, ^uint64(0)},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
s := NewStream(bytes.NewReader(unhex(test.input)))
|
|
kind, len, err := s.Kind()
|
|
if err != nil {
|
|
t.Errorf("test %d: Type returned error: %v", i, err)
|
|
continue
|
|
}
|
|
if kind != test.wantKind {
|
|
t.Errorf("test %d: kind mismatch: got %d, want %d", i, kind, test.wantKind)
|
|
}
|
|
if len != test.wantLen {
|
|
t.Errorf("test %d: len mismatch: got %d, want %d", i, len, test.wantLen)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNewListStream(t *testing.T) {
|
|
ls := NewListStream(bytes.NewReader(unhex("0101010101")), 3)
|
|
if k, size, err := ls.Kind(); k != List || size != 3 || err != nil {
|
|
t.Errorf("Kind() returned (%v, %d, %v), expected (List, 3, nil)", k, size, err)
|
|
}
|
|
if size, err := ls.List(); size != 3 || err != nil {
|
|
t.Errorf("List() returned (%d, %v), expected (3, nil)", size, err)
|
|
}
|
|
for i := 0; i < 3; i++ {
|
|
if val, err := ls.Uint(); val != 1 || err != nil {
|
|
t.Errorf("Uint() returned (%d, %v), expected (1, nil)", val, err)
|
|
}
|
|
}
|
|
if err := ls.ListEnd(); err != nil {
|
|
t.Errorf("ListEnd() returned %v, expected (3, nil)", err)
|
|
}
|
|
}
|
|
|
|
func TestStreamErrors(t *testing.T) {
|
|
type calls []string
|
|
tests := []struct {
|
|
string
|
|
calls
|
|
error
|
|
}{
|
|
{"", calls{"Kind"}, io.EOF},
|
|
{"", calls{"List"}, io.EOF},
|
|
{"", calls{"Uint"}, io.EOF},
|
|
{"C0", calls{"Bytes"}, ErrExpectedString},
|
|
{"C0", calls{"Uint"}, ErrExpectedString},
|
|
{"81", calls{"Bytes"}, io.ErrUnexpectedEOF},
|
|
{"81", calls{"Uint"}, io.ErrUnexpectedEOF},
|
|
{"BFFFFFFFFFFFFFFF", calls{"Bytes"}, io.ErrUnexpectedEOF},
|
|
{"89000000000000000001", calls{"Uint"}, errUintOverflow},
|
|
{"00", calls{"List"}, ErrExpectedList},
|
|
{"80", calls{"List"}, ErrExpectedList},
|
|
{"C0", calls{"List", "Uint"}, EOL},
|
|
{"C801", calls{"List", "Uint", "Uint"}, io.ErrUnexpectedEOF},
|
|
{"C8C9", calls{"List", "Kind"}, ErrElemTooLarge},
|
|
{"C3C2010201", calls{"List", "List", "Uint", "Uint", "ListEnd", "Uint"}, EOL},
|
|
{"00", calls{"ListEnd"}, errNotInList},
|
|
{"C40102", calls{"List", "Uint", "ListEnd"}, errNotAtEOL},
|
|
}
|
|
|
|
testfor:
|
|
for i, test := range tests {
|
|
s := NewStream(bytes.NewReader(unhex(test.string)))
|
|
rs := reflect.ValueOf(s)
|
|
for j, call := range test.calls {
|
|
fval := rs.MethodByName(call)
|
|
ret := fval.Call(nil)
|
|
err := "<nil>"
|
|
if lastret := ret[len(ret)-1].Interface(); lastret != nil {
|
|
err = lastret.(error).Error()
|
|
}
|
|
if j == len(test.calls)-1 {
|
|
if err != test.error.Error() {
|
|
t.Errorf("test %d: last call (%s) error mismatch\ngot: %s\nwant: %v",
|
|
i, call, err, test.error)
|
|
}
|
|
} else if err != "<nil>" {
|
|
t.Errorf("test %d: call %d (%s) unexpected error: %q", i, j, call, err)
|
|
continue testfor
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStreamList(t *testing.T) {
|
|
s := NewStream(bytes.NewReader(unhex("C80102030405060708")))
|
|
|
|
len, err := s.List()
|
|
if err != nil {
|
|
t.Fatalf("List error: %v", err)
|
|
}
|
|
if len != 8 {
|
|
t.Fatalf("List returned invalid length, got %d, want 8", len)
|
|
}
|
|
|
|
for i := uint64(1); i <= 8; i++ {
|
|
v, err := s.Uint()
|
|
if err != nil {
|
|
t.Fatalf("Uint error: %v", err)
|
|
}
|
|
if i != v {
|
|
t.Errorf("Uint returned wrong value, got %d, want %d", v, i)
|
|
}
|
|
}
|
|
|
|
if _, err := s.Uint(); err != EOL {
|
|
t.Errorf("Uint error mismatch, got %v, want %v", err, EOL)
|
|
}
|
|
if err = s.ListEnd(); err != nil {
|
|
t.Fatalf("ListEnd error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDecodeErrors(t *testing.T) {
|
|
r := bytes.NewReader(nil)
|
|
|
|
if err := Decode(r, nil); err != errDecodeIntoNil {
|
|
t.Errorf("Decode(r, nil) error mismatch, got %q, want %q", err, errDecodeIntoNil)
|
|
}
|
|
|
|
var nilptr *struct{}
|
|
if err := Decode(r, nilptr); err != errDecodeIntoNil {
|
|
t.Errorf("Decode(r, nilptr) error mismatch, got %q, want %q", err, errDecodeIntoNil)
|
|
}
|
|
|
|
if err := Decode(r, struct{}{}); err != errNoPointer {
|
|
t.Errorf("Decode(r, struct{}{}) error mismatch, got %q, want %q", err, errNoPointer)
|
|
}
|
|
|
|
expectErr := "rlp: type chan bool is not RLP-serializable"
|
|
if err := Decode(r, new(chan bool)); err == nil || err.Error() != expectErr {
|
|
t.Errorf("Decode(r, new(chan bool)) error mismatch, got %q, want %q", err, expectErr)
|
|
}
|
|
|
|
if err := Decode(r, new(int)); err != io.EOF {
|
|
t.Errorf("Decode(r, new(int)) error mismatch, got %q, want %q", err, io.EOF)
|
|
}
|
|
}
|
|
|
|
type decodeTest struct {
|
|
input string
|
|
ptr interface{}
|
|
value interface{}
|
|
error string
|
|
}
|
|
|
|
type simplestruct struct {
|
|
A int
|
|
B string
|
|
}
|
|
|
|
type recstruct struct {
|
|
I int
|
|
Child *recstruct
|
|
}
|
|
|
|
var (
|
|
veryBigInt = big.NewInt(0).Add(
|
|
big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16),
|
|
big.NewInt(0xFFFF),
|
|
)
|
|
)
|
|
|
|
var (
|
|
sharedByteArray [5]byte
|
|
sharedPtr = new(*int)
|
|
)
|
|
|
|
var decodeTests = []decodeTest{
|
|
// integers
|
|
{input: "05", ptr: new(uint32), value: uint32(5)},
|
|
{input: "80", ptr: new(uint32), value: uint32(0)},
|
|
{input: "8105", ptr: new(uint32), value: uint32(5)},
|
|
{input: "820505", ptr: new(uint32), value: uint32(0x0505)},
|
|
{input: "83050505", ptr: new(uint32), value: uint32(0x050505)},
|
|
{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)},
|
|
{input: "850505050505", ptr: new(uint32), error: "rlp: input string too big for uint32"},
|
|
{input: "C0", ptr: new(uint32), error: ErrExpectedString.Error()},
|
|
|
|
// slices
|
|
{input: "C0", ptr: new([]int), value: []int{}},
|
|
{input: "C80102030405060708", ptr: new([]int), value: []int{1, 2, 3, 4, 5, 6, 7, 8}},
|
|
|
|
// arrays
|
|
{input: "C0", ptr: new([5]int), value: [5]int{}},
|
|
{input: "C50102030405", ptr: new([5]int), value: [5]int{1, 2, 3, 4, 5}},
|
|
{input: "C6010203040506", ptr: new([5]int), error: "rlp: input list has too many elements for [5]int"},
|
|
|
|
// byte slices
|
|
{input: "01", ptr: new([]byte), value: []byte{1}},
|
|
{input: "80", ptr: new([]byte), value: []byte{}},
|
|
{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
|
|
{input: "C0", ptr: new([]byte), value: []byte{}},
|
|
{input: "C3010203", ptr: new([]byte), value: []byte{1, 2, 3}},
|
|
{input: "C3820102", ptr: new([]byte), error: "rlp: input string too big for uint8"},
|
|
|
|
// byte arrays
|
|
{input: "01", ptr: new([5]byte), value: [5]byte{1}},
|
|
{input: "80", ptr: new([5]byte), value: [5]byte{}},
|
|
{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
|
|
{input: "C0", ptr: new([5]byte), value: [5]byte{}},
|
|
{input: "C3010203", ptr: new([5]byte), value: [5]byte{1, 2, 3, 0, 0}},
|
|
{input: "C3820102", ptr: new([5]byte), error: "rlp: input string too big for uint8"},
|
|
{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too big for [5]uint8"},
|
|
{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF.Error()},
|
|
|
|
// byte array reuse (should be zeroed)
|
|
{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
|
|
{input: "8101", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: String
|
|
{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
|
|
{input: "01", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: Byte
|
|
{input: "C3010203", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 0, 0}},
|
|
{input: "C101", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: List
|
|
|
|
// zero sized byte arrays
|
|
{input: "80", ptr: new([0]byte), value: [0]byte{}},
|
|
{input: "C0", ptr: new([0]byte), value: [0]byte{}},
|
|
{input: "01", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
|
|
{input: "8101", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
|
|
|
|
// strings
|
|
{input: "00", ptr: new(string), value: "\000"},
|
|
{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"},
|
|
{input: "C0", ptr: new(string), error: ErrExpectedString.Error()},
|
|
|
|
// big ints
|
|
{input: "01", ptr: new(*big.Int), value: big.NewInt(1)},
|
|
{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt},
|
|
{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
|
|
{input: "C0", ptr: new(*big.Int), error: ErrExpectedString.Error()},
|
|
|
|
// structs
|
|
{input: "C0", ptr: new(simplestruct), value: simplestruct{0, ""}},
|
|
{input: "C105", ptr: new(simplestruct), value: simplestruct{5, ""}},
|
|
{input: "C50583343434", ptr: new(simplestruct), value: simplestruct{5, "444"}},
|
|
{input: "C3010101", ptr: new(simplestruct), error: "rlp: input list has too many elements for rlp.simplestruct"},
|
|
{
|
|
input: "C501C302C103",
|
|
ptr: new(recstruct),
|
|
value: recstruct{1, &recstruct{2, &recstruct{3, nil}}},
|
|
},
|
|
|
|
// pointers
|
|
{input: "00", ptr: new(*int), value: (*int)(nil)},
|
|
{input: "80", ptr: new(*int), value: (*int)(nil)},
|
|
{input: "C0", ptr: new(*int), value: (*int)(nil)},
|
|
{input: "07", ptr: new(*int), value: intp(7)},
|
|
{input: "8108", ptr: new(*int), value: intp(8)},
|
|
{input: "C109", ptr: new(*[]int), value: &[]int{9}},
|
|
{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}},
|
|
|
|
// pointer should be reset to nil
|
|
{input: "05", ptr: sharedPtr, value: intp(5)},
|
|
{input: "80", ptr: sharedPtr, value: (*int)(nil)},
|
|
|
|
// interface{}
|
|
{input: "00", ptr: new(interface{}), value: []byte{0}},
|
|
{input: "01", ptr: new(interface{}), value: []byte{1}},
|
|
{input: "80", ptr: new(interface{}), value: []byte{}},
|
|
{input: "850505050505", ptr: new(interface{}), value: []byte{5, 5, 5, 5, 5}},
|
|
{input: "C0", ptr: new(interface{}), value: []interface{}{}},
|
|
{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}},
|
|
}
|
|
|
|
func intp(i int) *int { return &i }
|
|
|
|
func runTests(t *testing.T, decode func([]byte, interface{}) error) {
|
|
for i, test := range decodeTests {
|
|
input, err := hex.DecodeString(test.input)
|
|
if err != nil {
|
|
t.Errorf("test %d: invalid hex input %q", i, test.input)
|
|
continue
|
|
}
|
|
err = decode(input, test.ptr)
|
|
if err != nil && test.error == "" {
|
|
t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q",
|
|
i, err, test.ptr, test.input)
|
|
continue
|
|
}
|
|
if test.error != "" && fmt.Sprint(err) != test.error {
|
|
t.Errorf("test %d: Decode error mismatch\ngot %v\nwant %v\ndecoding into %T\ninput %q",
|
|
i, err, test.error, test.ptr, test.input)
|
|
continue
|
|
}
|
|
deref := reflect.ValueOf(test.ptr).Elem().Interface()
|
|
if err == nil && !reflect.DeepEqual(deref, test.value) {
|
|
t.Errorf("test %d: value mismatch\ngot %#v\nwant %#v\ndecoding into %T\ninput %q",
|
|
i, deref, test.value, test.ptr, test.input)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDecodeWithByteReader(t *testing.T) {
|
|
runTests(t, func(input []byte, into interface{}) error {
|
|
return Decode(bytes.NewReader(input), into)
|
|
})
|
|
}
|
|
|
|
// dumbReader reads from a byte slice but does not
|
|
// implement ReadByte.
|
|
type dumbReader []byte
|
|
|
|
func (r *dumbReader) Read(buf []byte) (n int, err error) {
|
|
if len(*r) == 0 {
|
|
return 0, io.EOF
|
|
}
|
|
n = copy(buf, *r)
|
|
*r = (*r)[n:]
|
|
return n, nil
|
|
}
|
|
|
|
func TestDecodeWithNonByteReader(t *testing.T) {
|
|
runTests(t, func(input []byte, into interface{}) error {
|
|
r := dumbReader(input)
|
|
return Decode(&r, into)
|
|
})
|
|
}
|
|
|
|
func TestDecodeStreamReset(t *testing.T) {
|
|
s := NewStream(nil)
|
|
runTests(t, func(input []byte, into interface{}) error {
|
|
s.Reset(bytes.NewReader(input))
|
|
return s.Decode(into)
|
|
})
|
|
}
|
|
|
|
type testDecoder struct{ called bool }
|
|
|
|
func (t *testDecoder) DecodeRLP(s *Stream) error {
|
|
if _, err := s.Uint(); err != nil {
|
|
return err
|
|
}
|
|
t.called = true
|
|
return nil
|
|
}
|
|
|
|
func TestDecodeDecoder(t *testing.T) {
|
|
var s struct {
|
|
T1 testDecoder
|
|
T2 *testDecoder
|
|
T3 **testDecoder
|
|
}
|
|
if err := Decode(bytes.NewReader(unhex("C3010203")), &s); err != nil {
|
|
t.Fatalf("Decode error: %v", err)
|
|
}
|
|
|
|
if !s.T1.called {
|
|
t.Errorf("DecodeRLP was not called for (non-pointer) testDecoder")
|
|
}
|
|
|
|
if s.T2 == nil {
|
|
t.Errorf("*testDecoder has not been allocated")
|
|
} else if !s.T2.called {
|
|
t.Errorf("DecodeRLP was not called for *testDecoder")
|
|
}
|
|
|
|
if s.T3 == nil || *s.T3 == nil {
|
|
t.Errorf("**testDecoder has not been allocated")
|
|
} else if !(*s.T3).called {
|
|
t.Errorf("DecodeRLP was not called for **testDecoder")
|
|
}
|
|
}
|
|
|
|
type byteDecoder byte
|
|
|
|
func (bd *byteDecoder) DecodeRLP(s *Stream) error {
|
|
_, err := s.Uint()
|
|
*bd = 255
|
|
return err
|
|
}
|
|
|
|
func (bd byteDecoder) called() bool {
|
|
return bd == 255
|
|
}
|
|
|
|
// This test verifies that the byte slice/byte array logic
|
|
// does not kick in for element types implementing Decoder.
|
|
func TestDecoderInByteSlice(t *testing.T) {
|
|
var slice []byteDecoder
|
|
if err := Decode(bytes.NewReader(unhex("C101")), &slice); err != nil {
|
|
t.Errorf("unexpected Decode error %v", err)
|
|
} else if !slice[0].called() {
|
|
t.Errorf("DecodeRLP not called for slice element")
|
|
}
|
|
|
|
var array [1]byteDecoder
|
|
if err := Decode(bytes.NewReader(unhex("C101")), &array); err != nil {
|
|
t.Errorf("unexpected Decode error %v", err)
|
|
} else if !array[0].called() {
|
|
t.Errorf("DecodeRLP not called for array element")
|
|
}
|
|
}
|
|
|
|
func ExampleDecode() {
|
|
input, _ := hex.DecodeString("C90A1486666F6F626172")
|
|
|
|
type example struct {
|
|
A, B int
|
|
private int // private fields are ignored
|
|
String string
|
|
}
|
|
|
|
var s example
|
|
err := Decode(bytes.NewReader(input), &s)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
} else {
|
|
fmt.Printf("Decoded value: %#v\n", s)
|
|
}
|
|
// Output:
|
|
// Decoded value: rlp.example{A:10, B:20, private:0, String:"foobar"}
|
|
}
|
|
|
|
func ExampleStream() {
|
|
input, _ := hex.DecodeString("C90A1486666F6F626172")
|
|
s := NewStream(bytes.NewReader(input))
|
|
|
|
// Check what kind of value lies ahead
|
|
kind, size, _ := s.Kind()
|
|
fmt.Printf("Kind: %v size:%d\n", kind, size)
|
|
|
|
// Enter the list
|
|
if _, err := s.List(); err != nil {
|
|
fmt.Printf("List error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Decode elements
|
|
fmt.Println(s.Uint())
|
|
fmt.Println(s.Uint())
|
|
fmt.Println(s.Bytes())
|
|
|
|
// Acknowledge end of list
|
|
if err := s.ListEnd(); err != nil {
|
|
fmt.Printf("ListEnd error: %v\n", err)
|
|
}
|
|
// Output:
|
|
// Kind: List size:9
|
|
// 10 <nil>
|
|
// 20 <nil>
|
|
// [102 111 111 98 97 114] <nil>
|
|
}
|
|
|
|
func BenchmarkDecode(b *testing.B) {
|
|
enc := encTest(90000)
|
|
b.SetBytes(int64(len(enc)))
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
var s []int
|
|
r := bytes.NewReader(enc)
|
|
if err := Decode(r, &s); err != nil {
|
|
b.Fatalf("Decode error: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkDecodeIntSliceReuse(b *testing.B) {
|
|
enc := encTest(100000)
|
|
b.SetBytes(int64(len(enc)))
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
|
|
var s []int
|
|
for i := 0; i < b.N; i++ {
|
|
r := bytes.NewReader(enc)
|
|
if err := Decode(r, &s); err != nil {
|
|
b.Fatalf("Decode error: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func encTest(n int) []byte {
|
|
s := make([]interface{}, n)
|
|
for i := 0; i < n; i++ {
|
|
s[i] = i
|
|
}
|
|
return ethutil.Encode(s)
|
|
}
|
|
|
|
func unhex(str string) []byte {
|
|
b, err := hex.DecodeString(str)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("invalid hex string: %q", str))
|
|
}
|
|
return b
|
|
}
|