headrush
/
go-ethereum
forked from mirror/go-ethereum
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'tests' into poc8

Browse Source
poc8
obscuren 10 years ago
parent f8d0cd9906 5c958ec5f6
commit 675ba4d7eb
29 changed files with 2277 additions and 742 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 25
      .travis.yml
  2. 8
      chain/filter_test.go
  3. 16
      chain/helper_test.go
  4. 3
      chain/types/bloom9_test.go
  5. 3
      cmd/ethereum/main.go
  6. 14
      cmd/ethereum/repl/repl_windows.go
  7. 201
      compression/rle/read_write_test.go
  8. 218
      crypto/keys_test.go
  9. 73
      ethutil/big_test.go
  10. 195
      ethutil/bytes_test.go
  11. 1
      ethutil/common.go
  12. 80
      ethutil/common_test.go
  13. 9
      ethutil/main_test.go
  14. 51
      ethutil/path_test.go
  15. 17
      ethutil/rand_test.go
  16. 23
      ethutil/size_test.go
  17. 86
      ethutil/value_test.go
  18. 40
      event/profile.tmp
  19. 29
      gocoverage.sh
  20. 8
      install_deps.sh
  21. 1102
      profile.cov
  22. 9
      state/main_test.go
  23. 67
      state/state_test.go
  24. 265
      tests/vm/gh_test.go
  25. 67
      trie/encoding_test.go
  26. 9
      trie/main_test.go
  27. 289
      trie/trie_test.go
  28. 9
      vm/main_test.go
  29. 102
      vm/vm_test.go

25
.travis.yml
Unescape View File

@ -1,4 +1,27 @@
before_install: sudo apt-get install libgmp3-dev
language: go language: go
go: go:
- 1.3 - 1.3
before_install:
- sudo add-apt-repository ppa:ubuntu-sdk-team/ppa -y
- sudo apt-get update -qq
- sudo apt-get install -yqq libgmp3-dev qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev libreadline6-dev
install:
- go get code.google.com/p/go.tools/cmd/goimports
- go get github.com/golang/lint/golint
# - go get code.google.com/p/go.tools/cmd/vet
- go get code.google.com/p/go.tools/cmd/cover
- go get github.com/mattn/goveralls
- ./install_deps.sh
before_script:
- gofmt -l -w .
- goimports -l -w .
- golint .
# - go vet ./...
# - go test -race ./...
script:
- ./gocoverage.sh
after_script:
- goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN
env:
- secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="

8
chain/filter_test.go
Unescape View File

@ -1,7 +1,7 @@
package chain package chain
import "testing" // import "testing"
func TestFilter(t *testing.T) { // func TestFilter(t *testing.T) {
NewFilter(NewTestManager()) // NewFilter(NewTestManager())
} // }

16
chain/helper_test.go
Unescape View File

