mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

Convert vm test to checker

Browse Source 
Tests are skipped due to reliance on deprecated mutan
pull/199/head
Taylor Gerring 10 years ago
parent ffab36c7d8
commit 9095b37343
2 changed files with 184 additions and 183 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. 9
      vm/main_test.go
  2. 340
      vm/vm_test.go

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) }

340
vm/vm_test.go
Unescape View File

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

Write Preview
Loading…
Cancel
Save