github.com/luckypickle/go-ethereum-vet@v1.14.2/tests/rlp_test_util.go (about) 1 // Copyright 2015 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 tests 18 19 import ( 20 "bytes" 21 "encoding/hex" 22 "errors" 23 "fmt" 24 "math/big" 25 "strings" 26 27 "github.com/luckypickle/go-ethereum-vet/rlp" 28 ) 29 30 // RLPTest is the JSON structure of a single RLP test. 31 type RLPTest struct { 32 // If the value of In is "INVALID" or "VALID", the test 33 // checks whether Out can be decoded into a value of 34 // type interface{}. 35 // 36 // For other JSON values, In is treated as a driver for 37 // calls to rlp.Stream. The test also verifies that encoding 38 // In produces the bytes in Out. 39 In interface{} 40 41 // Out is a hex-encoded RLP value. 42 Out string 43 } 44 45 // Run executes the test. 46 func (t *RLPTest) Run() error { 47 outb, err := hex.DecodeString(t.Out) 48 if err != nil { 49 return fmt.Errorf("invalid hex in Out") 50 } 51 52 // Handle simple decoding tests with no actual In value. 53 if t.In == "VALID" || t.In == "INVALID" { 54 return checkDecodeInterface(outb, t.In == "VALID") 55 } 56 57 // Check whether encoding the value produces the same bytes. 58 in := translateJSON(t.In) 59 b, err := rlp.EncodeToBytes(in) 60 if err != nil { 61 return fmt.Errorf("encode failed: %v", err) 62 } 63 if !bytes.Equal(b, outb) { 64 return fmt.Errorf("encode produced %x, want %x", b, outb) 65 } 66 // Test stream decoding. 67 s := rlp.NewStream(bytes.NewReader(outb), 0) 68 return checkDecodeFromJSON(s, in) 69 } 70 71 func checkDecodeInterface(b []byte, isValid bool) error { 72 err := rlp.DecodeBytes(b, new(interface{})) 73 switch { 74 case isValid && err != nil: 75 return fmt.Errorf("decoding failed: %v", err) 76 case !isValid && err == nil: 77 return fmt.Errorf("decoding of invalid value succeeded") 78 } 79 return nil 80 } 81 82 // translateJSON makes test json values encodable with RLP. 83 func translateJSON(v interface{}) interface{} { 84 switch v := v.(type) { 85 case float64: 86 return uint64(v) 87 case string: 88 if len(v) > 0 && v[0] == '#' { // # starts a faux big int. 89 big, ok := new(big.Int).SetString(v[1:], 10) 90 if !ok { 91 panic(fmt.Errorf("bad test: bad big int: %q", v)) 92 } 93 return big 94 } 95 return []byte(v) 96 case []interface{}: 97 new := make([]interface{}, len(v)) 98 for i := range v { 99 new[i] = translateJSON(v[i]) 100 } 101 return new 102 default: 103 panic(fmt.Errorf("can't handle %T", v)) 104 } 105 } 106 107 // checkDecodeFromJSON decodes from s guided by exp. exp drives the 108 // Stream by invoking decoding operations (Uint, Big, List, ...) based 109 // on the type of each value. The value decoded from the RLP stream 110 // must match the JSON value. 111 func checkDecodeFromJSON(s *rlp.Stream, exp interface{}) error { 112 switch exp := exp.(type) { 113 case uint64: 114 i, err := s.Uint() 115 if err != nil { 116 return addStack("Uint", exp, err) 117 } 118 if i != exp { 119 return addStack("Uint", exp, fmt.Errorf("result mismatch: got %d", i)) 120 } 121 case *big.Int: 122 big := new(big.Int) 123 if err := s.Decode(&big); err != nil { 124 return addStack("Big", exp, err) 125 } 126 if big.Cmp(exp) != 0 { 127 return addStack("Big", exp, fmt.Errorf("result mismatch: got %d", big)) 128 } 129 case []byte: 130 b, err := s.Bytes() 131 if err != nil { 132 return addStack("Bytes", exp, err) 133 } 134 if !bytes.Equal(b, exp) { 135 return addStack("Bytes", exp, fmt.Errorf("result mismatch: got %x", b)) 136 } 137 case []interface{}: 138 if _, err := s.List(); err != nil { 139 return addStack("List", exp, err) 140 } 141 for i, v := range exp { 142 if err := checkDecodeFromJSON(s, v); err != nil { 143 return addStack(fmt.Sprintf("[%d]", i), exp, err) 144 } 145 } 146 if err := s.ListEnd(); err != nil { 147 return addStack("ListEnd", exp, err) 148 } 149 default: 150 panic(fmt.Errorf("unhandled type: %T", exp)) 151 } 152 return nil 153 } 154 155 func addStack(op string, val interface{}, err error) error { 156 lines := strings.Split(err.Error(), "\n") 157 lines = append(lines, fmt.Sprintf("\t%s: %v", op, val)) 158 return errors.New(strings.Join(lines, "\n")) 159 }