@ -13,8 +13,8 @@ import (
// Implement our EthTest Manager // Implement our EthTest Manager
type TestManager struct { type TestManager struct {
stateManager *StateManager // stateManager *StateManager
eventMux *event.TypeMux eventMux *event.TypeMux
db ethutil.Database db ethutil.Database
txPool *TxPool txPool *TxPool
@ -46,9 +46,9 @@ func (tm *TestManager) TxPool() *TxPool {
return tm.txPool return tm.txPool
} }
func (tm *TestManager) StateManager() *StateManager { // func (tm *TestManager) StateManager() *StateManager {
return tm.stateManager // return tm.stateManager
} // }
func (tm *TestManager) EventMux() *event.TypeMux { func (tm *TestManager) EventMux() *event.TypeMux {
return tm.eventMux return tm.eventMux
@ -81,9 +81,9 @@ func NewTestManager() *TestManager {
testManager := &TestManager{} testManager := &TestManager{}
testManager.eventMux = new(event.TypeMux) testManager.eventMux = new(event.TypeMux)
testManager.db = db testManager.db = db
testManager.txPool = NewTxPool(testManager) // testManager.txPool = NewTxPool(testManager)
testManager.blockChain = NewChainManager(testManager) // testManager.blockChain = NewChainManager(testManager)
testManager.stateManager = NewStateManager(testManager) // testManager.stateManager = NewStateManager(testManager)
// Start the tx pool // Start the tx pool
testManager.txPool.Start() testManager.txPool.Start()

3
chain/types/bloom9_test.go
Unescape View File

@ -1,5 +1,6 @@
package types package types
/*
import ( import (
"testing" "testing"
@ -18,7 +19,7 @@ func TestBloom9(t *testing.T) {
} }
} }
/*
func TestAddress(t *testing.T) { func TestAddress(t *testing.T) {
block := &Block{} block := &Block{}
block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f") block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f")

3
cmd/ethereum/main.go
Unescape View File

@ -93,7 +93,8 @@ func main() {
os.Exit(1) os.Exit(1)
} }
fmt.Printf("RLP: %x\nstate: %x\nhash: %x\n", ethutil.Rlp(block), block.GetRoot(), block.Hash()) // block.GetRoot() does not exist
//fmt.Printf("RLP: %x\nstate: %x\nhash: %x\n", ethutil.Rlp(block), block.GetRoot(), block.Hash())
// Leave the Println. This needs clean output for piping // Leave the Println. This needs clean output for piping
fmt.Printf("%s\n", block.State().Dump()) fmt.Printf("%s\n", block.State().Dump())

14
cmd/ethereum/repl/repl_windows.go
Unescape View File

@ -32,7 +32,7 @@ func (self *JSRepl) read() {
if err != nil { if err != nil {
fmt.Println("Error reading input", err) fmt.Println("Error reading input", err)
} else { } else {
if (string(str) == "exit") { if string(str) == "exit" {
self.Stop() self.Stop()
break break
} else { } else {
@ -46,25 +46,25 @@ func addHistory(s string) {
} }
func printColored(outputVal string) { func printColored(outputVal string) {
for ; outputVal != "" ; { for outputVal != "" {
codePart := "" codePart := ""
if (strings.HasPrefix(outputVal, "\033[32m")) { if strings.HasPrefix(outputVal, "\033[32m") {
codePart = "\033[32m" codePart = "\033[32m"
changeColor(2) changeColor(2)
} }
if (strings.HasPrefix(outputVal, "\033[1m\033[30m")) { if strings.HasPrefix(outputVal, "\033[1m\033[30m") {
codePart = "\033[1m\033[30m" codePart = "\033[1m\033[30m"
changeColor(8) changeColor(8)
} }
if (strings.HasPrefix(outputVal, "\033[31m")) { if strings.HasPrefix(outputVal, "\033[31m") {
codePart = "\033[31m" codePart = "\033[31m"
changeColor(red) changeColor(red)
} }
if (strings.HasPrefix(outputVal, "\033[35m")) { if strings.HasPrefix(outputVal, "\033[35m") {
codePart = "\033[35m" codePart = "\033[35m"
changeColor(5) changeColor(5)
} }
if (strings.HasPrefix(outputVal, "\033[0m")) { if strings.HasPrefix(outputVal, "\033[0m") {
codePart = "\033[0m" codePart = "\033[0m"
resetColorful() resetColorful()
} }

201
compression/rle/read_write_test.go
Unescape View File

@ -1,115 +1,118 @@
package rle package rle
import ( import (
"bytes"
"testing" "testing"
"github.com/ethereum/go-ethereum/crypto" checker "gopkg.in/check.v1"
) )
func TestDecompressSimple(t *testing.T) { func Test(t *testing.T) { checker.TestingT(t) }
type CompressionRleSuite struct{}
var _ = checker.Suite(&CompressionRleSuite{})
func (s *CompressionRleSuite) TestDecompressSimple(c *checker.C) {
exp := []byte{0xc5, 0xd2, 0x46, 0x1, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x3, 0xc0, 0xe5, 0x0, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x4, 0x5d, 0x85, 0xa4, 0x70}
res, err := Decompress([]byte{token, 0xfd}) res, err := Decompress([]byte{token, 0xfd})
if err != nil { c.Assert(err, checker.IsNil)
t.Error(err) c.Assert(res, checker.DeepEquals, exp)
} // if bytes.Compare(res, exp) != 0 {
if bytes.Compare(res, crypto.Sha3([]byte(""))) != 0 { // t.Error("empty sha3", res)
t.Error("empty sha3", res) // }
}
exp = []byte{0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x1, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21}
res, err = Decompress([]byte{token, 0xfe}) res, err = Decompress([]byte{token, 0xfe})
if err != nil { c.Assert(err, checker.IsNil)
t.Error(err) c.Assert(res, checker.DeepEquals, exp)
} // if bytes.Compare(res, exp) != 0 {
if bytes.Compare(res, crypto.Sha3([]byte{0x80})) != 0 { // t.Error("0x80 sha3", res)
t.Error("0x80 sha3", res) // }
}
res, err = Decompress([]byte{token, 0xff}) res, err = Decompress([]byte{token, 0xff})
if err != nil { c.Assert(err, checker.IsNil)
t.Error(err) c.Assert(res, checker.DeepEquals, []byte{token})
} // if bytes.Compare(res, []byte{token}) != 0 {
if bytes.Compare(res, []byte{token}) != 0 { // t.Error("token", res)
t.Error("token", res) // }
}
res, err = Decompress([]byte{token, 12}) res, err = Decompress([]byte{token, 12})
if err != nil { c.Assert(err, checker.IsNil)
t.Error(err) c.Assert(res, checker.DeepEquals, make([]byte, 10))
} // if bytes.Compare(res, make([]byte, 10)) != 0 {
if bytes.Compare(res, make([]byte, 10)) != 0 { // t.Error("10 * zero", res)
t.Error("10 * zero", res) // }
}
}
func TestDecompressMulti(t *testing.T) {
res, err := Decompress([]byte{token, 0xfd, token, 0xfe, token, 12})
if err != nil {
t.Error(err)
}
var exp []byte
exp = append(exp, crypto.Sha3([]byte(""))...)
exp = append(exp, crypto.Sha3([]byte{0x80})...)
exp = append(exp, make([]byte, 10)...)
if bytes.Compare(res, res) != 0 {
t.Error("Expected", exp, "result", res)
}
}
func TestCompressSimple(t *testing.T) {
res := Compress([]byte{0, 0, 0, 0, 0})
if bytes.Compare(res, []byte{token, 7}) != 0 {
t.Error("5 * zero", res)
}
res = Compress(crypto.Sha3([]byte("")))
if bytes.Compare(res, []byte{token, emptyShaToken}) != 0 {
t.Error("empty sha", res)
}
res = Compress(crypto.Sha3([]byte{0x80}))
if bytes.Compare(res, []byte{token, emptyListShaToken}) != 0 {
t.Error("empty list sha", res)
}
res = Compress([]byte{token})
if bytes.Compare(res, []byte{token, tokenToken}) != 0 {
t.Error("token", res)
}
} }
func TestCompressMulti(t *testing.T) { // func TestDecompressMulti(t *testing.T) {
in := []byte{0, 0, 0, 0, 0} // res, err := Decompress([]byte{token, 0xfd, token, 0xfe, token, 12})
in = append(in, crypto.Sha3([]byte(""))...) // if err != nil {
in = append(in, crypto.Sha3([]byte{0x80})...) // t.Error(err)
in = append(in, token) // }
res := Compress(in)
// var exp []byte
exp := []byte{token, 7, token, emptyShaToken, token, emptyListShaToken, token, tokenToken} // exp = append(exp, crypto.Sha3([]byte(""))...)
if bytes.Compare(res, exp) != 0 { // exp = append(exp, crypto.Sha3([]byte{0x80})...)
t.Error("expected", exp, "got", res) // exp = append(exp, make([]byte, 10)...)
}
} // if bytes.Compare(res, res) != 0 {
// t.Error("Expected", exp, "result", res)
func TestCompressDecompress(t *testing.T) { // }
var in []byte // }
for i := 0; i < 20; i++ { // func TestCompressSimple(t *testing.T) {
in = append(in, []byte{0, 0, 0, 0, 0}...) // res := Compress([]byte{0, 0, 0, 0, 0})
in = append(in, crypto.Sha3([]byte(""))...) // if bytes.Compare(res, []byte{token, 7}) != 0 {
in = append(in, crypto.Sha3([]byte{0x80})...) // t.Error("5 * zero", res)
in = append(in, []byte{123, 2, 19, 89, 245, 254, 255, token, 98, 233}...) // }
in = append(in, token)
} // res = Compress(crypto.Sha3([]byte("")))
// if bytes.Compare(res, []byte{token, emptyShaToken}) != 0 {
c := Compress(in) // t.Error("empty sha", res)
d, err := Decompress(c) // }
if err != nil {
t.Error(err) // res = Compress(crypto.Sha3([]byte{0x80}))
} // if bytes.Compare(res, []byte{token, emptyListShaToken}) != 0 {
// t.Error("empty list sha", res)
if bytes.Compare(d, in) != 0 { // }
t.Error("multi failed\n", d, "\n", in)
} // res = Compress([]byte{token})
} // if bytes.Compare(res, []byte{token, tokenToken}) != 0 {
// t.Error("token", res)
// }
// }
// func TestCompressMulti(t *testing.T) {
// in := []byte{0, 0, 0, 0, 0}
// in = append(in, crypto.Sha3([]byte(""))...)
// in = append(in, crypto.Sha3([]byte{0x80})...)
// in = append(in, token)
// res := Compress(in)
// exp := []byte{token, 7, token, emptyShaToken, token, emptyListShaToken, token, tokenToken}
// if bytes.Compare(res, exp) != 0 {
// t.Error("expected", exp, "got", res)
// }
// }
// func TestCompressDecompress(t *testing.T) {
// var in []byte
// for i := 0; i < 20; i++ {
// in = append(in, []byte{0, 0, 0, 0, 0}...)
// in = append(in, crypto.Sha3([]byte(""))...)
// in = append(in, crypto.Sha3([]byte{0x80})...)
// in = append(in, []byte{123, 2, 19, 89, 245, 254, 255, token, 98, 233}...)
// in = append(in, token)
// }
// c := Compress(in)
// d, err := Decompress(c)
// if err != nil {
// t.Error(err)
// }
// if bytes.Compare(d, in) != 0 {
// t.Error("multi failed\n", d, "\n", in)
// }
// }

218
crypto/keys_test.go
Unescape View File

@ -1,122 +1,122 @@
package crypto package crypto
import ( // import (
"github.com/ethereum/go-ethereum/ethdb" // "github.com/ethereum/go-ethereum/ethdb"
// "io/ioutil" // // "io/ioutil"
"fmt" // "fmt"
"os" // "os"
"path" // "path"
"testing" // "testing"
) // )
// test if persistence layer works // // test if persistence layer works
func TestDBKeyManager(t *testing.T) { // func TestDBKeyManager(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase() // memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb) // keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false) // err := keyManager0.Init("", 0, false)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
keyManager1 := NewDBKeyManager(memdb) // keyManager1 := NewDBKeyManager(memdb)
err = keyManager1.Init("", 0, false) // err = keyManager1.Init("", 0, false)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) { // if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
} // }
err = keyManager1.Init("", 0, true) // err = keyManager1.Init("", 0, true)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) { // if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
} // }
} // }
func TestFileKeyManager(t *testing.T) { // func TestFileKeyManager(t *testing.T) {
basedir0 := "/tmp/ethtest0" // basedir0 := "/tmp/ethtest0"
os.RemoveAll(basedir0) // os.RemoveAll(basedir0)
os.Mkdir(basedir0, 0777) // os.Mkdir(basedir0, 0777)
keyManager0 := NewFileKeyManager(basedir0) // keyManager0 := NewFileKeyManager(basedir0)
err := keyManager0.Init("", 0, false) // err := keyManager0.Init("", 0, false)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
keyManager1 := NewFileKeyManager(basedir0) // keyManager1 := NewFileKeyManager(basedir0)
err = keyManager1.Init("", 0, false) // err = keyManager1.Init("", 0, false)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) { // if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
} // }
err = keyManager1.Init("", 0, true) // err = keyManager1.Init("", 0, true)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) { // if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
} // }
} // }
// cursor errors // // cursor errors
func TestCursorErrors(t *testing.T) { // func TestCursorErrors(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase() // memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb) // keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false) // err := keyManager0.Init("", 0, false)
err = keyManager0.Init("", 1, false) // err = keyManager0.Init("", 1, false)
if err == nil { // if err == nil {
t.Error("Expected cursor error") // t.Error("Expected cursor error")
} // }
err = keyManager0.SetCursor(1) // err = keyManager0.SetCursor(1)
if err == nil { // if err == nil {
t.Error("Expected cursor error") // t.Error("Expected cursor error")
} // }
} // }
func TestExportImport(t *testing.T) { // func TestExportImport(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase() // memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb) // keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false) // err := keyManager0.Init("", 0, false)
basedir0 := "/tmp/ethtest0" // basedir0 := "/tmp/ethtest0"
os.RemoveAll(basedir0) // os.RemoveAll(basedir0)
os.Mkdir(basedir0, 0777) // os.Mkdir(basedir0, 0777)
keyManager0.Export(basedir0) // keyManager0.Export(basedir0)
keyManager1 := NewFileKeyManager(basedir0) // keyManager1 := NewFileKeyManager(basedir0)
err = keyManager1.Init("", 0, false) // err = keyManager1.Init("", 0, false)
if err != nil { // if err != nil {
t.Error("Unexpected error: ", err) // t.Error("Unexpected error: ", err)
} // }
fmt.Printf("keyRing: %v\n", keyManager0.KeyPair()) // fmt.Printf("keyRing: %v\n", keyManager0.KeyPair())
fmt.Printf("keyRing: %v\n", keyManager1.KeyPair()) // fmt.Printf("keyRing: %v\n", keyManager1.KeyPair())
if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) { // if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be identical via export to filestore basedir", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // t.Error("Expected private keys %x, %x, to be identical via export to filestore basedir", keyManager0.PrivateKey(), keyManager1.PrivateKey())
} // }
path.Join("") // path.Join("")
// memdb, _ = ethdb.NewMemDatabase() // // memdb, _ = ethdb.NewMemDatabase()
// keyManager2 := NewDBKeyManager(memdb) // // keyManager2 := NewDBKeyManager(memdb)
// err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv")) // // err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv"))
// if err != nil { // // if err != nil {
// t.Error("Unexpected error: ", err) // // t.Error("Unexpected error: ", err)
// } // // }
// if string(keyManager0.PrivateKey()) != string(keyManager2.PrivateKey()) { // // if string(keyManager0.PrivateKey()) != string(keyManager2.PrivateKey()) {
// t.Error("Expected private keys %s, %s, to be identical via export/import prv", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // // t.Error("Expected private keys %s, %s, to be identical via export/import prv", keyManager0.PrivateKey(), keyManager1.PrivateKey())
// } // // }
// memdb, _ = ethdb.NewMemDatabase() // // memdb, _ = ethdb.NewMemDatabase()
// keyManager3 := NewDBKeyManager(memdb) // // keyManager3 := NewDBKeyManager(memdb)
// err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne")) // // err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne"))
// if err != nil { // // if err != nil {
// t.Error("Unexpected error: ", err) // // t.Error("Unexpected error: ", err)
// } // // }
// if string(keyManager0.PrivateKey()) != string(keyManager3.PrivateKey()) { // // if string(keyManager0.PrivateKey()) != string(keyManager3.PrivateKey()) {
// t.Error("Expected private keys %s, %s, to be identical via export/import mnemonic file", keyManager0.PrivateKey(), keyManager1.PrivateKey()) // // t.Error("Expected private keys %s, %s, to be identical via export/import mnemonic file", keyManager0.PrivateKey(), keyManager1.PrivateKey())
// } // // }
} // }

73
ethutil/big_test.go
Unescape View File

@ -0,0 +1,73 @@
package ethutil
import (
"bytes"
"testing"
)
func TestMisc(t *testing.T) {
a := Big("10")
b := Big("57896044618658097711785492504343953926634992332820282019728792003956564819968")
c := []byte{1, 2, 3, 4}
z := BitTest(a, 1)
if z != true {
t.Error("Expected true got", z)
}
U256(a)
S256(a)
U256(b)
S256(b)
BigD(c)
}
func TestBigMax(t *testing.T) {
a := Big("10")
b := Big("5")
max1 := BigMax(a, b)
if max1 != a {
t.Errorf("Expected %d got %d", a, max1)
}
max2 := BigMax(b, a)
if max2 != a {
t.Errorf("Expected %d got %d", a, max2)
}
}
func TestBigMin(t *testing.T) {
a := Big("10")
b := Big("5")
min1 := BigMin(a, b)
if min1 != b {
t.Errorf("Expected %d got %d", b, min1)
}
min2 := BigMin(b, a)
if min2 != b {
t.Errorf("Expected %d got %d", b, min2)
}
}
func TestBigCopy(t *testing.T) {
a := Big("10")
b := BigCopy(a)
c := Big("1000000000000")
y := BigToBytes(b, 16)
ybytes := []byte{0, 10}
z := BigToBytes(c, 16)
zbytes := []byte{232, 212, 165, 16, 0}
if bytes.Compare(y, ybytes) != 0 {
t.Error("Got", ybytes)
}
if bytes.Compare(z, zbytes) != 0 {
t.Error("Got", zbytes)
}
}

195
ethutil/bytes_test.go
Unescape View File

@ -1,14 +1,193 @@
package ethutil package ethutil
import ( import (
"bytes" checker "gopkg.in/check.v1"
"testing"
) )
func TestParseData(t *testing.T) { type BytesSuite struct{}
data := ParseData("hello", "world", "0x0106")
exp := "68656c6c6f000000000000000000000000000000000000000000000000000000776f726c640000000000000000000000000000000000000000000000000000000106000000000000000000000000000000000000000000000000000000000000" var _ = checker.Suite(&BytesSuite{})
if bytes.Compare(data, Hex2Bytes(exp)) != 0 {
t.Error("Error parsing data") func (s *BytesSuite) TestByteString(c *checker.C) {
} var data Bytes
data = []byte{102, 111, 111}
exp := "foo"
res := data.String()
c.Assert(res, checker.Equals, exp)
}
/*
func (s *BytesSuite) TestDeleteFromByteSlice(c *checker.C) {
data := []byte{1, 2, 3, 4}
slice := []byte{1, 2, 3, 4}
exp := []byte{1, 4}
res := DeleteFromByteSlice(data, slice)
c.Assert(res, checker.DeepEquals, exp)
}
*/
func (s *BytesSuite) TestNumberToBytes(c *checker.C) {
// data1 := int(1)
// res1 := NumberToBytes(data1, 16)
// c.Check(res1, checker.Panics)
var data2 float64 = 3.141592653
exp2 := []byte{0xe9, 0x38}
res2 := NumberToBytes(data2, 16)
c.Assert(res2, checker.DeepEquals, exp2)
}
func (s *BytesSuite) TestBytesToNumber(c *checker.C) {
datasmall := []byte{0xe9, 0x38, 0xe9, 0x38}
datalarge := []byte{0xe9, 0x38, 0xe9, 0x38, 0xe9, 0x38, 0xe9, 0x38}
var expsmall uint64 = 0xe938e938
var explarge uint64 = 0x0
ressmall := BytesToNumber(datasmall)
reslarge := BytesToNumber(datalarge)
c.Assert(ressmall, checker.Equals, expsmall)
c.Assert(reslarge, checker.Equals, explarge)
}
func (s *BytesSuite) TestReadVarInt(c *checker.C) {
data8 := []byte{1, 2, 3, 4, 5, 6, 7, 8}
data4 := []byte{1, 2, 3, 4}
data2 := []byte{1, 2}
data1 := []byte{1}
exp8 := uint64(72623859790382856)
exp4 := uint64(16909060)
exp2 := uint64(258)
exp1 := uint64(1)
res8 := ReadVarInt(data8)
res4 := ReadVarInt(data4)
res2 := ReadVarInt(data2)
res1 := ReadVarInt(data1)
c.Assert(res8, checker.Equals, exp8)
c.Assert(res4, checker.Equals, exp4)
c.Assert(res2, checker.Equals, exp2)
c.Assert(res1, checker.Equals, exp1)
}
func (s *BytesSuite) TestBinaryLength(c *checker.C) {
data1 := 0
data2 := 920987656789
exp1 := 0
exp2 := 5
res1 := BinaryLength(data1)
res2 := BinaryLength(data2)
c.Assert(res1, checker.Equals, exp1)
c.Assert(res2, checker.Equals, exp2)
}
func (s *BytesSuite) TestCopyBytes(c *checker.C) {
data1 := []byte{1, 2, 3, 4}
exp1 := []byte{1, 2, 3, 4}
res1 := CopyBytes(data1)
c.Assert(res1, checker.DeepEquals, exp1)
}
func (s *BytesSuite) TestIsHex(c *checker.C) {
data1 := "a9e67e"
exp1 := false
res1 := IsHex(data1)
c.Assert(res1, checker.DeepEquals, exp1)
data2 := "0xa9e67e00"
exp2 := true
res2 := IsHex(data2)
c.Assert(res2, checker.DeepEquals, exp2)
}
func (s *BytesSuite) TestParseDataString(c *checker.C) {
res1 := ParseData("hello", "world", "0x0106")
data := "68656c6c6f000000000000000000000000000000000000000000000000000000776f726c640000000000000000000000000000000000000000000000000000000106000000000000000000000000000000000000000000000000000000000000"
exp1 := Hex2Bytes(data)
c.Assert(res1, checker.DeepEquals, exp1)
}
func (s *BytesSuite) TestParseDataBytes(c *checker.C) {
data1 := []byte{232, 212, 165, 16, 0}
exp1 := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 212, 165, 16, 0}
res1 := ParseData(data1)
c.Assert(res1, checker.DeepEquals, exp1)
}
func (s *BytesSuite) TestLeftPadBytes(c *checker.C) {
val1 := []byte{1, 2, 3, 4}
exp1 := []byte{0, 0, 0, 0, 1, 2, 3, 4}
res1 := LeftPadBytes(val1, 8)
res2 := LeftPadBytes(val1, 2)
c.Assert(res1, checker.DeepEquals, exp1)
c.Assert(res2, checker.DeepEquals, val1)
}
func (s *BytesSuite) TestFormatData(c *checker.C) {
data1 := ""
data2 := "0xa9e67e00"
data3 := "a9e67e"
data4 := "\"a9e67e00\""
// exp1 := []byte{}
exp2 := []byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0xa9, 0xe6, 0x7e, 00}
exp3 := []byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00}
exp4 := []byte{0x61, 0x39, 0x65, 0x36, 0x37, 0x65, 0x30, 0x30, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00}
res1 := FormatData(data1)
res2 := FormatData(data2)
res3 := FormatData(data3)
res4 := FormatData(data4)
c.Assert(res1, checker.IsNil)
c.Assert(res2, checker.DeepEquals, exp2)
c.Assert(res3, checker.DeepEquals, exp3)
c.Assert(res4, checker.DeepEquals, exp4)
}
func (s *BytesSuite) TestRightPadBytes(c *checker.C) {
val := []byte{1, 2, 3, 4}
exp := []byte{1, 2, 3, 4, 0, 0, 0, 0}
resstd := RightPadBytes(val, 8)
resshrt := RightPadBytes(val, 2)
c.Assert(resstd, checker.DeepEquals, exp)
c.Assert(resshrt, checker.DeepEquals, val)
}
func (s *BytesSuite) TestLeftPadString(c *checker.C) {
val := "test"
exp := "\x30\x30\x30\x30" + val
resstd := LeftPadString(val, 8)
resshrt := LeftPadString(val, 2)
c.Assert(resstd, checker.Equals, exp)
c.Assert(resshrt, checker.Equals, val)
}
func (s *BytesSuite) TestRightPadString(c *checker.C) {
val := "test"
exp := val + "\x30\x30\x30\x30"
resstd := RightPadString(val, 8)
resshrt := RightPadString(val, 2)
c.Assert(resstd, checker.Equals, exp)
c.Assert(resshrt, checker.Equals, val)
} }

1
ethutil/common.go
Unescape View File

@ -66,6 +66,7 @@ func CurrencyToString(num *big.Int) string {
denom = "Ada" denom = "Ada"
} }
// TODO add comment clarifying expected behavior
if len(fin.String()) > 5 { if len(fin.String()) > 5 {
return fmt.Sprintf("%sE%d %s", fin.String()[0:5], len(fin.String())-5, denom) return fmt.Sprintf("%sE%d %s", fin.String()[0:5], len(fin.String())-5, denom)
} }

