github.com/myafeier/go-ethereum@v1.6.8-0.20170719123245-3e0dbe0eaa72/rlp/decode_test.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum 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-ethereum 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-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package rlp
    18  
    19  import (
    20  	"bytes"
    21  	"encoding/hex"
    22  	"errors"
    23  	"fmt"
    24  	"io"
    25  	"math/big"
    26  	"reflect"
    27  	"strings"
    28  	"testing"
    29  )
    30  
    31  func TestStreamKind(t *testing.T) {
    32  	tests := []struct {
    33  		input    string
    34  		wantKind Kind
    35  		wantLen  uint64
    36  	}{
    37  		{"00", Byte, 0},
    38  		{"01", Byte, 0},
    39  		{"7F", Byte, 0},
    40  		{"80", String, 0},
    41  		{"B7", String, 55},
    42  		{"B90400", String, 1024},
    43  		{"BFFFFFFFFFFFFFFFFF", String, ^uint64(0)},
    44  		{"C0", List, 0},
    45  		{"C8", List, 8},
    46  		{"F7", List, 55},
    47  		{"F90400", List, 1024},
    48  		{"FFFFFFFFFFFFFFFFFF", List, ^uint64(0)},
    49  	}
    50  
    51  	for i, test := range tests {
    52  		// using plainReader to inhibit input limit errors.
    53  		s := NewStream(newPlainReader(unhex(test.input)), 0)
    54  		kind, len, err := s.Kind()
    55  		if err != nil {
    56  			t.Errorf("test %d: Kind returned error: %v", i, err)
    57  			continue
    58  		}
    59  		if kind != test.wantKind {
    60  			t.Errorf("test %d: kind mismatch: got %d, want %d", i, kind, test.wantKind)
    61  		}
    62  		if len != test.wantLen {
    63  			t.Errorf("test %d: len mismatch: got %d, want %d", i, len, test.wantLen)
    64  		}
    65  	}
    66  }
    67  
    68  func TestNewListStream(t *testing.T) {
    69  	ls := NewListStream(bytes.NewReader(unhex("0101010101")), 3)
    70  	if k, size, err := ls.Kind(); k != List || size != 3 || err != nil {
    71  		t.Errorf("Kind() returned (%v, %d, %v), expected (List, 3, nil)", k, size, err)
    72  	}
    73  	if size, err := ls.List(); size != 3 || err != nil {
    74  		t.Errorf("List() returned (%d, %v), expected (3, nil)", size, err)
    75  	}
    76  	for i := 0; i < 3; i++ {
    77  		if val, err := ls.Uint(); val != 1 || err != nil {
    78  			t.Errorf("Uint() returned (%d, %v), expected (1, nil)", val, err)
    79  		}
    80  	}
    81  	if err := ls.ListEnd(); err != nil {
    82  		t.Errorf("ListEnd() returned %v, expected (3, nil)", err)
    83  	}
    84  }
    85  
    86  func TestStreamErrors(t *testing.T) {
    87  	withoutInputLimit := func(b []byte) *Stream {
    88  		return NewStream(newPlainReader(b), 0)
    89  	}
    90  	withCustomInputLimit := func(limit uint64) func([]byte) *Stream {
    91  		return func(b []byte) *Stream {
    92  			return NewStream(bytes.NewReader(b), limit)
    93  		}
    94  	}
    95  
    96  	type calls []string
    97  	tests := []struct {
    98  		string
    99  		calls
   100  		newStream func([]byte) *Stream // uses bytes.Reader if nil
   101  		error     error
   102  	}{
   103  		{"C0", calls{"Bytes"}, nil, ErrExpectedString},
   104  		{"C0", calls{"Uint"}, nil, ErrExpectedString},
   105  		{"89000000000000000001", calls{"Uint"}, nil, errUintOverflow},
   106  		{"00", calls{"List"}, nil, ErrExpectedList},
   107  		{"80", calls{"List"}, nil, ErrExpectedList},
   108  		{"C0", calls{"List", "Uint"}, nil, EOL},
   109  		{"C8C9010101010101010101", calls{"List", "Kind"}, nil, ErrElemTooLarge},
   110  		{"C3C2010201", calls{"List", "List", "Uint", "Uint", "ListEnd", "Uint"}, nil, EOL},
   111  		{"00", calls{"ListEnd"}, nil, errNotInList},
   112  		{"C401020304", calls{"List", "Uint", "ListEnd"}, nil, errNotAtEOL},
   113  
   114  		// Non-canonical integers (e.g. leading zero bytes).
   115  		{"00", calls{"Uint"}, nil, ErrCanonInt},
   116  		{"820002", calls{"Uint"}, nil, ErrCanonInt},
   117  		{"8133", calls{"Uint"}, nil, ErrCanonSize},
   118  		{"817F", calls{"Uint"}, nil, ErrCanonSize},
   119  		{"8180", calls{"Uint"}, nil, nil},
   120  
   121  		// Non-valid boolean
   122  		{"02", calls{"Bool"}, nil, errors.New("rlp: invalid boolean value: 2")},
   123  
   124  		// Size tags must use the smallest possible encoding.
   125  		// Leading zero bytes in the size tag are also rejected.
   126  		{"8100", calls{"Uint"}, nil, ErrCanonSize},
   127  		{"8100", calls{"Bytes"}, nil, ErrCanonSize},
   128  		{"8101", calls{"Bytes"}, nil, ErrCanonSize},
   129  		{"817F", calls{"Bytes"}, nil, ErrCanonSize},
   130  		{"8180", calls{"Bytes"}, nil, nil},
   131  		{"B800", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   132  		{"B90000", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   133  		{"B90055", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   134  		{"BA0002FFFF", calls{"Bytes"}, withoutInputLimit, ErrCanonSize},
   135  		{"F800", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   136  		{"F90000", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   137  		{"F90055", calls{"Kind"}, withoutInputLimit, ErrCanonSize},
   138  		{"FA0002FFFF", calls{"List"}, withoutInputLimit, ErrCanonSize},
   139  
   140  		// Expected EOF
   141  		{"", calls{"Kind"}, nil, io.EOF},
   142  		{"", calls{"Uint"}, nil, io.EOF},
   143  		{"", calls{"List"}, nil, io.EOF},
   144  		{"8180", calls{"Uint", "Uint"}, nil, io.EOF},
   145  		{"C0", calls{"List", "ListEnd", "List"}, nil, io.EOF},
   146  
   147  		{"", calls{"List"}, withoutInputLimit, io.EOF},
   148  		{"8180", calls{"Uint", "Uint"}, withoutInputLimit, io.EOF},
   149  		{"C0", calls{"List", "ListEnd", "List"}, withoutInputLimit, io.EOF},
   150  
   151  		// Input limit errors.
   152  		{"81", calls{"Bytes"}, nil, ErrValueTooLarge},
   153  		{"81", calls{"Uint"}, nil, ErrValueTooLarge},
   154  		{"81", calls{"Raw"}, nil, ErrValueTooLarge},
   155  		{"BFFFFFFFFFFFFFFFFFFF", calls{"Bytes"}, nil, ErrValueTooLarge},
   156  		{"C801", calls{"List"}, nil, ErrValueTooLarge},
   157  
   158  		// Test for list element size check overflow.
   159  		{"CD04040404FFFFFFFFFFFFFFFFFF0303", calls{"List", "Uint", "Uint", "Uint", "Uint", "List"}, nil, ErrElemTooLarge},
   160  
   161  		// Test for input limit overflow. Since we are counting the limit
   162  		// down toward zero in Stream.remaining, reading too far can overflow
   163  		// remaining to a large value, effectively disabling the limit.
   164  		{"C40102030401", calls{"Raw", "Uint"}, withCustomInputLimit(5), io.EOF},
   165  		{"C4010203048180", calls{"Raw", "Uint"}, withCustomInputLimit(6), ErrValueTooLarge},
   166  
   167  		// Check that the same calls are fine without a limit.
   168  		{"C40102030401", calls{"Raw", "Uint"}, withoutInputLimit, nil},
   169  		{"C4010203048180", calls{"Raw", "Uint"}, withoutInputLimit, nil},
   170  
   171  		// Unexpected EOF. This only happens when there is
   172  		// no input limit, so the reader needs to be 'dumbed down'.
   173  		{"81", calls{"Bytes"}, withoutInputLimit, io.ErrUnexpectedEOF},
   174  		{"81", calls{"Uint"}, withoutInputLimit, io.ErrUnexpectedEOF},
   175  		{"BFFFFFFFFFFFFFFF", calls{"Bytes"}, withoutInputLimit, io.ErrUnexpectedEOF},
   176  		{"C801", calls{"List", "Uint", "Uint"}, withoutInputLimit, io.ErrUnexpectedEOF},
   177  
   178  		// This test verifies that the input position is advanced
   179  		// correctly when calling Bytes for empty strings. Kind can be called
   180  		// any number of times in between and doesn't advance.
   181  		{"C3808080", calls{
   182  			"List",  // enter the list
   183  			"Bytes", // past first element
   184  
   185  			"Kind", "Kind", "Kind", // this shouldn't advance
   186  
   187  			"Bytes", // past second element
   188  
   189  			"Kind", "Kind", // can't hurt to try
   190  
   191  			"Bytes", // past final element
   192  			"Bytes", // this one should fail
   193  		}, nil, EOL},
   194  	}
   195  
   196  testfor:
   197  	for i, test := range tests {
   198  		if test.newStream == nil {
   199  			test.newStream = func(b []byte) *Stream { return NewStream(bytes.NewReader(b), 0) }
   200  		}
   201  		s := test.newStream(unhex(test.string))
   202  		rs := reflect.ValueOf(s)
   203  		for j, call := range test.calls {
   204  			fval := rs.MethodByName(call)
   205  			ret := fval.Call(nil)
   206  			err := "<nil>"
   207  			if lastret := ret[len(ret)-1].Interface(); lastret != nil {
   208  				err = lastret.(error).Error()
   209  			}
   210  			if j == len(test.calls)-1 {
   211  				want := "<nil>"
   212  				if test.error != nil {
   213  					want = test.error.Error()
   214  				}
   215  				if err != want {
   216  					t.Log(test)
   217  					t.Errorf("test %d: last call (%s) error mismatch\ngot:  %s\nwant: %s",
   218  						i, call, err, test.error)
   219  				}
   220  			} else if err != "<nil>" {
   221  				t.Log(test)
   222  				t.Errorf("test %d: call %d (%s) unexpected error: %q", i, j, call, err)
   223  				continue testfor
   224  			}
   225  		}
   226  	}
   227  }
   228  
   229  func TestStreamList(t *testing.T) {
   230  	s := NewStream(bytes.NewReader(unhex("C80102030405060708")), 0)
   231  
   232  	len, err := s.List()
   233  	if err != nil {
   234  		t.Fatalf("List error: %v", err)
   235  	}
   236  	if len != 8 {
   237  		t.Fatalf("List returned invalid length, got %d, want 8", len)
   238  	}
   239  
   240  	for i := uint64(1); i <= 8; i++ {
   241  		v, err := s.Uint()
   242  		if err != nil {
   243  			t.Fatalf("Uint error: %v", err)
   244  		}
   245  		if i != v {
   246  			t.Errorf("Uint returned wrong value, got %d, want %d", v, i)
   247  		}
   248  	}
   249  
   250  	if _, err := s.Uint(); err != EOL {
   251  		t.Errorf("Uint error mismatch, got %v, want %v", err, EOL)
   252  	}
   253  	if err = s.ListEnd(); err != nil {
   254  		t.Fatalf("ListEnd error: %v", err)
   255  	}
   256  }
   257  
   258  func TestStreamRaw(t *testing.T) {
   259  	s := NewStream(bytes.NewReader(unhex("C58401010101")), 0)
   260  	s.List()
   261  
   262  	want := unhex("8401010101")
   263  	raw, err := s.Raw()
   264  	if err != nil {
   265  		t.Fatal(err)
   266  	}
   267  	if !bytes.Equal(want, raw) {
   268  		t.Errorf("raw mismatch: got %x, want %x", raw, want)
   269  	}
   270  }
   271  
   272  func TestDecodeErrors(t *testing.T) {
   273  	r := bytes.NewReader(nil)
   274  
   275  	if err := Decode(r, nil); err != errDecodeIntoNil {
   276  		t.Errorf("Decode(r, nil) error mismatch, got %q, want %q", err, errDecodeIntoNil)
   277  	}
   278  
   279  	var nilptr *struct{}
   280  	if err := Decode(r, nilptr); err != errDecodeIntoNil {
   281  		t.Errorf("Decode(r, nilptr) error mismatch, got %q, want %q", err, errDecodeIntoNil)
   282  	}
   283  
   284  	if err := Decode(r, struct{}{}); err != errNoPointer {
   285  		t.Errorf("Decode(r, struct{}{}) error mismatch, got %q, want %q", err, errNoPointer)
   286  	}
   287  
   288  	expectErr := "rlp: type chan bool is not RLP-serializable"
   289  	if err := Decode(r, new(chan bool)); err == nil || err.Error() != expectErr {
   290  		t.Errorf("Decode(r, new(chan bool)) error mismatch, got %q, want %q", err, expectErr)
   291  	}
   292  
   293  	if err := Decode(r, new(uint)); err != io.EOF {
   294  		t.Errorf("Decode(r, new(int)) error mismatch, got %q, want %q", err, io.EOF)
   295  	}
   296  }
   297  
   298  type decodeTest struct {
   299  	input string
   300  	ptr   interface{}
   301  	value interface{}
   302  	error string
   303  }
   304  
   305  type simplestruct struct {
   306  	A uint
   307  	B string
   308  }
   309  
   310  type recstruct struct {
   311  	I     uint
   312  	Child *recstruct `rlp:"nil"`
   313  }
   314  
   315  type invalidTail1 struct {
   316  	A uint `rlp:"tail"`
   317  	B string
   318  }
   319  
   320  type invalidTail2 struct {
   321  	A uint
   322  	B string `rlp:"tail"`
   323  }
   324  
   325  type tailRaw struct {
   326  	A    uint
   327  	Tail []RawValue `rlp:"tail"`
   328  }
   329  
   330  type tailUint struct {
   331  	A    uint
   332  	Tail []uint `rlp:"tail"`
   333  }
   334  
   335  var (
   336  	veryBigInt = big.NewInt(0).Add(
   337  		big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16),
   338  		big.NewInt(0xFFFF),
   339  	)
   340  )
   341  
   342  type hasIgnoredField struct {
   343  	A uint
   344  	B uint `rlp:"-"`
   345  	C uint
   346  }
   347  
   348  var decodeTests = []decodeTest{
   349  	// booleans
   350  	{input: "01", ptr: new(bool), value: true},
   351  	{input: "80", ptr: new(bool), value: false},
   352  	{input: "02", ptr: new(bool), error: "rlp: invalid boolean value: 2"},
   353  
   354  	// integers
   355  	{input: "05", ptr: new(uint32), value: uint32(5)},
   356  	{input: "80", ptr: new(uint32), value: uint32(0)},
   357  	{input: "820505", ptr: new(uint32), value: uint32(0x0505)},
   358  	{input: "83050505", ptr: new(uint32), value: uint32(0x050505)},
   359  	{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)},
   360  	{input: "850505050505", ptr: new(uint32), error: "rlp: input string too long for uint32"},
   361  	{input: "C0", ptr: new(uint32), error: "rlp: expected input string or byte for uint32"},
   362  	{input: "00", ptr: new(uint32), error: "rlp: non-canonical integer (leading zero bytes) for uint32"},
   363  	{input: "8105", ptr: new(uint32), error: "rlp: non-canonical size information for uint32"},
   364  	{input: "820004", ptr: new(uint32), error: "rlp: non-canonical integer (leading zero bytes) for uint32"},
   365  	{input: "B8020004", ptr: new(uint32), error: "rlp: non-canonical size information for uint32"},
   366  
   367  	// slices
   368  	{input: "C0", ptr: new([]uint), value: []uint{}},
   369  	{input: "C80102030405060708", ptr: new([]uint), value: []uint{1, 2, 3, 4, 5, 6, 7, 8}},
   370  	{input: "F8020004", ptr: new([]uint), error: "rlp: non-canonical size information for []uint"},
   371  
   372  	// arrays
   373  	{input: "C50102030405", ptr: new([5]uint), value: [5]uint{1, 2, 3, 4, 5}},
   374  	{input: "C0", ptr: new([5]uint), error: "rlp: input list has too few elements for [5]uint"},
   375  	{input: "C102", ptr: new([5]uint), error: "rlp: input list has too few elements for [5]uint"},
   376  	{input: "C6010203040506", ptr: new([5]uint), error: "rlp: input list has too many elements for [5]uint"},
   377  	{input: "F8020004", ptr: new([5]uint), error: "rlp: non-canonical size information for [5]uint"},
   378  
   379  	// zero sized arrays
   380  	{input: "C0", ptr: new([0]uint), value: [0]uint{}},
   381  	{input: "C101", ptr: new([0]uint), error: "rlp: input list has too many elements for [0]uint"},
   382  
   383  	// byte slices
   384  	{input: "01", ptr: new([]byte), value: []byte{1}},
   385  	{input: "80", ptr: new([]byte), value: []byte{}},
   386  	{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
   387  	{input: "C0", ptr: new([]byte), error: "rlp: expected input string or byte for []uint8"},
   388  	{input: "8105", ptr: new([]byte), error: "rlp: non-canonical size information for []uint8"},
   389  
   390  	// byte arrays
   391  	{input: "02", ptr: new([1]byte), value: [1]byte{2}},
   392  	{input: "8180", ptr: new([1]byte), value: [1]byte{128}},
   393  	{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
   394  
   395  	// byte array errors
   396  	{input: "02", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"},
   397  	{input: "80", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"},
   398  	{input: "820000", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"},
   399  	{input: "C0", ptr: new([5]byte), error: "rlp: expected input string or byte for [5]uint8"},
   400  	{input: "C3010203", ptr: new([5]byte), error: "rlp: expected input string or byte for [5]uint8"},
   401  	{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too long for [5]uint8"},
   402  	{input: "8105", ptr: new([1]byte), error: "rlp: non-canonical size information for [1]uint8"},
   403  	{input: "817F", ptr: new([1]byte), error: "rlp: non-canonical size information for [1]uint8"},
   404  
   405  	// zero sized byte arrays
   406  	{input: "80", ptr: new([0]byte), value: [0]byte{}},
   407  	{input: "01", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"},
   408  	{input: "8101", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"},
   409  
   410  	// strings
   411  	{input: "00", ptr: new(string), value: "\000"},
   412  	{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"},
   413  	{input: "C0", ptr: new(string), error: "rlp: expected input string or byte for string"},
   414  
   415  	// big ints
   416  	{input: "01", ptr: new(*big.Int), value: big.NewInt(1)},
   417  	{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt},
   418  	{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
   419  	{input: "C0", ptr: new(*big.Int), error: "rlp: expected input string or byte for *big.Int"},
   420  	{input: "820001", ptr: new(big.Int), error: "rlp: non-canonical integer (leading zero bytes) for *big.Int"},
   421  	{input: "8105", ptr: new(big.Int), error: "rlp: non-canonical size information for *big.Int"},
   422  
   423  	// structs
   424  	{
   425  		input: "C50583343434",
   426  		ptr:   new(simplestruct),
   427  		value: simplestruct{5, "444"},
   428  	},
   429  	{
   430  		input: "C601C402C203C0",
   431  		ptr:   new(recstruct),
   432  		value: recstruct{1, &recstruct{2, &recstruct{3, nil}}},
   433  	},
   434  
   435  	// struct errors
   436  	{
   437  		input: "C0",
   438  		ptr:   new(simplestruct),
   439  		error: "rlp: too few elements for rlp.simplestruct",
   440  	},
   441  	{
   442  		input: "C105",
   443  		ptr:   new(simplestruct),
   444  		error: "rlp: too few elements for rlp.simplestruct",
   445  	},
   446  	{
   447  		input: "C7C50583343434C0",
   448  		ptr:   new([]*simplestruct),
   449  		error: "rlp: too few elements for rlp.simplestruct, decoding into ([]*rlp.simplestruct)[1]",
   450  	},
   451  	{
   452  		input: "83222222",
   453  		ptr:   new(simplestruct),
   454  		error: "rlp: expected input list for rlp.simplestruct",
   455  	},
   456  	{
   457  		input: "C3010101",
   458  		ptr:   new(simplestruct),
   459  		error: "rlp: input list has too many elements for rlp.simplestruct",
   460  	},
   461  	{
   462  		input: "C501C3C00000",
   463  		ptr:   new(recstruct),
   464  		error: "rlp: expected input string or byte for uint, decoding into (rlp.recstruct).Child.I",
   465  	},
   466  	{
   467  		input: "C0",
   468  		ptr:   new(invalidTail1),
   469  		error: "rlp: invalid struct tag \"tail\" for rlp.invalidTail1.A (must be on last field)",
   470  	},
   471  	{
   472  		input: "C0",
   473  		ptr:   new(invalidTail2),
   474  		error: "rlp: invalid struct tag \"tail\" for rlp.invalidTail2.B (field type is not slice)",
   475  	},
   476  	{
   477  		input: "C50102C20102",
   478  		ptr:   new(tailUint),
   479  		error: "rlp: expected input string or byte for uint, decoding into (rlp.tailUint).Tail[1]",
   480  	},
   481  
   482  	// struct tag "tail"
   483  	{
   484  		input: "C3010203",
   485  		ptr:   new(tailRaw),
   486  		value: tailRaw{A: 1, Tail: []RawValue{unhex("02"), unhex("03")}},
   487  	},
   488  	{
   489  		input: "C20102",
   490  		ptr:   new(tailRaw),
   491  		value: tailRaw{A: 1, Tail: []RawValue{unhex("02")}},
   492  	},
   493  	{
   494  		input: "C101",
   495  		ptr:   new(tailRaw),
   496  		value: tailRaw{A: 1, Tail: []RawValue{}},
   497  	},
   498  
   499  	// struct tag "-"
   500  	{
   501  		input: "C20102",
   502  		ptr:   new(hasIgnoredField),
   503  		value: hasIgnoredField{A: 1, C: 2},
   504  	},
   505  
   506  	// RawValue
   507  	{input: "01", ptr: new(RawValue), value: RawValue(unhex("01"))},
   508  	{input: "82FFFF", ptr: new(RawValue), value: RawValue(unhex("82FFFF"))},
   509  	{input: "C20102", ptr: new([]RawValue), value: []RawValue{unhex("01"), unhex("02")}},
   510  
   511  	// pointers
   512  	{input: "00", ptr: new(*[]byte), value: &[]byte{0}},
   513  	{input: "80", ptr: new(*uint), value: uintp(0)},
   514  	{input: "C0", ptr: new(*uint), error: "rlp: expected input string or byte for uint"},
   515  	{input: "07", ptr: new(*uint), value: uintp(7)},
   516  	{input: "817F", ptr: new(*uint), error: "rlp: non-canonical size information for uint"},
   517  	{input: "8180", ptr: new(*uint), value: uintp(0x80)},
   518  	{input: "C109", ptr: new(*[]uint), value: &[]uint{9}},
   519  	{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}},
   520  
   521  	// check that input position is advanced also for empty values.
   522  	{input: "C3808005", ptr: new([]*uint), value: []*uint{uintp(0), uintp(0), uintp(5)}},
   523  
   524  	// interface{}
   525  	{input: "00", ptr: new(interface{}), value: []byte{0}},
   526  	{input: "01", ptr: new(interface{}), value: []byte{1}},
   527  	{input: "80", ptr: new(interface{}), value: []byte{}},
   528  	{input: "850505050505", ptr: new(interface{}), value: []byte{5, 5, 5, 5, 5}},
   529  	{input: "C0", ptr: new(interface{}), value: []interface{}{}},
   530  	{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}},
   531  	{
   532  		input: "C3010203",
   533  		ptr:   new([]io.Reader),
   534  		error: "rlp: type io.Reader is not RLP-serializable",
   535  	},
   536  
   537  	// fuzzer crashes
   538  	{
   539  		input: "c330f9c030f93030ce3030303030303030bd303030303030",
   540  		ptr:   new(interface{}),
   541  		error: "rlp: element is larger than containing list",
   542  	},
   543  }
   544  
   545  func uintp(i uint) *uint { return &i }
   546  
   547  func runTests(t *testing.T, decode func([]byte, interface{}) error) {
   548  	for i, test := range decodeTests {
   549  		input, err := hex.DecodeString(test.input)
   550  		if err != nil {
   551  			t.Errorf("test %d: invalid hex input %q", i, test.input)
   552  			continue
   553  		}
   554  		err = decode(input, test.ptr)
   555  		if err != nil && test.error == "" {
   556  			t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q",
   557  				i, err, test.ptr, test.input)
   558  			continue
   559  		}
   560  		if test.error != "" && fmt.Sprint(err) != test.error {
   561  			t.Errorf("test %d: Decode error mismatch\ngot  %v\nwant %v\ndecoding into %T\ninput %q",
   562  				i, err, test.error, test.ptr, test.input)
   563  			continue
   564  		}
   565  		deref := reflect.ValueOf(test.ptr).Elem().Interface()
   566  		if err == nil && !reflect.DeepEqual(deref, test.value) {
   567  			t.Errorf("test %d: value mismatch\ngot  %#v\nwant %#v\ndecoding into %T\ninput %q",
   568  				i, deref, test.value, test.ptr, test.input)
   569  		}
   570  	}
   571  }
   572  
   573  func TestDecodeWithByteReader(t *testing.T) {
   574  	runTests(t, func(input []byte, into interface{}) error {
   575  		return Decode(bytes.NewReader(input), into)
   576  	})
   577  }
   578  
   579  // plainReader reads from a byte slice but does not
   580  // implement ReadByte. It is also not recognized by the
   581  // size validation. This is useful to test how the decoder
   582  // behaves on a non-buffered input stream.
   583  type plainReader []byte
   584  
   585  func newPlainReader(b []byte) io.Reader {
   586  	return (*plainReader)(&b)
   587  }
   588  
   589  func (r *plainReader) Read(buf []byte) (n int, err error) {
   590  	if len(*r) == 0 {
   591  		return 0, io.EOF
   592  	}
   593  	n = copy(buf, *r)
   594  	*r = (*r)[n:]
   595  	return n, nil
   596  }
   597  
   598  func TestDecodeWithNonByteReader(t *testing.T) {
   599  	runTests(t, func(input []byte, into interface{}) error {
   600  		return Decode(newPlainReader(input), into)
   601  	})
   602  }
   603  
   604  func TestDecodeStreamReset(t *testing.T) {
   605  	s := NewStream(nil, 0)
   606  	runTests(t, func(input []byte, into interface{}) error {
   607  		s.Reset(bytes.NewReader(input), 0)
   608  		return s.Decode(into)
   609  	})
   610  }
   611  
   612  type testDecoder struct{ called bool }
   613  
   614  func (t *testDecoder) DecodeRLP(s *Stream) error {
   615  	if _, err := s.Uint(); err != nil {
   616  		return err
   617  	}
   618  	t.called = true
   619  	return nil
   620  }
   621  
   622  func TestDecodeDecoder(t *testing.T) {
   623  	var s struct {
   624  		T1 testDecoder
   625  		T2 *testDecoder
   626  		T3 **testDecoder
   627  	}
   628  	if err := Decode(bytes.NewReader(unhex("C3010203")), &s); err != nil {
   629  		t.Fatalf("Decode error: %v", err)
   630  	}
   631  
   632  	if !s.T1.called {
   633  		t.Errorf("DecodeRLP was not called for (non-pointer) testDecoder")
   634  	}
   635  
   636  	if s.T2 == nil {
   637  		t.Errorf("*testDecoder has not been allocated")
   638  	} else if !s.T2.called {
   639  		t.Errorf("DecodeRLP was not called for *testDecoder")
   640  	}
   641  
   642  	if s.T3 == nil || *s.T3 == nil {
   643  		t.Errorf("**testDecoder has not been allocated")
   644  	} else if !(*s.T3).called {
   645  		t.Errorf("DecodeRLP was not called for **testDecoder")
   646  	}
   647  }
   648  
   649  type byteDecoder byte
   650  
   651  func (bd *byteDecoder) DecodeRLP(s *Stream) error {
   652  	_, err := s.Uint()
   653  	*bd = 255
   654  	return err
   655  }
   656  
   657  func (bd byteDecoder) called() bool {
   658  	return bd == 255
   659  }
   660  
   661  // This test verifies that the byte slice/byte array logic
   662  // does not kick in for element types implementing Decoder.
   663  func TestDecoderInByteSlice(t *testing.T) {
   664  	var slice []byteDecoder
   665  	if err := Decode(bytes.NewReader(unhex("C101")), &slice); err != nil {
   666  		t.Errorf("unexpected Decode error %v", err)
   667  	} else if !slice[0].called() {
   668  		t.Errorf("DecodeRLP not called for slice element")
   669  	}
   670  
   671  	var array [1]byteDecoder
   672  	if err := Decode(bytes.NewReader(unhex("C101")), &array); err != nil {
   673  		t.Errorf("unexpected Decode error %v", err)
   674  	} else if !array[0].called() {
   675  		t.Errorf("DecodeRLP not called for array element")
   676  	}
   677  }
   678  
   679  func ExampleDecode() {
   680  	input, _ := hex.DecodeString("C90A1486666F6F626172")
   681  
   682  	type example struct {
   683  		A, B    uint
   684  		private uint // private fields are ignored
   685  		String  string
   686  	}
   687  
   688  	var s example
   689  	err := Decode(bytes.NewReader(input), &s)
   690  	if err != nil {
   691  		fmt.Printf("Error: %v\n", err)
   692  	} else {
   693  		fmt.Printf("Decoded value: %#v\n", s)
   694  	}
   695  	// Output:
   696  	// Decoded value: rlp.example{A:0xa, B:0x14, private:0x0, String:"foobar"}
   697  }
   698  
   699  func ExampleDecode_structTagNil() {
   700  	// In this example, we'll use the "nil" struct tag to change
   701  	// how a pointer-typed field is decoded. The input contains an RLP
   702  	// list of one element, an empty string.
   703  	input := []byte{0xC1, 0x80}
   704  
   705  	// This type uses the normal rules.
   706  	// The empty input string is decoded as a pointer to an empty Go string.
   707  	var normalRules struct {
   708  		String *string
   709  	}
   710  	Decode(bytes.NewReader(input), &normalRules)
   711  	fmt.Printf("normal: String = %q\n", *normalRules.String)
   712  
   713  	// This type uses the struct tag.
   714  	// The empty input string is decoded as a nil pointer.
   715  	var withEmptyOK struct {
   716  		String *string `rlp:"nil"`
   717  	}
   718  	Decode(bytes.NewReader(input), &withEmptyOK)
   719  	fmt.Printf("with nil tag: String = %v\n", withEmptyOK.String)
   720  
   721  	// Output:
   722  	// normal: String = ""
   723  	// with nil tag: String = <nil>
   724  }
   725  
   726  func ExampleStream() {
   727  	input, _ := hex.DecodeString("C90A1486666F6F626172")
   728  	s := NewStream(bytes.NewReader(input), 0)
   729  
   730  	// Check what kind of value lies ahead
   731  	kind, size, _ := s.Kind()
   732  	fmt.Printf("Kind: %v size:%d\n", kind, size)
   733  
   734  	// Enter the list
   735  	if _, err := s.List(); err != nil {
   736  		fmt.Printf("List error: %v\n", err)
   737  		return
   738  	}
   739  
   740  	// Decode elements
   741  	fmt.Println(s.Uint())
   742  	fmt.Println(s.Uint())
   743  	fmt.Println(s.Bytes())
   744  
   745  	// Acknowledge end of list
   746  	if err := s.ListEnd(); err != nil {
   747  		fmt.Printf("ListEnd error: %v\n", err)
   748  	}
   749  	// Output:
   750  	// Kind: List size:9
   751  	// 10 <nil>
   752  	// 20 <nil>
   753  	// [102 111 111 98 97 114] <nil>
   754  }
   755  
   756  func BenchmarkDecode(b *testing.B) {
   757  	enc := encodeTestSlice(90000)
   758  	b.SetBytes(int64(len(enc)))
   759  	b.ReportAllocs()
   760  	b.ResetTimer()
   761  
   762  	for i := 0; i < b.N; i++ {
   763  		var s []uint
   764  		r := bytes.NewReader(enc)
   765  		if err := Decode(r, &s); err != nil {
   766  			b.Fatalf("Decode error: %v", err)
   767  		}
   768  	}
   769  }
   770  
   771  func BenchmarkDecodeIntSliceReuse(b *testing.B) {
   772  	enc := encodeTestSlice(100000)
   773  	b.SetBytes(int64(len(enc)))
   774  	b.ReportAllocs()
   775  	b.ResetTimer()
   776  
   777  	var s []uint
   778  	for i := 0; i < b.N; i++ {
   779  		r := bytes.NewReader(enc)
   780  		if err := Decode(r, &s); err != nil {
   781  			b.Fatalf("Decode error: %v", err)
   782  		}
   783  	}
   784  }
   785  
   786  func encodeTestSlice(n uint) []byte {
   787  	s := make([]uint, n)
   788  	for i := uint(0); i < n; i++ {
   789  		s[i] = i
   790  	}
   791  	b, err := EncodeToBytes(s)
   792  	if err != nil {
   793  		panic(fmt.Sprintf("encode error: %v", err))
   794  	}
   795  	return b
   796  }
   797  
   798  func unhex(str string) []byte {
   799  	b, err := hex.DecodeString(strings.Replace(str, " ", "", -1))
   800  	if err != nil {
   801  		panic(fmt.Sprintf("invalid hex string: %q", str))
   802  	}
   803  	return b
   804  }