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 }