80
ethutil/common_test.go
Unescape View File

@ -2,43 +2,67 @@ package ethutil
import ( import (
"math/big" "math/big"
"testing" "os"
checker "gopkg.in/check.v1"
) )
func TestCommon(t *testing.T) { type CommonSuite struct{}
ether := CurrencyToString(BigPow(10, 19))
finney := CurrencyToString(BigPow(10, 16))
szabo := CurrencyToString(BigPow(10, 13))
vito := CurrencyToString(BigPow(10, 10))
turing := CurrencyToString(BigPow(10, 7))
eins := CurrencyToString(BigPow(10, 4))
wei := CurrencyToString(big.NewInt(10))
if ether != "10 Ether" { var _ = checker.Suite(&CommonSuite{})
t.Error("Got", ether)
}
if finney != "10 Finney" { func (s *CommonSuite) TestOS(c *checker.C) {
t.Error("Got", finney) expwin := (os.PathSeparator == '\\' && os.PathListSeparator == ';')
} res := IsWindows()
if szabo != "10 Szabo" { if !expwin {
t.Error("Got", szabo) c.Assert(res, checker.Equals, expwin, checker.Commentf("IsWindows is", res, "but path is", os.PathSeparator))
} else {
c.Assert(res, checker.Not(checker.Equals), expwin, checker.Commentf("IsWindows is", res, "but path is", os.PathSeparator))
} }
}
if vito != "10 Shannon" { func (s *CommonSuite) TestWindonziePath(c *checker.C) {
t.Error("Got", vito) iswindowspath := os.PathSeparator == '\\'
} path := "/opt/eth/test/file.ext"
res := WindonizePath(path)
ressep := string(res[0])
if turing != "10 Babbage" { if !iswindowspath {
t.Error("Got", turing) c.Assert(ressep, checker.Equals, "/")
} else {
c.Assert(ressep, checker.Not(checker.Equals), "/")
} }
}
if eins != "10 Ada" { func (s *CommonSuite) TestCommon(c *checker.C) {
t.Error("Got", eins) douglas := CurrencyToString(BigPow(10, 43))
} einstein := CurrencyToString(BigPow(10, 22))
ether := CurrencyToString(BigPow(10, 19))
finney := CurrencyToString(BigPow(10, 16))
szabo := CurrencyToString(BigPow(10, 13))
shannon := CurrencyToString(BigPow(10, 10))
babbage := CurrencyToString(BigPow(10, 7))
ada := CurrencyToString(BigPow(10, 4))
wei := CurrencyToString(big.NewInt(10))
if wei != "10 Wei" { c.Assert(douglas, checker.Equals, "10 Douglas")
t.Error("Got", wei) c.Assert(einstein, checker.Equals, "10 Einstein")
} c.Assert(ether, checker.Equals, "10 Ether")
c.Assert(finney, checker.Equals, "10 Finney")
c.Assert(szabo, checker.Equals, "10 Szabo")
c.Assert(shannon, checker.Equals, "10 Shannon")
c.Assert(babbage, checker.Equals, "10 Babbage")
c.Assert(ada, checker.Equals, "10 Ada")
c.Assert(wei, checker.Equals, "10 Wei")
}
func (s *CommonSuite) TestLarge(c *checker.C) {
douglaslarge := CurrencyToString(BigPow(100000000, 43))
adalarge := CurrencyToString(BigPow(100000000, 4))
weilarge := CurrencyToString(big.NewInt(100000000))
c.Assert(douglaslarge, checker.Equals, "10000E298 Douglas")
c.Assert(adalarge, checker.Equals, "10000E7 Einstein")
c.Assert(weilarge, checker.Equals, "100 Babbage")
} }

