good morning!!!!

Skip to content
Snippets Groups Projects
Commit dd9e99a4 authored by Taylor Gerring's avatar Taylor Gerring
Browse files

try to get full coverage report on travis

parent 1ecb3b4c
Branches
Tags
No related merge requests found
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
go:
- 1.3
before_script:
- ./gocoverage.sh
package chain
/*
import (
"testing"
"github.com/ethereum/go-ethereum/state"
)
......@@ -17,7 +19,7 @@ func TestBloom9(t *testing.T) {
}
}
/*
func TestAddress(t *testing.T) {
block := &Block{}
block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f")
......
package chain
import "testing"
// import "testing"
func TestFilter(t *testing.T) {
NewFilter(NewTestManager())
}
// func TestFilter(t *testing.T) {
// NewFilter(NewTestManager())
// }
......@@ -13,7 +13,7 @@ import (
// Implement our EthTest Manager
type TestManager struct {
stateManager *StateManager
// stateManager *StateManager
eventMux *event.TypeMux
db ethutil.Database
......@@ -46,9 +46,9 @@ func (tm *TestManager) TxPool() *TxPool {
return tm.txPool
}
func (tm *TestManager) StateManager() *StateManager {
return tm.stateManager
}
// func (tm *TestManager) StateManager() *StateManager {
// return tm.stateManager
// }
func (tm *TestManager) EventMux() *event.TypeMux {
return tm.eventMux
......@@ -81,9 +81,9 @@ func NewTestManager() *TestManager {
testManager := &TestManager{}
testManager.eventMux = new(event.TypeMux)
testManager.db = db
testManager.txPool = NewTxPool(testManager)
testManager.blockChain = NewChainManager(testManager)
testManager.stateManager = NewStateManager(testManager)
// testManager.txPool = NewTxPool(testManager)
// testManager.blockChain = NewChainManager(testManager)
// testManager.stateManager = NewStateManager(testManager)
// Start the tx pool
testManager.txPool.Start()
......
package rle
import (
"bytes"
checker "gopkg.in/check.v1"
"testing"
"github.com/ethereum/go-ethereum/crypto"
)
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})
if err != nil {
t.Error(err)
}
if bytes.Compare(res, crypto.Sha3([]byte(""))) != 0 {
t.Error("empty sha3", res)
}
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})
if err != nil {
t.Error(err)
}
if bytes.Compare(res, crypto.Sha3([]byte{0x80})) != 0 {
t.Error("0x80 sha3", res)
}
c.Assert(err, checker.IsNil)
c.Assert(res, checker.DeepEquals, exp)
// if bytes.Compare(res, exp) != 0 {
// t.Error("0x80 sha3", res)
// }
res, err = Decompress([]byte{token, 0xff})
if err != nil {
t.Error(err)
}
if bytes.Compare(res, []byte{token}) != 0 {
t.Error("token", res)
}
c.Assert(err, checker.IsNil)
c.Assert(res, checker.DeepEquals, []byte{token})
// if bytes.Compare(res, []byte{token}) != 0 {
// t.Error("token", res)
// }
res, err = Decompress([]byte{token, 12})
if err != nil {
t.Error(err)
}
if bytes.Compare(res, make([]byte, 10)) != 0 {
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) {
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)
}
}
c.Assert(err, checker.IsNil)
c.Assert(res, checker.DeepEquals, make([]byte, 10))
// if bytes.Compare(res, make([]byte, 10)) != 0 {
// 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) {
// 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)
// }
// }
package crypto
import (
"github.com/ethereum/go-ethereum/ethdb"
// "io/ioutil"
"fmt"
"os"
"path"
"testing"
)
// import (
// "github.com/ethereum/go-ethereum/ethdb"
// // "io/ioutil"
// "fmt"
// "os"
// "path"
// "testing"
// )
// test if persistence layer works
func TestDBKeyManager(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false)
if err != nil {
t.Error("Unexpected error: ", err)
}
keyManager1 := NewDBKeyManager(memdb)
err = keyManager1.Init("", 0, false)
if err != nil {
t.Error("Unexpected error: ", err)
}
if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
}
err = keyManager1.Init("", 0, true)
if err != nil {
t.Error("Unexpected error: ", err)
}
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())
}
}
func TestFileKeyManager(t *testing.T) {
basedir0 := "/tmp/ethtest0"
os.RemoveAll(basedir0)
os.Mkdir(basedir0, 0777)
keyManager0 := NewFileKeyManager(basedir0)
err := keyManager0.Init("", 0, false)
if err != nil {
t.Error("Unexpected error: ", err)
}
keyManager1 := NewFileKeyManager(basedir0)
err = keyManager1.Init("", 0, false)
if err != nil {
t.Error("Unexpected error: ", err)
}
if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
}
// // test if persistence layer works
// func TestDBKeyManager(t *testing.T) {
// memdb, _ := ethdb.NewMemDatabase()
// keyManager0 := NewDBKeyManager(memdb)
// err := keyManager0.Init("", 0, false)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// keyManager1 := NewDBKeyManager(memdb)
// err = keyManager1.Init("", 0, false)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
// t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
// }
// err = keyManager1.Init("", 0, true)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// 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())
// }
// }
err = keyManager1.Init("", 0, true)
if err != nil {
t.Error("Unexpected error: ", err)
}
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())
}
}
// func TestFileKeyManager(t *testing.T) {
// basedir0 := "/tmp/ethtest0"
// os.RemoveAll(basedir0)
// os.Mkdir(basedir0, 0777)
// cursor errors
func TestCursorErrors(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false)
err = keyManager0.Init("", 1, false)
if err == nil {
t.Error("Expected cursor error")
}
err = keyManager0.SetCursor(1)
if err == nil {
t.Error("Expected cursor error")
}
}
// keyManager0 := NewFileKeyManager(basedir0)
// err := keyManager0.Init("", 0, false)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
func TestExportImport(t *testing.T) {
memdb, _ := ethdb.NewMemDatabase()
keyManager0 := NewDBKeyManager(memdb)
err := keyManager0.Init("", 0, false)
basedir0 := "/tmp/ethtest0"
os.RemoveAll(basedir0)
os.Mkdir(basedir0, 0777)
keyManager0.Export(basedir0)
// keyManager1 := NewFileKeyManager(basedir0)
keyManager1 := NewFileKeyManager(basedir0)
err = keyManager1.Init("", 0, false)
if err != nil {
t.Error("Unexpected error: ", err)
}
fmt.Printf("keyRing: %v\n", keyManager0.KeyPair())
fmt.Printf("keyRing: %v\n", keyManager1.KeyPair())
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())
}
path.Join("")
// err = keyManager1.Init("", 0, false)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
// t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
// }
// memdb, _ = ethdb.NewMemDatabase()
// keyManager2 := NewDBKeyManager(memdb)
// err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv"))
// err = keyManager1.Init("", 0, true)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// 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())
// 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())
// }
// }
// memdb, _ = ethdb.NewMemDatabase()
// keyManager3 := NewDBKeyManager(memdb)
// err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne"))
// // cursor errors
// func TestCursorErrors(t *testing.T) {
// memdb, _ := ethdb.NewMemDatabase()
// keyManager0 := NewDBKeyManager(memdb)
// err := keyManager0.Init("", 0, false)
// err = keyManager0.Init("", 1, false)
// if err == nil {
// t.Error("Expected cursor error")
// }
// err = keyManager0.SetCursor(1)
// if err == nil {
// t.Error("Expected cursor error")
// }
// }
// func TestExportImport(t *testing.T) {
// memdb, _ := ethdb.NewMemDatabase()
// keyManager0 := NewDBKeyManager(memdb)
// err := keyManager0.Init("", 0, false)
// basedir0 := "/tmp/ethtest0"
// os.RemoveAll(basedir0)
// os.Mkdir(basedir0, 0777)
// keyManager0.Export(basedir0)
// keyManager1 := NewFileKeyManager(basedir0)
// err = keyManager1.Init("", 0, false)
// if err != nil {
// t.Error("Unexpected error: ", err)
// }
// 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())
// fmt.Printf("keyRing: %v\n", keyManager0.KeyPair())
// fmt.Printf("keyRing: %v\n", keyManager1.KeyPair())
// 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())
// }
// path.Join("")
// // memdb, _ = ethdb.NewMemDatabase()
// // keyManager2 := NewDBKeyManager(memdb)
// // err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv"))
// // if err != nil {
// // t.Error("Unexpected error: ", err)
// // }
// // 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())
// // }
// // memdb, _ = ethdb.NewMemDatabase()
// // keyManager3 := NewDBKeyManager(memdb)
// // err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne"))
// // if err != nil {
// // t.Error("Unexpected error: ", err)
// // }
// // 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())
// // }
// }
}
package eth
import (
checker "gopkg.in/check.v1"
"testing"
)
func Test(t *testing.T) { checker.TestingT(t) }
#!/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
package vm
import (
"bytes"
"testing"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/tests/helper"
)
type Account struct {
Balance string
Code string
Nonce string
Storage map[string]string
}
func StateObjectFromAccount(addr string, account Account) *state.StateObject {
obj := state.NewStateObject(ethutil.Hex2Bytes(addr))
obj.SetBalance(ethutil.Big(account.Balance))
if ethutil.IsHex(account.Code) {
account.Code = account.Code[2:]
}
obj.Code = ethutil.Hex2Bytes(account.Code)
obj.Nonce = ethutil.Big(account.Nonce).Uint64()
return obj
}
type VmTest struct {
Callcreates interface{}
Env map[string]string
Exec map[string]string
Gas string
Out string
Post map[string]Account
Pre map[string]Account
}
func RunVmTest(p string, t *testing.T) {
tests := make(map[string]VmTest)
helper.CreateFileTests(t, p, &tests)
for name, test := range tests {
state := state.New(helper.NewTrie())
for addr, account := range test.Pre {
obj := StateObjectFromAccount(addr, account)
state.SetStateObject(obj)
}
ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
// When an error is returned it doesn't always mean the tests fails.
// Have to come up with some conditional failing mechanism.
if err != nil {
helper.Log.Infoln(err)
}
rexp := helper.FromHex(test.Out)
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 {
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, value := range account.Storage {
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))
}
}
}
}
}
// 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) {
// import (
// "bytes"
// "testing"
// "github.com/ethereum/go-ethereum/ethutil"
// "github.com/ethereum/go-ethereum/state"
// "github.com/ethereum/go-ethereum/tests/helper"
// )
// type Account struct {
// Balance string
// Code string
// Nonce string
// Storage map[string]string
// }
// func StateObjectFromAccount(addr string, account Account) *state.StateObject {
// obj := state.NewStateObject(ethutil.Hex2Bytes(addr))
// obj.SetBalance(ethutil.Big(account.Balance))
// if ethutil.IsHex(account.Code) {
// account.Code = account.Code[2:]
// }
// obj.Code = ethutil.Hex2Bytes(account.Code)
// obj.Nonce = ethutil.Big(account.Nonce).Uint64()
// return obj
// }
// type VmTest struct {
// Callcreates interface{}
// Env map[string]string
// Exec map[string]string
// Gas string
// Out string
// Post map[string]Account
// Pre map[string]Account
// }
// func RunVmTest(p string, t *testing.T) {
// tests := make(map[string]VmTest)
// helper.CreateFileTests(t, p, &tests)
// for name, test := range tests {
// state := state.New(helper.NewTrie())
// for addr, account := range test.Pre {
// obj := StateObjectFromAccount(addr, account)
// state.SetStateObject(obj)
// }
// ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
// // When an error is returned it doesn't always mean the tests fails.
// // Have to come up with some conditional failing mechanism.
// if err != nil {
// t.Errorf("%s", err)
// helper.Log.Infoln(err)
// }
// rexp := helper.FromHex(test.Out)
// 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 {
// 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, value := range account.Storage {
// 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))
// }
// }
// }
// }
// }
// // 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) {
// //helper.Logger.SetLogLevel(5)
// const fn = "../files/vmtests/vmArithmeticTest.json"
// RunVmTest(fn, t)
// }
// /*
// deleted?
// func TestVMSystemOperation(t *testing.T) {
// helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmArithmeticTest.json"
RunVmTest(fn, t)
}
/*
deleted?
func TestVMSystemOperation(t *testing.T) {
helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmSystemOperationsTest.json"
RunVmTest(fn, t)
}
*/
func TestBitwiseLogicOperation(t *testing.T) {
const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
RunVmTest(fn, t)
}
func TestBlockInfo(t *testing.T) {
const fn = "../files/vmtests/vmBlockInfoTest.json"
RunVmTest(fn, t)
}
func TestEnvironmentalInfo(t *testing.T) {
const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
RunVmTest(fn, t)
}
func TestFlowOperation(t *testing.T) {
helper.Logger.SetLogLevel(5)
const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
RunVmTest(fn, t)
}
func TestPushDupSwap(t *testing.T) {
const fn = "../files/vmtests/vmPushDupSwapTest.json"
RunVmTest(fn, t)
}
func TestVMSha3(t *testing.T) {
const fn = "../files/vmtests/vmSha3Test.json"
RunVmTest(fn, t)
}
func TestVm(t *testing.T) {
const fn = "../files/vmtests/vmtests.json"
RunVmTest(fn, t)
}
// const fn = "../files/vmtests/vmSystemOperationsTest.json"
// RunVmTest(fn, t)
// }
// */
// func TestBitwiseLogicOperation(t *testing.T) {
// const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
// RunVmTest(fn, t)
// }
// func TestBlockInfo(t *testing.T) {
// const fn = "../files/vmtests/vmBlockInfoTest.json"
// RunVmTest(fn, t)
// }
// func TestEnvironmentalInfo(t *testing.T) {
// const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
// RunVmTest(fn, t)
// }
// func TestFlowOperation(t *testing.T) {
// helper.Logger.SetLogLevel(5)
// const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
// RunVmTest(fn, t)
// }
// func TestPushDupSwap(t *testing.T) {
// const fn = "../files/vmtests/vmPushDupSwapTest.json"
// RunVmTest(fn, t)
// }
// func TestVMSha3(t *testing.T) {
// const fn = "../files/vmtests/vmSha3Test.json"
// RunVmTest(fn, t)
// }
// func TestVm(t *testing.T) {
// const fn = "../files/vmtests/vmtests.json"
// RunVmTest(fn, t)
// }
package vm
import (
"bytes"
"fmt"
"io/ioutil"
"log"
"math/big"
"os"
"testing"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/trie"
// "github.com/obscuren/mutan"
)
type TestEnv struct{}
func (TestEnv) Origin() []byte { return nil }
func (TestEnv) BlockNumber() *big.Int { return nil }
func (TestEnv) BlockHash() []byte { return nil }
func (TestEnv) PrevHash() []byte { return nil }
func (TestEnv) Coinbase() []byte { return nil }
func (TestEnv) Time() int64 { return 0 }
func (TestEnv) GasLimit() *big.Int { return nil }
func (TestEnv) Difficulty() *big.Int { return nil }
func (TestEnv) Value() *big.Int { return nil }
func (TestEnv) AddLog(state.Log) {}
func (TestEnv) Transfer(from, to Account, amount *big.Int) error {
return nil
}
// This is likely to fail if anything ever gets looked up in the state trie :-)
func (TestEnv) State() *state.State {
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) {
code, err := ethutil.Compile(mutcode, true)
if err != nil {
log.Fatal(err)
}
// Pipe output to /dev/null
logger.AddLogSystem(logger.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level))
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
return callerClosure, New(TestEnv{}, typ)
}
var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009")
func TestDebugVm(t *testing.T) {
// if mutan.Version < "0.6" {
// t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// }
closure, vm := setup(logger.DebugLevel, DebugVmTy)
ret, _, e := closure.Call(vm, nil)
if e != nil {
t.Fatalf("Call returned error: %v", e)
}
if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
}
}
func TestVm(t *testing.T) {
// if mutan.Version < "0.6" {
// t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// }
closure, vm := setup(logger.DebugLevel, StandardVmTy)
ret, _, e := closure.Call(vm, nil)
if e != nil {
t.Fatalf("Call returned error: %v", e)
}
if !bytes.Equal(ret, big9) {
t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
}
}
func BenchmarkDebugVm(b *testing.B) {
closure, vm := setup(logger.InfoLevel, DebugVmTy)
b.ResetTimer()
for i := 0; i < b.N; i++ {
closure.Call(vm, nil)
}
}
func BenchmarkVm(b *testing.B) {
closure, vm := setup(logger.InfoLevel, StandardVmTy)
// import (
// "bytes"
// "fmt"
// "io/ioutil"
// "log"
// "math/big"
// "os"
// "testing"
// "github.com/ethereum/go-ethereum/crypto"
// "github.com/ethereum/go-ethereum/ethutil"
// "github.com/ethereum/go-ethereum/logger"
// "github.com/ethereum/go-ethereum/state"
// "github.com/ethereum/go-ethereum/trie"
// // "github.com/obscuren/mutan"
// )
// type TestEnv struct{}
// func (TestEnv) Origin() []byte { return nil }
// func (TestEnv) BlockNumber() *big.Int { return nil }
// func (TestEnv) BlockHash() []byte { return nil }
// func (TestEnv) PrevHash() []byte { return nil }
// func (TestEnv) Coinbase() []byte { return nil }
// func (TestEnv) Time() int64 { return 0 }
// func (TestEnv) GasLimit() *big.Int { return nil }
// func (TestEnv) Difficulty() *big.Int { return nil }
// func (TestEnv) Value() *big.Int { return nil }
// func (TestEnv) AddLog(state.Log) {}
// func (TestEnv) Transfer(from, to Account, amount *big.Int) error {
// return nil
// }
// // This is likely to fail if anything ever gets looked up in the state trie :-)
// func (TestEnv) State() *state.State {
// 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) {
// code, err := ethutil.Compile(mutcode, true)
// if err != nil {
// log.Fatal(err)
// }
// // Pipe output to /dev/null
// logger.AddLogSystem(logger.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level))
// ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
// stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
// callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
// return callerClosure, New(TestEnv{}, typ)
// }
// var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009")
// func TestDebugVm(t *testing.T) {
// // if mutan.Version < "0.6" {
// // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// // }
// closure, vm := setup(logger.DebugLevel, DebugVmTy)
// ret, _, e := closure.Call(vm, nil)
// if e != nil {
// t.Fatalf("Call returned error: %v", e)
// }
// if !bytes.Equal(ret, big9) {
// t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
// }
// }
// func TestVm(t *testing.T) {
// // if mutan.Version < "0.6" {
// // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// // }
// closure, vm := setup(logger.DebugLevel, StandardVmTy)
// ret, _, e := closure.Call(vm, nil)
// if e != nil {
// t.Fatalf("Call returned error: %v", e)
// }
// if !bytes.Equal(ret, big9) {
// t.Errorf("Wrong return value '%x', want '%x'", ret, big9)
// }
// }
b.ResetTimer()
for i := 0; i < b.N; i++ {
closure.Call(vm, nil)
}
}
// func BenchmarkDebugVm(b *testing.B) {
// closure, vm := setup(logger.InfoLevel, DebugVmTy)
func RunCode(mutCode string, typ Type) []byte {
code, err := ethutil.Compile(mutCode, true)
if err != nil {
log.Fatal(err)
}
// b.ResetTimer()
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
// for i := 0; i < b.N; i++ {
// closure.Call(vm, nil)
// }
// }
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
// func BenchmarkVm(b *testing.B) {
// closure, vm := setup(logger.InfoLevel, StandardVmTy)
stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
// b.ResetTimer()
vm := New(TestEnv{}, typ)
ret, _, e := closure.Call(vm, nil)
if e != nil {
fmt.Println(e)
}
// for i := 0; i < b.N; i++ {
// closure.Call(vm, nil)
// }
// }
return ret
}
// func RunCode(mutCode string, typ Type) []byte {
// code, err := ethutil.Compile(mutCode, true)
// if err != nil {
// log.Fatal(err)
// }
func TestBuildInSha256(t *testing.T) {
ret := RunCode(`
var in = 42
var out = 0
// logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
call(0x2, 0, 10000, in, out)
// ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
return out
`, DebugVmTy)
// stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
// closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
if bytes.Compare(ret, exp) != 0 {
t.Errorf("Expected %x, got %x", exp, ret)
}
}
// vm := New(TestEnv{}, typ)
// ret, _, e := closure.Call(vm, nil)
// if e != nil {
// fmt.Println(e)
// }
func TestBuildInRipemd(t *testing.T) {
ret := RunCode(`
var in = 42
var out = 0
// return ret
// }
call(0x3, 0, 10000, in, out)
// func TestBuildInSha256(t *testing.T) {
// ret := RunCode(`
// var in = 42
// var out = 0
return out
`, DebugVmTy)
// call(0x2, 0, 10000, in, out)
exp := ethutil.RightPadBytes(crypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32)
if bytes.Compare(ret, exp) != 0 {
t.Errorf("Expected %x, got %x", exp, ret)
}
}
// return out
// `, DebugVmTy)
func TestOog(t *testing.T) {
// This tests takes a long time and will eventually run out of gas
//t.Skip()
// exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
// if bytes.Compare(ret, exp) != 0 {
// t.Errorf("Expected %x, got %x", exp, ret)
// }
// }
// func TestBuildInRipemd(t *testing.T) {
// ret := RunCode(`
// var in = 42
// var out = 0
// call(0x3, 0, 10000, in, out)
// return out
// `, DebugVmTy)
// exp := ethutil.RightPadBytes(crypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32)
// if bytes.Compare(ret, exp) != 0 {
// t.Errorf("Expected %x, got %x", exp, ret)
// }
// }
// func TestOog(t *testing.T) {
// // This tests takes a long time and will eventually run out of gas
// // 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'})
closure := NewClosure(nil, stateObject, stateObject, ethutil.Hex2Bytes("60ff60ff600057"), big.NewInt(1000000), big.NewInt(0))
// stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
// closure := NewClosure(nil, stateObject, stateObject, ethutil.Hex2Bytes("60ff60ff600057"), big.NewInt(1000000), big.NewInt(0))
vm := New(TestEnv{}, DebugVmTy)
_, _, e := closure.Call(vm, nil)
if e != nil {
fmt.Println(e)
}
}
// vm := New(TestEnv{}, DebugVmTy)
// _, _, e := closure.Call(vm, nil)
// if e != nil {
// fmt.Println(e)
// }
// }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment