From 805345d13594b41e5dd2e4fed471c58c3775be9e Mon Sep 17 00:00:00 2001 From: Gustav Simonsson Date: Sun, 19 Apr 2015 00:35:48 +0200 Subject: Add block tests wrapper and fixes for tx tests * Add fixes to parsing and converting of fields in tx tests * Correct logic in tx tests; validation of fields and correct logic for when RLP decoding works/fails and when this is expected or not * Rename files for consistency * Add block tests wrapper to run block tests with go test --- tests/block_test_util.go | 345 +++++++++++++++++++++++++++++++++++++++++ tests/blocktest.go | 339 ---------------------------------------- tests/transaction_test_util.go | 143 +++++++++-------- 3 files changed, 426 insertions(+), 401 deletions(-) create mode 100644 tests/block_test_util.go delete mode 100644 tests/blocktest.go (limited to 'tests') diff --git a/tests/block_test_util.go b/tests/block_test_util.go new file mode 100644 index 000000000..5c42ae18c --- /dev/null +++ b/tests/block_test_util.go @@ -0,0 +1,345 @@ +package tests + +import ( + "bytes" + "encoding/hex" + "encoding/json" + "fmt" + "io/ioutil" + "math/big" + "runtime" + "strconv" + "strings" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" +) + +// Block Test JSON Format +type btJSON struct { + Blocks []btBlock + GenesisBlockHeader btHeader + Pre map[string]btAccount + PostState map[string]btAccount +} + +type btAccount struct { + Balance string + Code string + Nonce string + Storage map[string]string +} + +type btHeader struct { + Bloom string + Coinbase string + MixHash string + Nonce string + Number string + ParentHash string + ReceiptTrie string + SeedHash string + StateRoot string + TransactionsTrie string + UncleHash string + + ExtraData string + Difficulty string + GasLimit string + GasUsed string + Timestamp string +} + +type btTransaction struct { + Data string + GasLimit string + GasPrice string + Nonce string + R string + S string + To string + V string + Value string +} + +type btBlock struct { + BlockHeader *btHeader + Rlp string + Transactions []btTransaction + UncleHeaders []*btHeader +} + +type BlockTest struct { + Genesis *types.Block + + json *btJSON + preAccounts map[string]btAccount +} + +// LoadBlockTests loads a block test JSON file. +func LoadBlockTests(file string) (map[string]*BlockTest, error) { + bt := make(map[string]*btJSON) + if err := LoadJSON(file, &bt); err != nil { + return nil, err + } + out := make(map[string]*BlockTest) + for name, in := range bt { + var err error + if out[name], err = convertTest(in); err != nil { + return out, fmt.Errorf("bad test %q: %v", name, err) + } + } + return out, nil +} + +// InsertPreState populates the given database with the genesis +// accounts defined by the test. +func (t *BlockTest) InsertPreState(db common.Database) (*state.StateDB, error) { + statedb := state.New(common.Hash{}, db) + for addrString, acct := range t.preAccounts { + // XXX: is is worth it checking for errors here? + //addr, _ := hex.DecodeString(addrString) + code, _ := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) + balance, _ := new(big.Int).SetString(acct.Balance, 0) + nonce, _ := strconv.ParseUint(acct.Nonce, 16, 64) + + obj := statedb.CreateAccount(common.HexToAddress(addrString)) + obj.SetCode(code) + obj.SetBalance(balance) + obj.SetNonce(nonce) + for k, v := range acct.Storage { + statedb.SetState(common.HexToAddress(addrString), common.HexToHash(k), common.FromHex(v)) + } + } + // sync objects to trie + statedb.Update() + // sync trie to disk + statedb.Sync() + + if !bytes.Equal(t.Genesis.Root().Bytes(), statedb.Root().Bytes()) { + return nil, fmt.Errorf("computed state root does not match genesis block %x %x", t.Genesis.Root().Bytes()[:4], statedb.Root().Bytes()[:4]) + } + return statedb, nil +} + +// InsertBlocks loads the test's blocks into the given chain. +func (t *BlockTest) InsertBlocks(chain *core.ChainManager) error { + blocks, err := t.convertBlocks() + if err != nil { + return err + } + return chain.InsertChain(blocks) +} + +func (t *BlockTest) ValidatePostState(statedb *state.StateDB) error { + for addrString, acct := range t.preAccounts { + // XXX: is is worth it checking for errors here? + addr, _ := hex.DecodeString(addrString) + code, _ := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) + balance, _ := new(big.Int).SetString(acct.Balance, 0) + nonce, _ := strconv.ParseUint(acct.Nonce, 16, 64) + + // address is indirectly verified by the other fields, as it's the db key + code2 := statedb.GetCode(common.BytesToAddress(addr)) + balance2 := statedb.GetBalance(common.BytesToAddress(addr)) + nonce2 := statedb.GetNonce(common.BytesToAddress(addr)) + if !bytes.Equal(code2, code) { + return fmt.Errorf("account code mismatch, addr, found, expected: ", addrString, hex.EncodeToString(code2), hex.EncodeToString(code)) + } + if balance2.Cmp(balance) != 0 { + return fmt.Errorf("account balance mismatch, addr, found, expected: ", addrString, balance2, balance) + } + if nonce2 != nonce { + return fmt.Errorf("account nonce mismatch, addr, found, expected: ", addrString, nonce2, nonce) + } + } + return nil +} + +func (t *BlockTest) convertBlocks() (blocks []*types.Block, err error) { + // the conversion handles errors by catching panics. + // you might consider this ugly, but the alternative (passing errors) + // would be much harder to read. + defer func() { + if recovered := recover(); recovered != nil { + buf := make([]byte, 64<<10) + buf = buf[:runtime.Stack(buf, false)] + err = fmt.Errorf("%v\n%s", recovered, buf) + } + }() + blocks = mustConvertBlocks(t.json.Blocks) + return blocks, nil +} + +func convertTest(in *btJSON) (out *BlockTest, err error) { + // the conversion handles errors by catching panics. + // you might consider this ugly, but the alternative (passing errors) + // would be much harder to read. + defer func() { + if recovered := recover(); recovered != nil { + buf := make([]byte, 64<<10) + buf = buf[:runtime.Stack(buf, false)] + err = fmt.Errorf("%v\n%s", recovered, buf) + } + }() + out = &BlockTest{preAccounts: in.Pre, json: in} + out.Genesis = mustConvertGenesis(in.GenesisBlockHeader) + return out, err +} + +func mustConvertGenesis(testGenesis btHeader) *types.Block { + hdr := mustConvertHeader(testGenesis) + hdr.Number = big.NewInt(0) + b := types.NewBlockWithHeader(hdr) + b.Td = new(big.Int) + return b +} + +func mustConvertHeader(in btHeader) *types.Header { + // hex decode these fields + header := &types.Header{ + //SeedHash: mustConvertBytes(in.SeedHash), + MixDigest: mustConvertHash(in.MixHash), + Bloom: mustConvertBloom(in.Bloom), + ReceiptHash: mustConvertHash(in.ReceiptTrie), + TxHash: mustConvertHash(in.TransactionsTrie), + Root: mustConvertHash(in.StateRoot), + Coinbase: mustConvertAddress(in.Coinbase), + UncleHash: mustConvertHash(in.UncleHash), + ParentHash: mustConvertHash(in.ParentHash), + Extra: mustConvertBytes(in.ExtraData), + GasUsed: mustConvertBigInt(in.GasUsed, 10), + GasLimit: mustConvertBigInt(in.GasLimit, 10), + Difficulty: mustConvertBigInt(in.Difficulty, 10), + Time: mustConvertUint(in.Timestamp, 10), + } + // XXX cheats? :-) + header.SetNonce(mustConvertUint(in.Nonce, 16)) + return header +} + +func mustConvertBlocks(testBlocks []btBlock) []*types.Block { + var out []*types.Block + for i, inb := range testBlocks { + var b types.Block + r := bytes.NewReader(mustConvertBytes(inb.Rlp)) + if err := rlp.Decode(r, &b); err != nil { + panic(fmt.Errorf("invalid block %d: %q\nerror: %v", i, inb.Rlp, err)) + } + out = append(out, &b) + } + return out +} + +func mustConvertBytes(in string) []byte { + if in == "0x" { + return []byte{} + } + h := unfuckFuckedHex(strings.TrimPrefix(in, "0x")) + out, err := hex.DecodeString(h) + if err != nil { + panic(fmt.Errorf("invalid hex: %q: ", h, err)) + } + return out +} + +func mustConvertHash(in string) common.Hash { + out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) + if err != nil { + panic(fmt.Errorf("invalid hex: %q", in)) + } + return common.BytesToHash(out) +} + +func mustConvertAddress(in string) common.Address { + out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) + if err != nil { + panic(fmt.Errorf("invalid hex: %q", in)) + } + return common.BytesToAddress(out) +} + +func mustConvertBloom(in string) types.Bloom { + out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) + if err != nil { + panic(fmt.Errorf("invalid hex: %q", in)) + } + return types.BytesToBloom(out) +} + +func mustConvertBigInt(in string, base int) *big.Int { + in = prepInt(base, in) + out, ok := new(big.Int).SetString(in, base) + if !ok { + panic(fmt.Errorf("invalid integer: %q", in)) + } + return out +} + +func mustConvertUint(in string, base int) uint64 { + in = prepInt(base, in) + out, err := strconv.ParseUint(in, base, 64) + if err != nil { + panic(fmt.Errorf("invalid integer: %q", in)) + } + return out +} + +// LoadJSON reads the given file and unmarshals its content. +func LoadJSON(file string, val interface{}) error { + content, err := ioutil.ReadFile(file) + if err != nil { + return err + } + if err := json.Unmarshal(content, val); err != nil { + if syntaxerr, ok := err.(*json.SyntaxError); ok { + line := findLine(content, syntaxerr.Offset) + return fmt.Errorf("JSON syntax error at %v:%v: %v", file, line, err) + } + return fmt.Errorf("JSON unmarshal error in %v: %v", file, err) + } + return nil +} + +// findLine returns the line number for the given offset into data. +func findLine(data []byte, offset int64) (line int) { + line = 1 + for i, r := range string(data) { + if int64(i) >= offset { + return + } + if r == '\n' { + line++ + } + } + return +} + +// Nothing to see here, please move along... +func prepInt(base int, s string) string { + if base == 16 { + if strings.HasPrefix(s, "0x") { + s = s[2:] + } + if len(s) == 0 { + s = "00" + } + s = nibbleFix(s) + } + return s +} + +// don't ask +func unfuckFuckedHex(almostHex string) string { + return nibbleFix(strings.Replace(almostHex, "v", "", -1)) +} + +func nibbleFix(s string) string { + if len(s)%2 != 0 { + s = "0" + s + } + return s +} diff --git a/tests/blocktest.go b/tests/blocktest.go deleted file mode 100644 index d0a910336..000000000 --- a/tests/blocktest.go +++ /dev/null @@ -1,339 +0,0 @@ -package tests - -import ( - "bytes" - "encoding/hex" - "encoding/json" - "fmt" - "io/ioutil" - "math/big" - "runtime" - "strconv" - "strings" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/state" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/rlp" -) - -// Block Test JSON Format -type btJSON struct { - Blocks []btBlock - GenesisBlockHeader btHeader - Pre map[string]btAccount - PostState map[string]btAccount -} - -type btAccount struct { - Balance string - Code string - Nonce string - Storage map[string]string -} - -type btHeader struct { - Bloom string - Coinbase string - MixHash string - Nonce string - Number string - ParentHash string - ReceiptTrie string - SeedHash string - StateRoot string - TransactionsTrie string - UncleHash string - - ExtraData string - Difficulty string - GasLimit string - GasUsed string - Timestamp string -} - -type btTransaction struct { - Data string - GasLimit string - GasPrice string - Nonce string - R string - S string - To string - V string - Value string -} - -type btBlock struct { - BlockHeader *btHeader - Rlp string - Transactions []btTransaction - UncleHeaders []*btHeader -} - -type BlockTest struct { - Genesis *types.Block - - json *btJSON - preAccounts map[string]btAccount -} - -// LoadBlockTests loads a block test JSON file. -func LoadBlockTests(file string) (map[string]*BlockTest, error) { - bt := make(map[string]*btJSON) - if err := LoadJSON(file, &bt); err != nil { - return nil, err - } - out := make(map[string]*BlockTest) - for name, in := range bt { - var err error - if out[name], err = convertTest(in); err != nil { - return out, fmt.Errorf("bad test %q: %v", name, err) - } - } - return out, nil -} - -// InsertPreState populates the given database with the genesis -// accounts defined by the test. -func (t *BlockTest) InsertPreState(db common.Database) (*state.StateDB, error) { - statedb := state.New(common.Hash{}, db) - for addrString, acct := range t.preAccounts { - // XXX: is is worth it checking for errors here? - //addr, _ := hex.DecodeString(addrString) - code, _ := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) - balance, _ := new(big.Int).SetString(acct.Balance, 0) - nonce, _ := strconv.ParseUint(acct.Nonce, 16, 64) - - obj := statedb.CreateAccount(common.HexToAddress(addrString)) - obj.SetCode(code) - obj.SetBalance(balance) - obj.SetNonce(nonce) - for k, v := range acct.Storage { - statedb.SetState(common.HexToAddress(addrString), common.HexToHash(k), common.FromHex(v)) - } - } - // sync objects to trie - statedb.Update() - // sync trie to disk - statedb.Sync() - - if !bytes.Equal(t.Genesis.Root().Bytes(), statedb.Root().Bytes()) { - return nil, fmt.Errorf("computed state root does not match genesis block %x %x", t.Genesis.Root().Bytes()[:4], statedb.Root().Bytes()[:4]) - } - return statedb, nil -} - -// InsertBlocks loads the test's blocks into the given chain. -func (t *BlockTest) InsertBlocks(chain *core.ChainManager) error { - blocks, err := t.convertBlocks() - if err != nil { - return err - } - return chain.InsertChain(blocks) -} - -func (t *BlockTest) ValidatePostState(statedb *state.StateDB) error { - for addrString, acct := range t.preAccounts { - // XXX: is is worth it checking for errors here? - addr, _ := hex.DecodeString(addrString) - code, _ := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) - balance, _ := new(big.Int).SetString(acct.Balance, 0) - nonce, _ := strconv.ParseUint(acct.Nonce, 16, 64) - - // address is indirectly verified by the other fields, as it's the db key - code2 := statedb.GetCode(common.BytesToAddress(addr)) - balance2 := statedb.GetBalance(common.BytesToAddress(addr)) - nonce2 := statedb.GetNonce(common.BytesToAddress(addr)) - if !bytes.Equal(code2, code) { - return fmt.Errorf("account code mismatch, addr, found, expected: ", addrString, hex.EncodeToString(code2), hex.EncodeToString(code)) - } - if balance2.Cmp(balance) != 0 { - return fmt.Errorf("account balance mismatch, addr, found, expected: ", addrString, balance2, balance) - } - if nonce2 != nonce { - return fmt.Errorf("account nonce mismatch, addr, found, expected: ", addrString, nonce2, nonce) - } - } - return nil -} - -func (t *BlockTest) convertBlocks() (blocks []*types.Block, err error) { - // the conversion handles errors by catching panics. - // you might consider this ugly, but the alternative (passing errors) - // would be much harder to read. - defer func() { - if recovered := recover(); recovered != nil { - buf := make([]byte, 64<<10) - buf = buf[:runtime.Stack(buf, false)] - err = fmt.Errorf("%v\n%s", recovered, buf) - } - }() - blocks = mustConvertBlocks(t.json.Blocks) - return blocks, nil -} - -func convertTest(in *btJSON) (out *BlockTest, err error) { - // the conversion handles errors by catching panics. - // you might consider this ugly, but the alternative (passing errors) - // would be much harder to read. - defer func() { - if recovered := recover(); recovered != nil { - buf := make([]byte, 64<<10) - buf = buf[:runtime.Stack(buf, false)] - err = fmt.Errorf("%v\n%s", recovered, buf) - } - }() - out = &BlockTest{preAccounts: in.Pre, json: in} - out.Genesis = mustConvertGenesis(in.GenesisBlockHeader) - return out, err -} - -func mustConvertGenesis(testGenesis btHeader) *types.Block { - hdr := mustConvertHeader(testGenesis) - hdr.Number = big.NewInt(0) - b := types.NewBlockWithHeader(hdr) - b.Td = new(big.Int) - return b -} - -func mustConvertHeader(in btHeader) *types.Header { - // hex decode these fields - header := &types.Header{ - //SeedHash: mustConvertBytes(in.SeedHash), - MixDigest: mustConvertHash(in.MixHash), - Bloom: mustConvertBloom(in.Bloom), - ReceiptHash: mustConvertHash(in.ReceiptTrie), - TxHash: mustConvertHash(in.TransactionsTrie), - Root: mustConvertHash(in.StateRoot), - Coinbase: mustConvertAddress(in.Coinbase), - UncleHash: mustConvertHash(in.UncleHash), - ParentHash: mustConvertHash(in.ParentHash), - Extra: mustConvertBytes(in.ExtraData), - GasUsed: mustConvertBigInt(in.GasUsed, 10), - GasLimit: mustConvertBigInt(in.GasLimit, 10), - Difficulty: mustConvertBigInt(in.Difficulty, 10), - Time: mustConvertUint(in.Timestamp, 10), - } - // XXX cheats? :-) - header.SetNonce(mustConvertUint(in.Nonce, 16)) - return header -} - -func mustConvertBlocks(testBlocks []btBlock) []*types.Block { - var out []*types.Block - for i, inb := range testBlocks { - var b types.Block - r := bytes.NewReader(mustConvertBytes(inb.Rlp)) - if err := rlp.Decode(r, &b); err != nil { - panic(fmt.Errorf("invalid block %d: %q\nerror: %v", i, inb.Rlp, err)) - } - out = append(out, &b) - } - return out -} - -func mustConvertBytes(in string) []byte { - if in == "0x" { - return []byte{} - } - h := nibbleFix(strings.TrimPrefix(in, "0x")) - out, err := hex.DecodeString(h) - if err != nil { - panic(fmt.Errorf("invalid hex: %q", h)) - } - return out -} - -func mustConvertHash(in string) common.Hash { - out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) - if err != nil { - panic(fmt.Errorf("invalid hex: %q", in)) - } - return common.BytesToHash(out) -} - -func mustConvertAddress(in string) common.Address { - out, err := hex.DecodeString(nibbleFix(strings.TrimPrefix(in, "0x"))) - if err != nil { - panic(fmt.Errorf("invalid hex: %q", in)) - } - return common.BytesToAddress(out) -} - -func mustConvertBloom(in string) types.Bloom { - out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) - if err != nil { - panic(fmt.Errorf("invalid hex: %q", in)) - } - return types.BytesToBloom(out) -} - -func mustConvertBigInt(in string, base int) *big.Int { - in = prepInt(base, in) - out, ok := new(big.Int).SetString(in, base) - if !ok { - panic(fmt.Errorf("invalid integer: %q", in)) - } - return out -} - -func mustConvertUint(in string, base int) uint64 { - in = prepInt(base, in) - out, err := strconv.ParseUint(in, base, 64) - if err != nil { - panic(fmt.Errorf("invalid integer: %q", in)) - } - return out -} - -// LoadJSON reads the given file and unmarshals its content. -func LoadJSON(file string, val interface{}) error { - content, err := ioutil.ReadFile(file) - if err != nil { - return err - } - if err := json.Unmarshal(content, val); err != nil { - if syntaxerr, ok := err.(*json.SyntaxError); ok { - line := findLine(content, syntaxerr.Offset) - return fmt.Errorf("JSON syntax error at %v:%v: %v", file, line, err) - } - return fmt.Errorf("JSON unmarshal error in %v: %v", file, err) - } - return nil -} - -// findLine returns the line number for the given offset into data. -func findLine(data []byte, offset int64) (line int) { - line = 1 - for i, r := range string(data) { - if int64(i) >= offset { - return - } - if r == '\n' { - line++ - } - } - return -} - -func prepInt(base int, s string) string { - if base == 16 { - if strings.HasPrefix(s, "0x") { - s = s[2:] - } - if len(s) == 0 { - s = "00" - } - s = nibbleFix(s) - } - return s -} - -func nibbleFix(s string) string { - if len(s)%2 != 0 { - s = "0" + s - } - return s -} diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index d82946e20..23ec375e3 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -2,8 +2,8 @@ package tests import ( "bytes" + "errors" "fmt" - "math/big" "runtime" "github.com/ethereum/go-ethereum/common" @@ -49,93 +49,112 @@ func RunTransactionTests(file string, notWorking map[string]bool) error { } func runTest(txTest TransactionTest) (err error) { - expectedSender, expectedTo, expectedData, rlpBytes, expectedGasLimit, expectedGasPrice, expectedValue, expectedR, expectedS, expectedNonce, expectedV, err := convertTestTypes(txTest) + tx := new(types.Transaction) + err = rlp.DecodeBytes(mustConvertBytes(txTest.Rlp), tx) if err != nil { - if txTest.Sender == "" { // tx is invalid and this is expected (test OK) + if txTest.Sender == "" { + // RLP decoding failed and this is expected (test OK) return nil } else { - return err // tx is invalid and this is NOT expected (test FAIL) + // RLP decoding failed but is expected to succeed (test FAIL) + return errors.New("RLP decoding failed when expected to succeed") } } - tx := new(types.Transaction) - rlp.DecodeBytes(rlpBytes, tx) - //fmt.Println("HURR tx: %v", tx) - sender, err := tx.From() + + validationError := verifyTxFields(txTest, tx) + if txTest.Sender == "" { + if validationError != nil { + // RLP decoding works but validation should fail (test OK) + return nil + } else { + // RLP decoding works but validation should fail (test FAIL) + // (this should not be possible but added here for completeness) + return errors.New("Field validations succeeded but should fail") + } + } + + if txTest.Sender != "" { + if validationError == nil { + // RLP decoding works and validations pass (test OK) + return nil + } else { + // RLP decoding works and validations pass (test FAIL) + return errors.New("Field validations failed after RLP decoding") + } + } + return errors.New("Should not happen: verify RLP decoding and field validation") +} + +func verifyTxFields(txTest TransactionTest, decodedTx *types.Transaction) (err error) { + defer func() { + if recovered := recover(); recovered != nil { + buf := make([]byte, 64<<10) + buf = buf[:runtime.Stack(buf, false)] + err = fmt.Errorf("%v\n%s", recovered, buf) + } + }() + + decodedSender, err := decodedTx.From() if err != nil { return err } - if expectedSender != sender { - return fmt.Errorf("Sender mismatch: %v %v", expectedSender, sender) + expectedSender := mustConvertAddress(txTest.Sender) + if expectedSender != decodedSender { + return fmt.Errorf("Sender mismatch: %v %v", expectedSender, decodedSender) } - if !bytes.Equal(expectedData, tx.Payload) { - return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, tx.Payload) + + expectedData := mustConvertBytes(txTest.Transaction.Data) + if !bytes.Equal(expectedData, decodedTx.Payload) { + return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, decodedTx.Payload) } - if expectedGasLimit.Cmp(tx.GasLimit) != 0 { - return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, tx.GasLimit) + + expectedGasLimit := mustConvertBigInt(txTest.Transaction.GasLimit, 16) + if expectedGasLimit.Cmp(decodedTx.GasLimit) != 0 { + return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, decodedTx.GasLimit) } - if expectedGasPrice.Cmp(tx.Price) != 0 { - return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, tx.Price) + + expectedGasPrice := mustConvertBigInt(txTest.Transaction.GasPrice, 16) + if expectedGasPrice.Cmp(decodedTx.Price) != 0 { + return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, decodedTx.Price) } - if expectedNonce != tx.AccountNonce { - return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, tx.AccountNonce) + + expectedNonce := mustConvertUint(txTest.Transaction.Nonce, 16) + if expectedNonce != decodedTx.AccountNonce { + return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, decodedTx.AccountNonce) } - if expectedR.Cmp(tx.R) != 0 { - return fmt.Errorf("R mismatch: %v %v", expectedR, tx.R) + + expectedR := common.Bytes2Big(mustConvertBytes(txTest.Transaction.R)) + if expectedR.Cmp(decodedTx.R) != 0 { + return fmt.Errorf("R mismatch: %v %v", expectedR, decodedTx.R) } - if expectedS.Cmp(tx.S) != 0 { - return fmt.Errorf("S mismatch: %v %v", expectedS, tx.S) + + expectedS := common.Bytes2Big(mustConvertBytes(txTest.Transaction.S)) + if expectedS.Cmp(decodedTx.S) != 0 { + return fmt.Errorf("S mismatch: %v %v", expectedS, decodedTx.S) } - if expectedV != uint64(tx.V) { - return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(tx.V)) + + expectedV := mustConvertUint(txTest.Transaction.V, 16) + if expectedV != uint64(decodedTx.V) { + return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(decodedTx.V)) } - if tx.Recipient == nil { + + expectedTo := mustConvertAddress(txTest.Transaction.To) + if decodedTx.Recipient == nil { if expectedTo != common.BytesToAddress([]byte{}) { // "empty" or "zero" address return fmt.Errorf("To mismatch when recipient is nil (contract creation): %v", expectedTo) } } else { - if expectedTo != *tx.Recipient { - return fmt.Errorf("To mismatch: %v %v", expectedTo, *tx.Recipient) + if expectedTo != *decodedTx.Recipient { + return fmt.Errorf("To mismatch: %v %v", expectedTo, *decodedTx.Recipient) } } - if expectedValue.Cmp(tx.Amount) != 0 { - return fmt.Errorf("Value mismatch: %v %v", expectedValue, tx.Amount) + expectedValue := mustConvertBigInt(txTest.Transaction.Value, 16) + if expectedValue.Cmp(decodedTx.Amount) != 0 { + return fmt.Errorf("Value mismatch: %v %v", expectedValue, decodedTx.Amount) } return nil } - -func convertTestTypes(txTest TransactionTest) (sender, to common.Address, - txInputData, rlpBytes []byte, - gasLimit, gasPrice, value, r, s *big.Int, - nonce, v uint64, - err error) { - - defer func() { - if recovered := recover(); recovered != nil { - buf := make([]byte, 64<<10) - buf = buf[:runtime.Stack(buf, false)] - err = fmt.Errorf("%v\n%s", recovered, buf) - } - }() - - sender = mustConvertAddress(txTest.Sender) - to = mustConvertAddress(txTest.Transaction.To) - - txInputData = mustConvertBytes(txTest.Transaction.Data) - rlpBytes = mustConvertBytes(txTest.Rlp) - - gasLimit = mustConvertBigInt(txTest.Transaction.GasLimit, 16) - gasPrice = mustConvertBigInt(txTest.Transaction.GasPrice, 16) - value = mustConvertBigInt(txTest.Transaction.Value, 16) - - r = common.Bytes2Big(mustConvertBytes(txTest.Transaction.R)) - s = common.Bytes2Big(mustConvertBytes(txTest.Transaction.S)) - - nonce = mustConvertUint(txTest.Transaction.Nonce, 16) - v = mustConvertUint(txTest.Transaction.V, 16) - - return sender, to, txInputData, rlpBytes, gasLimit, gasPrice, value, r, s, nonce, v, nil -} -- cgit