9
ethutil/main_test.go
Unescape View File

@ -0,0 +1,9 @@
package ethutil
import (
"testing"
checker "gopkg.in/check.v1"
)
func Test(t *testing.T) { checker.TestingT(t) }

51
ethutil/path_test.go
Unescape View File

@ -0,0 +1,51 @@
package ethutil
import (
// "os"
"testing"
)
func TestGoodFile(t *testing.T) {
goodpath := "~/goethereumtest.pass"
path := ExpandHomePath(goodpath)
contentstring := "3.14159265358979323846"
err := WriteFile(path, []byte(contentstring))
if err != nil {
t.Error("Could not write file")
}
if !FileExist(path) {
t.Error("File not found at", path)
}
v, err := ReadAllFile(path)
if err != nil {
t.Error("Could not read file", path)
}
if v != contentstring {
t.Error("Expected", contentstring, "Got", v)
}
}
func TestBadFile(t *testing.T) {
badpath := "/this/path/should/not/exist/goethereumtest.fail"
path := ExpandHomePath(badpath)
contentstring := "3.14159265358979323846"
err := WriteFile(path, []byte(contentstring))
if err == nil {
t.Error("Wrote file, but should not be able to", path)
}
if FileExist(path) {
t.Error("Found file, but should not be able to", path)
}
v, err := ReadAllFile(path)
if err == nil {
t.Error("Read file, but should not be able to", v)
}
}

17
ethutil/rand_test.go
Unescape View File

@ -0,0 +1,17 @@
package ethutil
import (
checker "gopkg.in/check.v1"
)
type RandomSuite struct{}
var _ = checker.Suite(&RandomSuite{})
func (s *RandomSuite) TestRandomUint64(c *checker.C) {
res1, _ := RandomUint64()
res2, _ := RandomUint64()
c.Assert(res1, checker.NotNil)
c.Assert(res2, checker.NotNil)
c.Assert(res1, checker.Not(checker.Equals), res2)
}

23
ethutil/size_test.go
Unescape View File

@ -1,12 +1,23 @@
package ethutil package ethutil
import ( import (
"fmt" checker "gopkg.in/check.v1"
"testing"
) )
func TestSize(t *testing.T) { type SizeSuite struct{}
fmt.Println(StorageSize(2381273))
fmt.Println(StorageSize(2192)) var _ = checker.Suite(&SizeSuite{})
fmt.Println(StorageSize(12))
func (s *SizeSuite) TestStorageSizeString(c *checker.C) {
data1 := 2381273
data2 := 2192
data3 := 12
exp1 := "2.38 mB"
exp2 := "2.19 kB"
exp3 := "12.00 B"
c.Assert(StorageSize(data1).String(), checker.Equals, exp1)
c.Assert(StorageSize(data2).String(), checker.Equals, exp2)
c.Assert(StorageSize(data3).String(), checker.Equals, exp3)
} }

86
ethutil/value_test.go
Unescape View File

@ -1,86 +1,70 @@
package ethutil package ethutil
import ( import (
"bytes"
"fmt"
"math/big" "math/big"
"testing"
checker "gopkg.in/check.v1"
) )
func TestValueCmp(t *testing.T) { type ValueSuite struct{}
var _ = checker.Suite(&ValueSuite{})
func (s *ValueSuite) TestValueCmp(c *checker.C) {
val1 := NewValue("hello") val1 := NewValue("hello")
val2 := NewValue("world") val2 := NewValue("world")
if val1.Cmp(val2) { c.Assert(val1.Cmp(val2), checker.Equals, false)
t.Error("Expected values not to be equal")
}
val3 := NewValue("hello") val3 := NewValue("hello")
val4 := NewValue("hello") val4 := NewValue("hello")
if !val3.Cmp(val4) { c.Assert(val3.Cmp(val4), checker.Equals, true)
t.Error("Expected values to be equal")
}
} }
func TestValueTypes(t *testing.T) { func (s *ValueSuite) TestValueTypes(c *checker.C) {
str := NewValue("str") str := NewValue("str")
num := NewValue(1) num := NewValue(1)
inter := NewValue([]interface{}{1}) inter := NewValue([]interface{}{1})
byt := NewValue([]byte{1, 2, 3, 4}) byt := NewValue([]byte{1, 2, 3, 4})
bigInt := NewValue(big.NewInt(10)) bigInt := NewValue(big.NewInt(10))
if str.Str() != "str" { strExp := "str"
t.Errorf("expected Str to return 'str', got %s", str.Str()) numExp := uint64(1)
}
if num.Uint() != 1 {
t.Errorf("expected Uint to return '1', got %d", num.Uint())
}
interExp := []interface{}{1} interExp := []interface{}{1}
if !NewValue(inter.Interface()).Cmp(NewValue(interExp)) {
t.Errorf("expected Interface to return '%v', got %v", interExp, num.Interface())
}
bytExp := []byte{1, 2, 3, 4} bytExp := []byte{1, 2, 3, 4}
if bytes.Compare(byt.Bytes(), bytExp) != 0 {
t.Errorf("expected Bytes to return '%v', got %v", bytExp, byt.Bytes())
}
bigExp := big.NewInt(10) bigExp := big.NewInt(10)
if bigInt.BigInt().Cmp(bigExp) != 0 {
t.Errorf("expected BigInt to return '%v', got %v", bigExp, bigInt.BigInt()) c.Assert(str.Str(), checker.Equals, strExp)
} c.Assert(num.Uint(), checker.Equals, numExp)
c.Assert(NewValue(inter.Interface()).Cmp(NewValue(interExp)), checker.Equals, true)
c.Assert(byt.Bytes(), checker.DeepEquals, bytExp)
c.Assert(bigInt.BigInt(), checker.DeepEquals, bigExp)
} }
func TestIterator(t *testing.T) { func (s *ValueSuite) TestIterator(c *checker.C) {
value := NewValue([]interface{}{1, 2, 3}) value := NewValue([]interface{}{1, 2, 3})
it := value.NewIterator() iter := value.NewIterator()
values := []uint64{1, 2, 3} values := []uint64{1, 2, 3}
i := 0 i := 0
for it.Next() { for iter.Next() {
if values[i] != it.Value().Uint() { c.Assert(values[i], checker.Equals, iter.Value().Uint())
t.Errorf("Expected %d, got %d", values[i], it.Value().Uint())
}
i++ i++
} }
} }
func TestMath(t *testing.T) { func (s *ValueSuite) TestMath(c *checker.C) {
a := NewValue(1) data1 := NewValue(1)
a.Add(1).Add(1) data1.Add(1).Add(1)
exp1 := NewValue(3)
if !a.DeepCmp(NewValue(3)) { data2 := NewValue(2)
t.Error("Expected 3, got", a) data2.Sub(1).Sub(1)
} exp2 := NewValue(0)
a = NewValue(2) c.Assert(data1.DeepCmp(exp1), checker.Equals, true)
a.Sub(1).Sub(1) c.Assert(data2.DeepCmp(exp2), checker.Equals, true)
if !a.DeepCmp(NewValue(0)) {
t.Error("Expected 0, got", a)
}
} }
func TestString(t *testing.T) { func (s *ValueSuite) TestString(c *checker.C) {
a := NewValue("10") data := "10"
fmt.Println("VALUE WITH STRING:", a.Int()) exp := int64(10)
c.Assert(NewValue(data).Int(), checker.DeepEquals, exp)
} }

40
event/profile.tmp
Unescape View File

