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

Convert vm test to checker

Browse Source 
Tests are skipped due to reliance on deprecated mutan
This commit is contained in:
Taylor Gerring 2014-11-16 13:45:46 -06:00
parent ffab36c7d8
commit 9095b37343
2 changed files with 148 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
vm/main_test.go Normal file
View File

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

302
vm/vm_test.go
View File

@ -1,189 +1,181 @@
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 TestEnv struct{} type VmSuite struct{}
// func (TestEnv) Origin() []byte { return nil } var _ = checker.Suite(&VmSuite{})
// func (TestEnv) BlockNumber() *big.Int { return nil } var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009")
// 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 { const mutcode = `
// return nil var x = 0;
for i := 0; i < 10; i++ {
x = i
}
return x`
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, ""))
}
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)
}
func (s *VmSuite) TestDebugVm(c *checker.C) {
// 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)
c.Assert(e, checker.NotNil)
c.Skip("Depends on mutan")
c.Assert(ret, checker.DeepEquals, big9)
}
// // This is likely to fail if anything ever gets looked up in the state trie :-) func (s *VmSuite) TestVm(c *checker.C) {
// func (TestEnv) State() *state.State { // if mutan.Version < "0.6" {
// return state.New(trie.New(nil, "")) // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// } // }
closure, vm := setup(logger.DebugLevel, StandardVmTy)
ret, _, e := closure.Call(vm, nil)
c.Assert(e, checker.NotNil)
c.Skip("Depends on mutan")
c.Assert(ret, checker.DeepEquals, big9)
}
// const mutcode = ` func (s *VmSuite) BenchmarkDebugVm(c *checker.C) {
// var x = 0; closure, vm := setup(logger.InfoLevel, StandardVmTy)
// for i := 0; i < 10; i++ {
// x = i
// }
// return x` c.ResetTimer()
// func setup(level logger.LogLevel, typ Type) (*Closure, VirtualMachine) { for i := 0; i < c.N; i++ {
// code, err := ethutil.Compile(mutcode, true) closure.Call(vm, nil)
// if err != nil { }
// log.Fatal(err) }
// }
// // Pipe output to /dev/null func (s *VmSuite) BenchmarkVm(c *checker.C) {
// logger.AddLogSystem(logger.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level)) closure, vm := setup(logger.InfoLevel, DebugVmTy)
// ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") c.ResetTimer()
// stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'}) for i := 0; i < c.N; i++ {
// callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0)) closure.Call(vm, nil)
}
}
// return callerClosure, New(TestEnv{}, typ) func RunCode(mutCode string, typ Type) []byte {
// } code, err := ethutil.Compile(mutCode, true)
if err != nil {
log.Fatal(err)
}
// var big9 = ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000009") logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
// func TestDebugVm(t *testing.T) { ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
// // if mutan.Version < "0.6" {
// // t.Skip("skipping for mutan version", mutan.Version, " < 0.6")
// // }
// closure, vm := setup(logger.DebugLevel, DebugVmTy) stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
// ret, _, e := closure.Call(vm, nil) closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
// 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) { vm := New(TestEnv{}, typ)
// // if mutan.Version < "0.6" { ret, _, e := closure.Call(vm, nil)
// // t.Skip("skipping for mutan version", mutan.Version, " < 0.6") if e != nil {
// // } fmt.Println(e)
}
// closure, vm := setup(logger.DebugLevel, StandardVmTy) return ret
// 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) { func (s *VmSuite) TestBuildInSha256(c *checker.C) {
// closure, vm := setup(logger.InfoLevel, DebugVmTy) ret := RunCode(`
var in = 42
var out = 0
// b.ResetTimer() call(0x2, 0, 10000, in, out)
// for i := 0; i < b.N; i++ { return out
// closure.Call(vm, nil) `, DebugVmTy)
// }
// }
// func BenchmarkVm(b *testing.B) { exp := crypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
// closure, vm := setup(logger.InfoLevel, StandardVmTy) c.Skip("Depends on mutan")
c.Assert(ret, checker.DeepEquals, exp)
}
// b.ResetTimer() func (s *VmSuite) TestBuildInRipemd(c *checker.C) {
ret := RunCode(`
var in = 42
var out = 0
// for i := 0; i < b.N; i++ { call(0x3, 0, 10000, in, out)
// closure.Call(vm, nil)
// }
// }
// func RunCode(mutCode string, typ Type) []byte { return out
// code, err := ethutil.Compile(mutCode, true) `, DebugVmTy)
// if err != nil {
// log.Fatal(err)
// }
// logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel)) exp := ethutil.RightPadBytes(crypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32)
c.Skip("Depends on mutan")
c.Assert(ret, checker.DeepEquals, exp)
}
// ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") func (s *VmSuite) TestOog(c *checker.C) {
// This tests takes a long time and will eventually run out of gas
// t.Skip()
c.Skip("This tests takes a long time and will eventually run out of gas")
// stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'}) logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
// closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
// vm := New(TestEnv{}, typ) ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
// ret, _, e := closure.Call(vm, nil)
// if e != nil {
// fmt.Println(e)
// }
// return ret stateObject := state.NewStateObject([]byte{'j', 'e', 'f', 'f'})
// } closure := NewClosure(nil, stateObject, stateObject, ethutil.Hex2Bytes("60ff60ff600057"), big.NewInt(1000000), big.NewInt(0))
// func TestBuildInSha256(t *testing.T) { vm := New(TestEnv{}, DebugVmTy)
// ret := RunCode(` _, _, e := closure.Call(vm, nil)
// var in = 42 if e != nil {
// var out = 0 fmt.Println(e)
}
// call(0x2, 0, 10000, in, out) }
// return out
// `, DebugVmTy)
// 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))
// 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))
// vm := New(TestEnv{}, DebugVmTy)
// _, _, e := closure.Call(vm, nil)
// if e != nil {
// fmt.Println(e)
// }
// }