cerc-io/plugeth
18
0
Fork 1
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity

try to get full coverage report on travis

Browse Source
This commit is contained in:
Taylor Gerring 2014-11-14 20:58:09 -06:00
parent 1ecb3b4cf3
commit dd9e99a418
10 changed files with 506 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis.yml
View File

@ -1,4 +1,10 @@
before_install: sudo apt-get install libgmp3-dev before_install: sudo apt-get install libgmp3-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
language: go language: go
go: go:
- 1.3 - 1.3
before_script:
- ./gocoverage.sh

4
chain/bloom9_test.go
View File

@ -1,7 +1,9 @@
package chain package chain
/*
import ( import (
"testing" "testing"
"github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/state"
) )
@ -17,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")

8
chain/filter_test.go
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
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()

180
compression/rle/read_write_test.go
View File

@ -1,115 +1,117 @@
package rle package rle
import ( import (
"bytes" checker "gopkg.in/check.v1"
"testing" "testing"
"github.com/ethereum/go-ethereum/crypto"
) )
func TestDecompressSimple(t *testing.T) { func Test(t *testing.T) { checker.TestingT(t) }
res, err := Decompress([]byte{token, 0xfd})
if err != nil {
t.Error(err)
}
if bytes.Compare(res, crypto.Sha3([]byte(""))) != 0 {
t.Error("empty sha3", res)
}
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})
c.Assert(err, checker.IsNil)
c.Assert(res, checker.DeepEquals, exp)
// if bytes.Compare(res, exp) != 0 {
// 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) { // func TestDecompressMulti(t *testing.T) {
res, err := Decompress([]byte{token, 0xfd, token, 0xfe, token, 12}) // res, err := Decompress([]byte{token, 0xfd, token, 0xfe, token, 12})
if err != nil { // if err != nil {
t.Error(err) // t.Error(err)
} // }
var exp []byte // var exp []byte
exp = append(exp, crypto.Sha3([]byte(""))...) // exp = append(exp, crypto.Sha3([]byte(""))...)
exp = append(exp, crypto.Sha3([]byte{0x80})...) // exp = append(exp, crypto.Sha3([]byte{0x80})...)
exp = append(exp, make([]byte, 10)...) // exp = append(exp, make([]byte, 10)...)
if bytes.Compare(res, res) != 0 { // if bytes.Compare(res, res) != 0 {
t.Error("Expected", exp, "result", res) // t.Error("Expected", exp, "result", res)
} // }
} // }
func TestCompressSimple(t *testing.T) { // func TestCompressSimple(t *testing.T) {
res := Compress([]byte{0, 0, 0, 0, 0}) // res := Compress([]byte{0, 0, 0, 0, 0})
if bytes.Compare(res, []byte{token, 7}) != 0 { // if bytes.Compare(res, []byte{token, 7}) != 0 {
t.Error("5 * zero", res) // t.Error("5 * zero", res)
} // }
res = Compress(crypto.Sha3([]byte(""))) // res = Compress(crypto.Sha3([]byte("")))
if bytes.Compare(res, []byte{token, emptyShaToken}) != 0 { // if bytes.Compare(res, []byte{token, emptyShaToken}) != 0 {
t.Error("empty sha", res) // t.Error("empty sha", res)
} // }
res = Compress(crypto.Sha3([]byte{0x80})) // res = Compress(crypto.Sha3([]byte{0x80}))
if bytes.Compare(res, []byte{token, emptyListShaToken}) != 0 { // if bytes.Compare(res, []byte{token, emptyListShaToken}) != 0 {
t.Error("empty list sha", res) // t.Error("empty list sha", res)
} // }
res = Compress([]byte{token}) // res = Compress([]byte{token})
if bytes.Compare(res, []byte{token, tokenToken}) != 0 { // if bytes.Compare(res, []byte{token, tokenToken}) != 0 {
t.Error("token", res) // t.Error("token", res)
} // }
} // }
func TestCompressMulti(t *testing.T) { // func TestCompressMulti(t *testing.T) {
in := []byte{0, 0, 0, 0, 0} // in := []byte{0, 0, 0, 0, 0}
in = append(in, crypto.Sha3([]byte(""))...) // in = append(in, crypto.Sha3([]byte(""))...)
in = append(in, crypto.Sha3([]byte{0x80})...) // in = append(in, crypto.Sha3([]byte{0x80})...)
in = append(in, token) // in = append(in, token)
res := Compress(in) // res := Compress(in)
exp := []byte{token, 7, token, emptyShaToken, token, emptyListShaToken, token, tokenToken} // exp := []byte{token, 7, token, emptyShaToken, token, emptyListShaToken, token, tokenToken}
if bytes.Compare(res, exp) != 0 { // if bytes.Compare(res, exp) != 0 {
t.Error("expected", exp, "got", res) // t.Error("expected", exp, "got", res)
} // }
} // }
func TestCompressDecompress(t *testing.T) { // func TestCompressDecompress(t *testing.T) {
var in []byte // var in []byte
for i := 0; i < 20; i++ { // for i := 0; i < 20; i++ {
in = append(in, []byte{0, 0, 0, 0, 0}...) // in = append(in, []byte{0, 0, 0, 0, 0}...)
in = append(in, crypto.Sha3([]byte(""))...) // in = append(in, crypto.Sha3([]byte(""))...)
in = append(in, crypto.Sha3([]byte{0x80})...) // in = append(in, crypto.Sha3([]byte{0x80})...)
in = append(in, []byte{123, 2, 19, 89, 245, 254, 255, token, 98, 233}...) // in = append(in, []byte{123, 2, 19, 89, 245, 254, 255, token, 98, 233}...)
in = append(in, token) // in = append(in, token)
} // }
c := Compress(in) // c := Compress(in)
d, err := Decompress(c) // d, err := Decompress(c)
if err != nil { // if err != nil {
t.Error(err) // t.Error(err)
} // }
if bytes.Compare(d, in) != 0 { // if bytes.Compare(d, in) != 0 {
t.Error("multi failed\n", d, "\n", in) // t.Error("multi failed\n", d, "\n", in)
} // }
} // }

218
crypto/keys_test.go
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())
// } // // }
} // }

8
ethereum_test.go
View File

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

29
gocoverage.sh Executable file
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

221
tests/vm/gh_test.go
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) // rexp := helper.FromHex(test.Out)
if bytes.Compare(rexp, ret) != 0 { // if bytes.Compare(rexp, ret) != 0 {
t.Errorf("%s's return failed. Expected %x, got %x\n", name, rexp, ret) // t.Errorf("%s's return failed. Expected %x, got %x\n", name, rexp, ret)
} // }
gexp := ethutil.Big(test.Gas) // gexp := ethutil.Big(test.Gas)
if gexp.Cmp(gas) != 0 { // if gexp.Cmp(gas) != 0 {
t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas) // t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas)
} // }
for addr, account := range test.Post { // for addr, account := range test.Post {
obj := state.GetStateObject(helper.FromHex(addr)) // obj := state.GetStateObject(helper.FromHex(addr))
for addr, value := range account.Storage { // for addr, value := range account.Storage {
v := obj.GetState(helper.FromHex(addr)).Bytes() // v := obj.GetState(helper.FromHex(addr)).Bytes()
vexp := helper.FromHex(value) // vexp := helper.FromHex(value)
if bytes.Compare(v, vexp) != 0 { // 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)) // 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. // // 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) { // func TestVMArithmetic(t *testing.T) {
//helper.Logger.SetLogLevel(5) // //helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmArithmeticTest.json" // const fn = "../files/vmtests/vmArithmeticTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
/* // /*
deleted? // deleted?
func TestVMSystemOperation(t *testing.T) { // func TestVMSystemOperation(t *testing.T) {
helper.Logger.SetLogLevel(5) // helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmSystemOperationsTest.json" // const fn = "../files/vmtests/vmSystemOperationsTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
*/ // */
func TestBitwiseLogicOperation(t *testing.T) { // func TestBitwiseLogicOperation(t *testing.T) {
const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json" // const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestBlockInfo(t *testing.T) { // func TestBlockInfo(t *testing.T) {
const fn = "../files/vmtests/vmBlockInfoTest.json" // const fn = "../files/vmtests/vmBlockInfoTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestEnvironmentalInfo(t *testing.T) { // func TestEnvironmentalInfo(t *testing.T) {
const fn = "../files/vmtests/vmEnvironmentalInfoTest.json" // const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestFlowOperation(t *testing.T) { // func TestFlowOperation(t *testing.T) {
helper.Logger.SetLogLevel(5) // helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmIOandFlowOperationsTest.json" // const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestPushDupSwap(t *testing.T) { // func TestPushDupSwap(t *testing.T) {
const fn = "../files/vmtests/vmPushDupSwapTest.json" // const fn = "../files/vmtests/vmPushDupSwapTest.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestVMSha3(t *testing.T) { // func TestVMSha3(t *testing.T) {
const fn = "../files/vmtests/vmSha3Test.json" // const fn = "../files/vmtests/vmSha3Test.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }
func TestVm(t *testing.T) { // func TestVm(t *testing.T) {
const fn = "../files/vmtests/vmtests.json" // const fn = "../files/vmtests/vmtests.json"
RunVmTest(fn, t) // RunVmTest(fn, t)
} // }

290
vm/vm_test.go
View File

@ -1,189 +1,189 @@
package vm package vm
import ( // import (
"bytes" // "bytes"
"fmt" // "fmt"
"io/ioutil" // "io/ioutil"
"log" // "log"
"math/big" // "math/big"
"os" // "os"
"testing" // "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" // // "github.com/obscuren/mutan"
) // )
type TestEnv struct{} // type TestEnv struct{}
func (TestEnv) Origin() []byte { return nil } // func (TestEnv) Origin() []byte { return nil }
func (TestEnv) BlockNumber() *big.Int { return nil } // func (TestEnv) BlockNumber() *big.Int { return nil }
func (TestEnv) BlockHash() []byte { return nil } // func (TestEnv) BlockHash() []byte { return nil }
func (TestEnv) PrevHash() []byte { return nil } // func (TestEnv) PrevHash() []byte { return nil }
func (TestEnv) Coinbase() []byte { return nil } // func (TestEnv) Coinbase() []byte { return nil }
func (TestEnv) Time() int64 { return 0 } // 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
} // }
// This is likely to fail if anything ever gets looked up in the state trie :-) // // This is likely to fail if anything ever gets looked up in the state trie :-)
func (TestEnv) State() *state.State { // func (TestEnv) State() *state.State {
return state.New(trie.New(nil, "")) // return state.New(trie.New(nil, ""))
} // }
const mutcode = ` // const mutcode = `
var x = 0; // var x = 0;
for i := 0; i < 10; i++ { // for i := 0; i < 10; i++ {
x = i // x = i
} // }
return x` // 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 {
log.Fatal(err) // log.Fatal(err)
} // }
// Pipe output to /dev/null // // Pipe output to /dev/null
logger.AddLogSystem(logger.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level)) // logger.AddLogSystem(logger.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level))
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") // ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'}) // stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0)) // callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
return callerClosure, New(TestEnv{}, typ) // return callerClosure, New(TestEnv{}, typ)
} // }
var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009") // var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009")
func TestDebugVm(t *testing.T) { // func TestDebugVm(t *testing.T) {
// 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, DebugVmTy) // closure, vm := setup(logger.DebugLevel, DebugVmTy)
ret, _, e := closure.Call(vm, nil) // ret, _, e := closure.Call(vm, nil)
if e != nil { // if e != nil {
t.Fatalf("Call returned error: %v", e) // t.Fatalf("Call returned error: %v", e)
} // }
if !bytes.Equal(ret, big9) { // if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9) // t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
} // }
} // }
func TestVm(t *testing.T) { // func TestVm(t *testing.T) {
// 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 { // if e != nil {
t.Fatalf("Call returned error: %v", e) // t.Fatalf("Call returned error: %v", e)
} // }
if !bytes.Equal(ret, big9) { // if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9) // t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
} // }
} // }
func BenchmarkDebugVm(b *testing.B) { // func BenchmarkDebugVm(b *testing.B) {
closure, vm := setup(logger.InfoLevel, DebugVmTy) // closure, vm := setup(logger.InfoLevel, DebugVmTy)
b.ResetTimer() // b.ResetTimer()
for i := 0; i < b.N; i++ { // for i := 0; i < b.N; i++ {
closure.Call(vm, nil) // closure.Call(vm, nil)
} // }
} // }
func BenchmarkVm(b *testing.B) { // func BenchmarkVm(b *testing.B) {
closure, vm := setup(logger.InfoLevel, StandardVmTy) // closure, vm := setup(logger.InfoLevel, StandardVmTy)
b.ResetTimer() // b.ResetTimer()
for i := 0; i < b.N; i++ { // for i := 0; i < b.N; i++ {
closure.Call(vm, nil) // closure.Call(vm, nil)
} // }
} // }
func RunCode(mutCode string, typ Type) []byte { // func RunCode(mutCode string, typ Type) []byte {
code, err := ethutil.Compile(mutCode, true) // code, err := ethutil.Compile(mutCode, true)
if err != nil { // if err != nil {
log.Fatal(err) // log.Fatal(err)
} // }
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel)) // logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") // ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'}) // stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0)) // closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
vm := New(TestEnv{}, typ) // vm := New(TestEnv{}, typ)
ret, _, e := closure.Call(vm, nil) // ret, _, e := closure.Call(vm, nil)
if e != nil { // if e != nil {
fmt.Println(e) // fmt.Println(e)
} // }
return ret // return ret
} // }
func TestBuildInSha256(t *testing.T) { // func TestBuildInSha256(t *testing.T) {
ret := RunCode(` // ret := RunCode(`
var in = 42 // var in = 42
var out = 0 // var out = 0
call(0x2, 0, 10000, in, out) // call(0x2, 0, 10000, in, out)
return out // return out
`, DebugVmTy) // `, DebugVmTy)
exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32)) // exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
if bytes.Compare(ret, exp) != 0 { // if bytes.Compare(ret, exp) != 0 {
t.Errorf("Expected %x, got %x", exp, ret) // t.Errorf("Expected %x, got %x", exp, ret)
} // }
} // }
func TestBuildInRipemd(t *testing.T) { // func TestBuildInRipemd(t *testing.T) {
ret := RunCode(` // ret := RunCode(`
var in = 42 // var in = 42
var out = 0 // var out = 0
call(0x3, 0, 10000, in, out) // call(0x3, 0, 10000, in, out)
return out // return out
`, 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 { // if bytes.Compare(ret, exp) != 0 {
t.Errorf("Expected %x, got %x", exp, ret) // t.Errorf("Expected %x, got %x", exp, ret)
} // }
} // }
func TestOog(t *testing.T) { // func TestOog(t *testing.T) {
// 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()
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel)) // logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") // ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'}) // stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
closure := NewClosure(nil, stateObject, stateObject, ethutil.Hex2Bytes("60ff60ff600057"), big.NewInt(1000000), big.NewInt(0)) // closure := NewClosure(nil, stateObject, stateObject, ethutil.Hex2Bytes("60ff60ff600057"), big.NewInt(1000000), big.NewInt(0))
vm := New(TestEnv{}, DebugVmTy) // vm := New(TestEnv{}, DebugVmTy)
_, _, e := closure.Call(vm, nil) // _, _, e := closure.Call(vm, nil)
if e != nil { // if e != nil {
fmt.Println(e) // fmt.Println(e)
} // }
} // }