@ -0,0 +1,40 @@
mode: count
github.com/ethereum/go-ethereum/event/event.go:41.66,45.17 4 1005
github.com/ethereum/go-ethereum/event/event.go:63.2,63.12 1 1004
github.com/ethereum/go-ethereum/event/event.go:45.17,47.3 1 1
github.com/ethereum/go-ethereum/event/event.go:47.3,48.22 1 1004
github.com/ethereum/go-ethereum/event/event.go:51.3,51.27 1 1004
github.com/ethereum/go-ethereum/event/event.go:48.22,50.4 1 5
github.com/ethereum/go-ethereum/event/event.go:51.27,54.32 3 1006
github.com/ethereum/go-ethereum/event/event.go:57.4,60.25 4 1005
github.com/ethereum/go-ethereum/event/event.go:54.32,56.5 1 1
github.com/ethereum/go-ethereum/event/event.go:68.48,71.17 3 3513
github.com/ethereum/go-ethereum/event/event.go:75.2,77.27 3 3511
github.com/ethereum/go-ethereum/event/event.go:80.2,80.12 1 3509
github.com/ethereum/go-ethereum/event/event.go:71.17,74.3 2 2
github.com/ethereum/go-ethereum/event/event.go:77.27,79.3 1 2576
github.com/ethereum/go-ethereum/event/event.go:86.28,88.32 2 5
github.com/ethereum/go-ethereum/event/event.go:93.2,95.20 3 5
github.com/ethereum/go-ethereum/event/event.go:88.32,89.28 1 3
github.com/ethereum/go-ethereum/event/event.go:89.28,91.4 1 3
github.com/ethereum/go-ethereum/event/event.go:98.36,100.34 2 1001
github.com/ethereum/go-ethereum/event/event.go:109.2,109.22 1 1001
github.com/ethereum/go-ethereum/event/event.go:100.34,101.37 1 1001
github.com/ethereum/go-ethereum/event/event.go:101.37,102.22 1 1001
github.com/ethereum/go-ethereum/event/event.go:102.22,104.5 1 2
github.com/ethereum/go-ethereum/event/event.go:104.5,106.5 1 999
github.com/ethereum/go-ethereum/event/event.go:112.46,113.26 1 2007
github.com/ethereum/go-ethereum/event/event.go:118.2,118.11 1 1005
github.com/ethereum/go-ethereum/event/event.go:113.26,114.16 1 181499
github.com/ethereum/go-ethereum/event/event.go:114.16,116.4 1 1002
github.com/ethereum/go-ethereum/event/event.go:121.52,126.2 4 999
github.com/ethereum/go-ethereum/event/event.go:142.35,150.2 2 1005
github.com/ethereum/go-ethereum/event/event.go:152.44,154.2 1 1003
github.com/ethereum/go-ethereum/event/event.go:156.32,159.2 2 1001
github.com/ethereum/go-ethereum/event/event.go:161.30,164.14 3 1004
github.com/ethereum/go-ethereum/event/event.go:167.2,173.19 6 1003
github.com/ethereum/go-ethereum/event/event.go:164.14,166.3 1 1
github.com/ethereum/go-ethereum/event/event.go:176.42,178.9 2 2575
github.com/ethereum/go-ethereum/event/event.go:182.2,182.20 1 2575
github.com/ethereum/go-ethereum/event/event.go:179.2,179.21 0 1004
github.com/ethereum/go-ethereum/event/event.go:180.2,180.19 0 1571

29
gocoverage.sh
Unescape View File

@ -0,0 +1,29 @@
#!/bin/bash
# The script does automatic checking on a Go package and its sub-packages, including:
# 6. test coverage (http://blog.golang.org/cover)
set -e
# Run test coverage on each subdirectories and merge the coverage profile.
echo "mode: count" > profile.cov
# Standard go tooling behavior is to ignore dirs with leading underscors
for dir in $(find . -maxdepth 10 -not -path './.git*' -not -path '*/_*' -type d);
do
if ls $dir/*.go &> /dev/null; then
# echo $dir
go test -covermode=count -coverprofile=$dir/profile.tmp $dir
if [ -f $dir/profile.tmp ]
then
cat $dir/profile.tmp | tail -n +2 >> profile.cov
rm $dir/profile.tmp
fi
fi
done
go tool cover -func profile.cov
# To submit the test coverage result to coveralls.io,
# use goveralls (https://github.com/mattn/goveralls)
# goveralls -coverprofile=profile.cov -service=travis-ci

8
install_deps.sh
Unescape View File

@ -0,0 +1,8 @@
#!/bin/bash
set -e
TEST_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g')
if [ "$TEST_DEPS" ]; then
go get -race $TEST_DEPS
fi

1102
profile.cov
View File

File diff suppressed because it is too large Load Diff

9
state/main_test.go
Unescape View File

@ -0,0 +1,9 @@
package state
import (
"testing"
checker "gopkg.in/check.v1"
)
func Test(t *testing.T) { checker.TestingT(t) }

67
state/state_test.go
Unescape View File

@ -1,36 +1,61 @@
package state package state
import ( import (
"testing" checker "gopkg.in/check.v1"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie"
) )
var ZeroHash256 = make([]byte, 32) type StateSuite struct {
state *State
func TestSnapshot(t *testing.T) { }
db, _ := ethdb.NewMemDatabase()
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
ethutil.Config.Db = db
state := New(trie.New(db, ""))
stateObject := state.GetOrNewStateObject([]byte("aa"))
stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(42)) var _ = checker.Suite(&StateSuite{})
snapshot := state.Copy() // var ZeroHash256 = make([]byte, 32)
stateObject = state.GetStateObject([]byte("aa")) func (s *StateSuite) TestDump(c *checker.C) {
stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(43)) key := []byte{0x01}
value := "foo"
node := []interface{}{key, value}
s.state.Trie.Put(node)
dump := s.state.Dump()
c.Assert(dump, checker.NotNil)
}
state.Set(snapshot) func (s *StateSuite) SetUpTest(c *checker.C) {
db, _ := ethdb.NewMemDatabase()
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
ethutil.Config.Db = db
s.state = New(trie.New(db, ""))
}
stateObject = state.GetStateObject([]byte("aa")) func (s *StateSuite) TestSnapshot(c *checker.C) {
res := stateObject.GetStorage(ethutil.Big("0")) stateobjaddr := []byte("aa")
if !res.Cmp(ethutil.NewValue(42)) { storageaddr := ethutil.Big("0")
t.Error("Expected storage 0 to be 42", res) data1 := ethutil.NewValue(42)
} data2 := ethutil.NewValue(43)
// get state object
stateObject := s.state.GetOrNewStateObject(stateobjaddr)
// set inital state object value
stateObject.SetStorage(storageaddr, data1)
// get snapshot of current state
snapshot := s.state.Copy()
// get state object. is this strictly necessary?
stateObject = s.state.GetStateObject(stateobjaddr)
// set new state object value
stateObject.SetStorage(storageaddr, data2)
// restore snapshot
s.state.Set(snapshot)
// get state object
stateObject = s.state.GetStateObject(stateobjaddr)
// get state storage value
res := stateObject.GetStorage(storageaddr)
c.Assert(data1, checker.DeepEquals, res)
} }

265
tests/vm/gh_test.go
Unescape View File

@ -1,134 +1,135 @@
package vm package vm
import ( // import (
"bytes" // "bytes"
"testing" // "testing"
"github.com/ethereum/go-ethereum/ethutil" // "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state" // "github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/tests/helper" // "github.com/ethereum/go-ethereum/tests/helper"
) // )
type Account struct { // type Account struct {
Balance string // Balance string
Code string // Code string
Nonce string // Nonce string
Storage map[string]string // Storage map[string]string
} // }
func StateObjectFromAccount(addr string, account Account) *state.StateObject { // func StateObjectFromAccount(addr string, account Account) *state.StateObject {
obj := state.NewStateObject(ethutil.Hex2Bytes(addr)) // obj := state.NewStateObject(ethutil.Hex2Bytes(addr))
obj.SetBalance(ethutil.Big(account.Balance)) // obj.SetBalance(ethutil.Big(account.Balance))
if ethutil.IsHex(account.Code) { // if ethutil.IsHex(account.Code) {
account.Code = account.Code[2:] // account.Code = account.Code[2:]
} // }
obj.Code = ethutil.Hex2Bytes(account.Code) // obj.Code = ethutil.Hex2Bytes(account.Code)
obj.Nonce = ethutil.Big(account.Nonce).Uint64() // obj.Nonce = ethutil.Big(account.Nonce).Uint64()
return obj // return obj
} // }
type VmTest struct { // type VmTest struct {
Callcreates interface{} // Callcreates interface{}
Env map[string]string // Env map[string]string
Exec map[string]string // Exec map[string]string
Gas string // Gas string
Out string // Out string
Post map[string]Account // Post map[string]Account
Pre map[string]Account // Pre map[string]Account
} // }
func RunVmTest(p string, t *testing.T) { // func RunVmTest(p string, t *testing.T) {
tests := make(map[string]VmTest) // tests := make(map[string]VmTest)
helper.CreateFileTests(t, p, &tests) // helper.CreateFileTests(t, p, &tests)
for name, test := range tests { // for name, test := range tests {
state := state.New(helper.NewTrie()) // state := state.New(helper.NewTrie())
for addr, account := range test.Pre { // for addr, account := range test.Pre {
obj := StateObjectFromAccount(addr, account) // obj := StateObjectFromAccount(addr, account)
state.SetStateObject(obj) // state.SetStateObject(obj)
} // }
ret, gas, err := helper.RunVm(state, test.Env, test.Exec) // ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
// When an error is returned it doesn't always mean the tests fails. // // When an error is returned it doesn't always mean the tests fails.
// Have to come up with some conditional failing mechanism. // // Have to come up with some conditional failing mechanism.
if err != nil { // if err != nil {
helper.Log.Infoln(err) // t.Errorf("%s", err)
} // helper.Log.Infoln(err)
// }
rexp := helper.FromHex(test.Out)
if bytes.Compare(rexp, ret) != 0 { // rexp := helper.FromHex(test.Out)
t.Errorf("%s's return failed. Expected %x, got %x\n", name, rexp, ret) // if bytes.Compare(rexp, ret) != 0 {
} // t.Errorf("%s's return failed. Expected %x, got %x\n", name, rexp, ret)
// }
gexp := ethutil.Big(test.Gas)
if gexp.Cmp(gas) != 0 { // gexp := ethutil.Big(test.Gas)
t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas) // if gexp.Cmp(gas) != 0 {
} // t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas)
// }
for addr, account := range test.Post {
obj := state.GetStateObject(helper.FromHex(addr)) // for addr, account := range test.Post {
for addr, value := range account.Storage { // obj := state.GetStateObject(helper.FromHex(addr))
v := obj.GetState(helper.FromHex(addr)).Bytes() // for addr, value := range account.Storage {
vexp := helper.FromHex(value) // v := obj.GetState(helper.FromHex(addr)).Bytes()
// vexp := helper.FromHex(value)
if bytes.Compare(v, vexp) != 0 {
t.Errorf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v)) // if bytes.Compare(v, vexp) != 0 {
} // t.Errorf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v))
} // }
} // }
} // }
} // }
// }
// I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
func TestVMArithmetic(t *testing.T) { // // I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
//helper.Logger.SetLogLevel(5) // func TestVMArithmetic(t *testing.T) {
const fn = "../files/vmtests/vmArithmeticTest.json" // //helper.Logger.SetLogLevel(5)
RunVmTest(fn, t) // const fn = "../files/vmtests/vmArithmeticTest.json"
} // RunVmTest(fn, t)
// }
/*
deleted? // /*
func TestVMSystemOperation(t *testing.T) { // deleted?
helper.Logger.SetLogLevel(5) // func TestVMSystemOperation(t *testing.T) {
const fn = "../files/vmtests/vmSystemOperationsTest.json" // helper.Logger.SetLogLevel(5)
RunVmTest(fn, t) // const fn = "../files/vmtests/vmSystemOperationsTest.json"
} // RunVmTest(fn, t)
*/ // }
// */
func TestBitwiseLogicOperation(t *testing.T) {
const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json" // func TestBitwiseLogicOperation(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
} // RunVmTest(fn, t)
// }
func TestBlockInfo(t *testing.T) {
const fn = "../files/vmtests/vmBlockInfoTest.json" // func TestBlockInfo(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmBlockInfoTest.json"
} // RunVmTest(fn, t)
// }
func TestEnvironmentalInfo(t *testing.T) {
const fn = "../files/vmtests/vmEnvironmentalInfoTest.json" // func TestEnvironmentalInfo(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
} // RunVmTest(fn, t)
// }
func TestFlowOperation(t *testing.T) {
helper.Logger.SetLogLevel(5) // func TestFlowOperation(t *testing.T) {
const fn = "../files/vmtests/vmIOandFlowOperationsTest.json" // helper.Logger.SetLogLevel(5)
RunVmTest(fn, t) // const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
} // RunVmTest(fn, t)
// }
func TestPushDupSwap(t *testing.T) {
const fn = "../files/vmtests/vmPushDupSwapTest.json" // func TestPushDupSwap(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmPushDupSwapTest.json"
} // RunVmTest(fn, t)
// }
func TestVMSha3(t *testing.T) {
const fn = "../files/vmtests/vmSha3Test.json" // func TestVMSha3(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmSha3Test.json"
} // RunVmTest(fn, t)
// }
func TestVm(t *testing.T) {
const fn = "../files/vmtests/vmtests.json" // func TestVm(t *testing.T) {
RunVmTest(fn, t) // const fn = "../files/vmtests/vmtests.json"
} // RunVmTest(fn, t)
// }

67
trie/encoding_test.go
Unescape View File

@ -1,68 +1,59 @@
package trie package trie
import ( import (
"bytes" checker "gopkg.in/check.v1"
"fmt"
"testing"
) )
func TestCompactEncode(t *testing.T) { type TrieEncodingSuite struct{}
var _ = checker.Suite(&TrieEncodingSuite{})
func (s *TrieEncodingSuite) TestCompactEncode(c *checker.C) {
// even compact encode
test1 := []byte{1, 2, 3, 4, 5} test1 := []byte{1, 2, 3, 4, 5}
if res := CompactEncode(test1); res != "\x11\x23\x45" { res1 := CompactEncode(test1)
t.Error(fmt.Sprintf("even compact encode failed. Got: %q", res)) c.Assert(res1, checker.Equals, "\x11\x23\x45")
}
// odd compact encode
test2 := []byte{0, 1, 2, 3, 4, 5} test2 := []byte{0, 1, 2, 3, 4, 5}
if res := CompactEncode(test2); res != "\x00\x01\x23\x45" { res2 := CompactEncode(test2)
t.Error(fmt.Sprintf("odd compact encode failed. Got: %q", res)) c.Assert(res2, checker.Equals, "\x00\x01\x23\x45")
}
//odd terminated compact encode
test3 := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16} test3 := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
if res := CompactEncode(test3); res != "\x20\x0f\x1c\xb8" { res3 := CompactEncode(test3)
t.Error(fmt.Sprintf("odd terminated compact encode failed. Got: %q", res)) c.Assert(res3, checker.Equals, "\x20\x0f\x1c\xb8")
}
// even terminated compact encode
test4 := []byte{15, 1, 12, 11, 8 /*term*/, 16} test4 := []byte{15, 1, 12, 11, 8 /*term*/, 16}
if res := CompactEncode(test4); res != "\x3f\x1c\xb8" { res4 := CompactEncode(test4)
t.Error(fmt.Sprintf("even terminated compact encode failed. Got: %q", res)) c.Assert(res4, checker.Equals, "\x3f\x1c\xb8")
}
} }
func TestCompactHexDecode(t *testing.T) { func (s *TrieEncodingSuite) TestCompactHexDecode(c *checker.C) {
exp := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16} exp := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
res := CompactHexDecode("verb") res := CompactHexDecode("verb")
c.Assert(res, checker.DeepEquals, exp)
if !bytes.Equal(res, exp) {
t.Error("Error compact hex decode. Expected", exp, "got", res)
}
} }
func TestCompactDecode(t *testing.T) { func (s *TrieEncodingSuite) TestCompactDecode(c *checker.C) {
// odd compact decode
exp := []byte{1, 2, 3, 4, 5} exp := []byte{1, 2, 3, 4, 5}
res := CompactDecode("\x11\x23\x45") res := CompactDecode("\x11\x23\x45")
c.Assert(res, checker.DeepEquals, exp)
if !bytes.Equal(res, exp) { // even compact decode
t.Error("odd compact decode. Expected", exp, "got", res)
}
exp = []byte{0, 1, 2, 3, 4, 5} exp = []byte{0, 1, 2, 3, 4, 5}
res = CompactDecode("\x00\x01\x23\x45") res = CompactDecode("\x00\x01\x23\x45")
c.Assert(res, checker.DeepEquals, exp)
if !bytes.Equal(res, exp) { // even terminated compact decode
t.Error("even compact decode. Expected", exp, "got", res)
}
exp = []byte{0, 15, 1, 12, 11, 8 /*term*/, 16} exp = []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
res = CompactDecode("\x20\x0f\x1c\xb8") res = CompactDecode("\x20\x0f\x1c\xb8")
c.Assert(res, checker.DeepEquals, exp)
if !bytes.Equal(res, exp) { // even terminated compact decode
t.Error("even terminated compact decode. Expected", exp, "got", res)
}
exp = []byte{15, 1, 12, 11, 8 /*term*/, 16} exp = []byte{15, 1, 12, 11, 8 /*term*/, 16}
res = CompactDecode("\x3f\x1c\xb8") res = CompactDecode("\x3f\x1c\xb8")
c.Assert(res, checker.DeepEquals, exp)
if !bytes.Equal(res, exp) {
t.Error("even terminated compact decode. Expected", exp, "got", res)
}
} }

9
trie/main_test.go
Unescape View File

@ -0,0 +1,9 @@
package trie
import (
"testing"
checker "gopkg.in/check.v1"
)
func Test(t *testing.T) { checker.TestingT(t) }

289
trie/trie_test.go
Unescape View File

@ -1,22 +1,26 @@
package trie package trie
import ( import (
"bytes"
"encoding/hex" "encoding/hex"
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"math/rand" "math/rand"
"net/http" "net/http"
"reflect"
"testing"
"time" "time"
checker "gopkg.in/check.v1"
"github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/ethutil"
) )
const LONG_WORD = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ" const LONG_WORD = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ"
type TrieSuite struct {
db *MemDatabase
trie *Trie
}
type MemDatabase struct { type MemDatabase struct {
db map[string][]byte db map[string][]byte
} }
@ -44,142 +48,97 @@ func NewTrie() (*MemDatabase, *Trie) {
return db, New(db, "") return db, New(db, "")
} }
func TestTrieSync(t *testing.T) { func (s *TrieSuite) SetUpTest(c *checker.C) {
db, trie := NewTrie() s.db, s.trie = NewTrie()
trie.Update("dog", LONG_WORD)
if len(db.db) != 0 {
t.Error("Expected no data in database")
}
trie.Sync()
if len(db.db) == 0 {
t.Error("Expected data to be persisted")
}
} }
func TestTrieDirtyTracking(t *testing.T) { func (s *TrieSuite) TestTrieSync(c *checker.C) {
_, trie := NewTrie() s.trie.Update("dog", LONG_WORD)
trie.Update("dog", LONG_WORD) c.Assert(s.db.db, checker.HasLen, 0, checker.Commentf("Expected no data in database"))
if !trie.cache.IsDirty { s.trie.Sync()
t.Error("Expected trie to be dirty") c.Assert(s.db.db, checker.HasLen, 3)
} }
trie.Sync() func (s *TrieSuite) TestTrieDirtyTracking(c *checker.C) {
if trie.cache.IsDirty { s.trie.Update("dog", LONG_WORD)
t.Error("Expected trie not to be dirty") c.Assert(s.trie.cache.IsDirty, checker.Equals, true, checker.Commentf("Expected no data in database"))
}
trie.Update("test", LONG_WORD) s.trie.Sync()
trie.cache.Undo() c.Assert(s.trie.cache.IsDirty, checker.Equals, false, checker.Commentf("Expected trie to be dirty"))
if trie.cache.IsDirty {
t.Error("Expected trie not to be dirty")
}
s.trie.Update("test", LONG_WORD)
s.trie.cache.Undo()
c.Assert(s.trie.cache.IsDirty, checker.Equals, false)
} }
func TestTrieReset(t *testing.T) { func (s *TrieSuite) TestTrieReset(c *checker.C) {
_, trie := NewTrie() s.trie.Update("cat", LONG_WORD)
c.Assert(s.trie.cache.nodes, checker.HasLen, 1, checker.Commentf("Expected cached nodes"))
trie.Update("cat", LONG_WORD) s.trie.cache.Undo()
if len(trie.cache.nodes) == 0 { c.Assert(s.trie.cache.nodes, checker.HasLen, 0, checker.Commentf("Expected no nodes after undo"))
t.Error("Expected cached nodes")
}
trie.cache.Undo()
if len(trie.cache.nodes) != 0 {
t.Error("Expected no nodes after undo", len(trie.cache.nodes))
}
} }
func TestTrieGet(t *testing.T) { func (s *TrieSuite) TestTrieGet(c *checker.C) {
_, trie := NewTrie() s.trie.Update("cat", LONG_WORD)
x := s.trie.Get("cat")
trie.Update("cat", LONG_WORD) c.Assert(x, checker.DeepEquals, LONG_WORD)
x := trie.Get("cat")
if x != LONG_WORD {
t.Error("expected %s, got %s", LONG_WORD, x)
}
} }
func TestTrieUpdating(t *testing.T) { func (s *TrieSuite) TestTrieUpdating(c *checker.C) {
_, trie := NewTrie() s.trie.Update("cat", LONG_WORD)
trie.Update("cat", LONG_WORD) s.trie.Update("cat", LONG_WORD+"1")
trie.Update("cat", LONG_WORD+"1") x := s.trie.Get("cat")
x := trie.Get("cat") c.Assert(x, checker.DeepEquals, LONG_WORD+"1")
if x != LONG_WORD+"1" {
t.Error("expected %S, got %s", LONG_WORD+"1", x)
}
} }
func TestTrieCmp(t *testing.T) { func (s *TrieSuite) TestTrieCmp(c *checker.C) {
_, trie1 := NewTrie() _, trie1 := NewTrie()
_, trie2 := NewTrie() _, trie2 := NewTrie()
trie1.Update("doge", LONG_WORD) trie1.Update("doge", LONG_WORD)
trie2.Update("doge", LONG_WORD) trie2.Update("doge", LONG_WORD)
if !trie1.Cmp(trie2) { c.Assert(trie1, checker.DeepEquals, trie2)
t.Error("Expected tries to be equal")
}
trie1.Update("dog", LONG_WORD) trie1.Update("dog", LONG_WORD)
trie2.Update("cat", LONG_WORD) trie2.Update("cat", LONG_WORD)
if trie1.Cmp(trie2) { c.Assert(trie1, checker.Not(checker.DeepEquals), trie2)
t.Errorf("Expected tries not to be equal %x %x", trie1.Root, trie2.Root)
}
} }
func TestTrieDelete(t *testing.T) { func (s *TrieSuite) TestTrieDelete(c *checker.C) {
t.Skip() s.trie.Update("cat", LONG_WORD)
_, trie := NewTrie() exp := s.trie.Root
trie.Update("cat", LONG_WORD) s.trie.Update("dog", LONG_WORD)
exp := trie.Root s.trie.Delete("dog")
trie.Update("dog", LONG_WORD) c.Assert(s.trie.Root, checker.DeepEquals, exp)
trie.Delete("dog")
if !reflect.DeepEqual(exp, trie.Root) { s.trie.Update("dog", LONG_WORD)
t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root) exp = s.trie.Root
} s.trie.Update("dude", LONG_WORD)
s.trie.Delete("dude")
trie.Update("dog", LONG_WORD) c.Assert(s.trie.Root, checker.DeepEquals, exp)
exp = trie.Root
trie.Update("dude", LONG_WORD)
trie.Delete("dude")
if !reflect.DeepEqual(exp, trie.Root) {
t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
}
} }
func TestTrieDeleteWithValue(t *testing.T) { func (s *TrieSuite) TestTrieDeleteWithValue(c *checker.C) {
t.Skip() s.trie.Update("c", LONG_WORD)
_, trie := NewTrie() exp := s.trie.Root
trie.Update("c", LONG_WORD) s.trie.Update("ca", LONG_WORD)
exp := trie.Root s.trie.Update("cat", LONG_WORD)
trie.Update("ca", LONG_WORD) s.trie.Delete("ca")
trie.Update("cat", LONG_WORD) s.trie.Delete("cat")
trie.Delete("ca") c.Assert(s.trie.Root, checker.DeepEquals, exp)
trie.Delete("cat")
if !reflect.DeepEqual(exp, trie.Root) {
t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
}
} }
func TestTriePurge(t *testing.T) { func (s *TrieSuite) TestTriePurge(c *checker.C) {
_, trie := NewTrie() s.trie.Update("c", LONG_WORD)
trie.Update("c", LONG_WORD) s.trie.Update("ca", LONG_WORD)
trie.Update("ca", LONG_WORD) s.trie.Update("cat", LONG_WORD)
trie.Update("cat", LONG_WORD)
lenBefore := len(trie.cache.nodes)
it := trie.NewIterator()
if num := it.Purge(); num != 3 {
t.Errorf("Expected purge to return 3, got %d", num)
}
if lenBefore == len(trie.cache.nodes) { lenBefore := len(s.trie.cache.nodes)
t.Errorf("Expected cached nodes to be deleted") it := s.trie.NewIterator()
} num := it.Purge()
c.Assert(num, checker.Equals, 3)
c.Assert(len(s.trie.cache.nodes), checker.Equals, lenBefore)
} }
func h(str string) string { func h(str string) string {
@ -201,23 +160,23 @@ func get(in string) (out string) {
return return
} }
type Test struct { type TrieTest struct {
Name string Name string
In map[string]string In map[string]string
Root string Root string
} }
func CreateTest(name string, data []byte) (Test, error) { func CreateTest(name string, data []byte) (TrieTest, error) {
t := Test{Name: name} t := TrieTest{Name: name}
err := json.Unmarshal(data, &t) err := json.Unmarshal(data, &t)
if err != nil { if err != nil {
return Test{}, fmt.Errorf("%v", err) return TrieTest{}, fmt.Errorf("%v", err)
} }
return t, nil return t, nil
} }
func CreateTests(uri string, cb func(Test)) map[string]Test { func CreateTests(uri string, cb func(TrieTest)) map[string]TrieTest {
resp, err := http.Get(uri) resp, err := http.Get(uri)
if err != nil { if err != nil {
panic(err) panic(err)
@ -232,7 +191,7 @@ func CreateTests(uri string, cb func(Test)) map[string]Test {
panic(err) panic(err)
} }
tests := make(map[string]Test) tests := make(map[string]TrieTest)
for name, testData := range objmap { for name, testData := range objmap {
test, err := CreateTest(name, *testData) test, err := CreateTest(name, *testData)
if err != nil { if err != nil {
@ -276,7 +235,7 @@ func RandomData() [][]string {
const MaxTest = 1000 const MaxTest = 1000
// This test insert data in random order and seeks to find indifferences between the different tries // This test insert data in random order and seeks to find indifferences between the different tries
func TestRegression(t *testing.T) { func (s *TrieSuite) TestRegression(c *checker.C) {
rand.Seed(time.Now().Unix()) rand.Seed(time.Now().Unix())
roots := make(map[string]int) roots := make(map[string]int)
@ -292,34 +251,33 @@ func TestRegression(t *testing.T) {
roots[string(trie.Root.([]byte))] += 1 roots[string(trie.Root.([]byte))] += 1
} }
if len(roots) > 1 { c.Assert(len(roots) <= 1, checker.Equals, true)
for root, num := range roots { // if len(roots) > 1 {
t.Errorf("%x => %d\n", root, num) // for root, num := range roots {
} // t.Errorf("%x => %d\n", root, num)
} // }
// }
} }
func TestDelete(t *testing.T) { func (s *TrieSuite) TestDelete(c *checker.C) {
_, trie := NewTrie() s.trie.Update("a", "jeffreytestlongstring")
s.trie.Update("aa", "otherstring")
trie.Update("a", "jeffreytestlongstring") s.trie.Update("aaa", "othermorestring")
trie.Update("aa", "otherstring") s.trie.Update("aabbbbccc", "hithere")
trie.Update("aaa", "othermorestring") s.trie.Update("abbcccdd", "hstanoehutnaheoustnh")
trie.Update("aabbbbccc", "hithere") s.trie.Update("rnthaoeuabbcccdd", "hstanoehutnaheoustnh")
trie.Update("abbcccdd", "hstanoehutnaheoustnh") s.trie.Update("rneuabbcccdd", "hstanoehutnaheoustnh")
trie.Update("rnthaoeuabbcccdd", "hstanoehutnaheoustnh") s.trie.Update("rneuabboeusntahoeucccdd", "hstanoehutnaheoustnh")
trie.Update("rneuabbcccdd", "hstanoehutnaheoustnh") s.trie.Update("rnxabboeusntahoeucccdd", "hstanoehutnaheoustnh")
trie.Update("rneuabboeusntahoeucccdd", "hstanoehutnaheoustnh") s.trie.Delete("aaboaestnuhbccc")
trie.Update("rnxabboeusntahoeucccdd", "hstanoehutnaheoustnh") s.trie.Delete("a")
trie.Delete("aaboaestnuhbccc") s.trie.Update("a", "nthaonethaosentuh")
trie.Delete("a") s.trie.Update("c", "shtaosntehua")
trie.Update("a", "nthaonethaosentuh") s.trie.Delete("a")
trie.Update("c", "shtaosntehua") s.trie.Update("aaaa", "testmegood")
trie.Delete("a")
trie.Update("aaaa", "testmegood")
_, t2 := NewTrie() _, t2 := NewTrie()
trie.NewIterator().Each(func(key string, v *ethutil.Value) { s.trie.NewIterator().Each(func(key string, v *ethutil.Value) {
if key == "aaaa" { if key == "aaaa" {
t2.Update(key, v.Str()) t2.Update(key, v.Str())
} else { } else {
@ -327,27 +285,22 @@ func TestDelete(t *testing.T) {
} }
}) })
a := ethutil.NewValue(trie.Root).Bytes() a := ethutil.NewValue(s.trie.Root).Bytes()
b := ethutil.NewValue(t2.Root).Bytes() b := ethutil.NewValue(t2.Root).Bytes()
if bytes.Compare(a, b) != 0 { c.Assert(a, checker.DeepEquals, b)
t.Errorf("Expected %x and %x to be equal", a, b)
}
} }
func TestTerminator(t *testing.T) { func (s *TrieSuite) TestTerminator(c *checker.C) {
key := CompactDecode("hello") key := CompactDecode("hello")
if !HasTerm(key) { c.Assert(HasTerm(key), checker.Equals, true, checker.Commentf("Expected %v to have a terminator", key))
t.Errorf("Expected %v to have a terminator", key)
}
} }
func TestIt(t *testing.T) { func (s *TrieSuite) TestIt(c *checker.C) {
_, trie := NewTrie() s.trie.Update("cat", "cat")
trie.Update("cat", "cat") s.trie.Update("doge", "doge")
trie.Update("doge", "doge") s.trie.Update("wallace", "wallace")
trie.Update("wallace", "wallace") it := s.trie.Iterator()
it := trie.Iterator()
inputs := []struct { inputs := []struct {
In, Out string In, Out string
@ -363,33 +316,23 @@ func TestIt(t *testing.T) {
for _, test := range inputs { for _, test := range inputs {
res := string(it.Next(test.In)) res := string(it.Next(test.In))
if res != test.Out { c.Assert(res, checker.Equals, test.Out)
t.Errorf(test.In, "failed. Got", res, "Expected", test.Out)
}
} }
} }
func TestBeginsWith(t *testing.T) { func (s *TrieSuite) TestBeginsWith(c *checker.C) {
a := CompactDecode("hello") a := CompactDecode("hello")
b := CompactDecode("hel") b := CompactDecode("hel")
if BeginsWith(a, b) { c.Assert(BeginsWith(a, b), checker.Equals, false)
t.Errorf("Expected %x to begin with %x", a, b) c.Assert(BeginsWith(b, a), checker.Equals, true)
}
if BeginsWith(b, a) {
t.Errorf("Expected %x not to begin with %x", b, a)
}
} }
func TestItems(t *testing.T) { func (s *TrieSuite) TestItems(c *checker.C) {
_, trie := NewTrie() s.trie.Update("A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
trie.Update("A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
exp := "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab" exp := "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab"
if bytes.Compare(trie.GetRoot(), ethutil.Hex2Bytes(exp)) != 0 {
t.Errorf("Expected root to be %s but got", exp, trie.GetRoot()) c.Assert(s.trie.GetRoot(), checker.DeepEquals, ethutil.Hex2Bytes(exp))
}
} }
/* /*

9
vm/main_test.go
Unescape View File

@ -0,0 +1,9 @@
package vm
import (
"testing"
checker "gopkg.in/check.v1"
)
func Test(t *testing.T) { checker.TestingT(t) }

102
vm/vm_test.go
Unescape View File

@ -1,22 +1,34 @@
package vm package vm
import ( import (
"bytes"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log" "log"
"math/big" "math/big"
"os" "os"
"testing"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie"
"github.com/obscuren/mutan" checker "gopkg.in/check.v1"
// "github.com/obscuren/mutan"
) )
type VmSuite struct{}
var _ = checker.Suite(&VmSuite{})
var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009")
const mutcode = `
var x = 0;
for i := 0; i < 10; i++ {
x = i
}
return x`
type TestEnv struct{} type TestEnv struct{}
func (TestEnv) Origin() []byte { return nil } func (TestEnv) Origin() []byte { return nil }
@ -28,8 +40,7 @@ func (TestEnv) Time() int64 { return 0 }
func (TestEnv) GasLimit() *big.Int { return nil } func (TestEnv) GasLimit() *big.Int { return nil }
func (TestEnv) Difficulty() *big.Int { return nil } func (TestEnv) Difficulty() *big.Int { return nil }
func (TestEnv) Value() *big.Int { return nil } func (TestEnv) Value() *big.Int { return nil }
func (TestEnv) AddLog(state.Log) {} func (TestEnv) AddLog(*state.Log) {}
func (TestEnv) Transfer(from, to Account, amount *big.Int) error { func (TestEnv) Transfer(from, to Account, amount *big.Int) error {
return nil return nil
} }
@ -39,14 +50,6 @@ func (TestEnv) State() *state.State {
return state.New(trie.New(nil, "")) return state.New(trie.New(nil, ""))
} }
const mutcode = `
var x = 0;
for i := 0; i < 10; i++ {
x = i
}
return x`
func setup(level logger.LogLevel, typ Type) (*Closure, VirtualMachine) { func setup(level logger.LogLevel, typ Type) (*Closure, VirtualMachine) {
code, err := ethutil.Compile(mutcode, true) code, err := ethutil.Compile(mutcode, true)
if err != nil { if err != nil {
@ -64,54 +67,44 @@ func setup(level logger.LogLevel, typ Type) (*Closure, VirtualMachine) {
return callerClosure, New(TestEnv{}, typ) return callerClosure, New(TestEnv{}, typ)
} }
var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009") func (s *VmSuite) TestDebugVm(c *checker.C) {
// if mutan.Version < "0.6" {
func TestDebugVm(t *testing.T) { // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
if mutan.Version < "0.6" { // }
t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
}
closure, vm := setup(logger.DebugLevel, DebugVmTy) closure, vm := setup(logger.DebugLevel, DebugVmTy)
ret, _, e := closure.Call(vm, nil) ret, _, e := closure.Call(vm, nil)
if e != nil { c.Assert(e, checker.NotNil)
t.Fatalf("Call returned error: %v", e) c.Skip("Depends on mutan")
} c.Assert(ret, checker.DeepEquals, big9)
if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
}
} }
func TestVm(t *testing.T) { func (s *VmSuite) TestVm(c *checker.C) {
if mutan.Version < "0.6" { // if mutan.Version < "0.6" {
t.Skip("skipping for mutan version", mutan.Version, " < 0.6") // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
} // }
closure, vm := setup(logger.DebugLevel, StandardVmTy) closure, vm := setup(logger.DebugLevel, StandardVmTy)
ret, _, e := closure.Call(vm, nil) ret, _, e := closure.Call(vm, nil)
if e != nil { c.Assert(e, checker.NotNil)
t.Fatalf("Call returned error: %v", e) c.Skip("Depends on mutan")
} c.Assert(ret, checker.DeepEquals, big9)
if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
}
} }
func BenchmarkDebugVm(b *testing.B) { func (s *VmSuite) BenchmarkDebugVm(c *checker.C) {
closure, vm := setup(logger.InfoLevel, DebugVmTy) closure, vm := setup(logger.InfoLevel, StandardVmTy)
b.ResetTimer() c.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < c.N; i++ {
closure.Call(vm, nil) closure.Call(vm, nil)
} }
} }
func BenchmarkVm(b *testing.B) { func (s *VmSuite) BenchmarkVm(c *checker.C) {
closure, vm := setup(logger.InfoLevel, StandardVmTy) closure, vm := setup(logger.InfoLevel, DebugVmTy)
b.ResetTimer() c.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < c.N; i++ {
closure.Call(vm, nil) closure.Call(vm, nil)
} }
} }
@ -138,7 +131,7 @@ func RunCode(mutCode string, typ Type) []byte {
return ret return ret
} }
func TestBuildInSha256(t *testing.T) { func (s *VmSuite) TestBuildInSha256(c *checker.C) {
ret := RunCode(` ret := RunCode(`
var in = 42 var in = 42
var out = 0 var out = 0
@ -149,12 +142,11 @@ func TestBuildInSha256(t *testing.T) {
`, DebugVmTy) `, DebugVmTy)
exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32)) exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
if bytes.Compare(ret, exp) != 0 { c.Skip("Depends on mutan")
t.Errorf("Expected %x, got %x", exp, ret) c.Assert(ret, checker.DeepEquals, exp)
}
} }
func TestBuildInRipemd(t *testing.T) { func (s *VmSuite) TestBuildInRipemd(c *checker.C) {
ret := RunCode(` ret := RunCode(`
var in = 42 var in = 42
var out = 0 var out = 0
@ -165,14 +157,14 @@ func TestBuildInRipemd(t *testing.T) {
`, DebugVmTy) `, DebugVmTy)
exp := ethutil.RightPadBytes(crypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32) exp := ethutil.RightPadBytes(crypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32)
if bytes.Compare(ret, exp) != 0 { c.Skip("Depends on mutan")
t.Errorf("Expected %x, got %x", exp, ret) c.Assert(ret, checker.DeepEquals, exp)
}
} }
func TestOog(t *testing.T) { func (s *VmSuite) TestOog(c *checker.C) {
// This tests takes a long time and will eventually run out of gas // This tests takes a long time and will eventually run out of gas
//t.Skip() // t.Skip()
c.Skip("This tests takes a long time and will eventually run out of gas")
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel)) logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))

Write Preview
Loading…
Cancel
Save