diff --git a/tests/helper/common.go b/tests/helper/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..3d539ebb054981db1cd4f16d2507482b23346839
--- /dev/null
+++ b/tests/helper/common.go
@@ -0,0 +1,11 @@
+package helper
+
+import "github.com/ethereum/eth-go/ethutil"
+
+func FromHex(h string) []byte {
+ if ethutil.IsHex(h) {
+ h = h[2:]
+ }
+
+ return ethutil.Hex2Bytes(h)
+}
diff --git a/tests/helper/http.go b/tests/helper/http.go
new file mode 100644
index 0000000000000000000000000000000000000000..b379695d03e168418ac2c30f8c28265ed9d2a749
--- /dev/null
+++ b/tests/helper/http.go
@@ -0,0 +1,24 @@
+package helper
+
+import (
+ "encoding/json"
+ "io/ioutil"
+ "net/http"
+)
+
+func CreateTests(uri string, value interface{}) error {
+ resp, err := http.Get(uri)
+ if err != nil {
+ panic(err)
+ }
+ defer resp.Body.Close()
+
+ data, err := ioutil.ReadAll(resp.Body)
+
+ err = json.Unmarshal(data, &value)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/tests/helper/init.go b/tests/helper/init.go
new file mode 100644
index 0000000000000000000000000000000000000000..1f2ee208abc5f252b5308d88e4fff1ad5406e38a
--- /dev/null
+++ b/tests/helper/init.go
@@ -0,0 +1,15 @@
+package helper
+
+import (
+ "log"
+ "os"
+
+ "github.com/ethereum/eth-go/ethlog"
+ "github.com/ethereum/eth-go/ethutil"
+)
+
+func init() {
+ ethlog.AddLogSystem(ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.LogLevel(4)))
+
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+}
diff --git a/tests/helper/trie.go b/tests/helper/trie.go
new file mode 100644
index 0000000000000000000000000000000000000000..af828685c608f45ec34e4f255b7a4279d9784990
--- /dev/null
+++ b/tests/helper/trie.go
@@ -0,0 +1,31 @@
+package helper
+
+import "github.com/ethereum/eth-go/ethtrie"
+
+type MemDatabase struct {
+ db map[string][]byte
+}
+
+func NewMemDatabase() (*MemDatabase, error) {
+ db := &MemDatabase{db: make(map[string][]byte)}
+ return db, nil
+}
+func (db *MemDatabase) Put(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+func (db *MemDatabase) Get(key []byte) ([]byte, error) {
+ return db.db[string(key)], nil
+}
+func (db *MemDatabase) Delete(key []byte) error {
+ delete(db.db, string(key))
+ return nil
+}
+func (db *MemDatabase) Print() {}
+func (db *MemDatabase) Close() {}
+func (db *MemDatabase) LastKnownTD() []byte { return nil }
+
+func NewTrie() *ethtrie.Trie {
+ db, _ := NewMemDatabase()
+
+ return ethtrie.New(db, "")
+}
diff --git a/tests/helper/vm.go b/tests/helper/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..49a0bfeae9f497a1dedd9ef10d93dd1085432513
--- /dev/null
+++ b/tests/helper/vm.go
@@ -0,0 +1,66 @@
+package helper
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/eth-go/ethstate"
+ "github.com/ethereum/eth-go/ethtrie"
+ "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/eth-go/ethvm"
+)
+
+type Env struct {
+ state *ethstate.State
+
+ origin []byte
+ parent []byte
+ coinbase []byte
+
+ number *big.Int
+ time int64
+ difficulty *big.Int
+}
+
+func NewEnv(state *ethstate.State) *Env {
+ return &Env{
+ state: state,
+ }
+}
+
+func NewEnvFromMap(state *ethstate.State, envValues map[string]string, exeValues map[string]string) *Env {
+ env := NewEnv(state)
+
+ env.origin = ethutil.Hex2Bytes(exeValues["caller"])
+ env.parent = ethutil.Hex2Bytes(envValues["previousHash"])
+ env.coinbase = ethutil.Hex2Bytes(envValues["currentCoinbase"])
+ env.number = ethutil.Big(envValues["currentNumber"])
+ env.time = ethutil.Big(envValues["currentTime"]).Int64()
+
+ return env
+}
+
+func (self *Env) Origin() []byte { return self.origin }
+func (self *Env) BlockNumber() *big.Int { return self.number }
+func (self *Env) PrevHash() []byte { return self.parent }
+func (self *Env) Coinbase() []byte { return self.coinbase }
+func (self *Env) Time() int64 { return self.time }
+func (self *Env) Difficulty() *big.Int { return self.difficulty }
+func (self *Env) BlockHash() []byte { return nil }
+
+// This is likely to fail if anything ever gets looked up in the state trie :-)
+func (self *Env) State() *ethstate.State { return ethstate.New(ethtrie.New(nil, "")) }
+
+func RunVm(state *ethstate.State, env, exec map[string]string) ([]byte, *big.Int) {
+ caller := state.NewStateObject(ethutil.Hex2Bytes(exec["caller"]))
+ callee := state.GetStateObject(ethutil.Hex2Bytes(exec["address"]))
+ closure := ethvm.NewClosure(nil, caller, callee, callee.Code, ethutil.Big(exec["gas"]), ethutil.Big(exec["gasPrice"]))
+
+ vm := ethvm.New(NewEnvFromMap(state, env, exec), ethvm.DebugVmTy)
+ ret, _, e := closure.Call(vm, nil)
+ if e != nil {
+ fmt.Println(e)
+ }
+
+ return ret, closure.Gas
+}
diff --git a/tests/vm/.ethtest b/tests/vm/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac8d47fe62891f3711baed92b572c2de266bb2ad
--- /dev/null
+++ b/tests/vm/gh_test.go
@@ -0,0 +1,81 @@
+package ethvm
+
+import (
+ "bytes"
+ "log"
+ "testing"
+
+ "github.com/ethereum/eth-go/ethstate"
+ "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/eth-go/tests/helper"
+)
+
+type Account struct {
+ Balance string
+ Code string
+ Nonce string
+ Storage map[string]string
+}
+
+func StateObjectFromAccount(addr string, account Account) *ethstate.StateObject {
+ obj := ethstate.NewStateObject(ethutil.Hex2Bytes(addr))
+ obj.Balance = 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 TestRemote(t *testing.T) {
+ tests := make(map[string]VmTest)
+ err := helper.CreateTests("https://raw.githubusercontent.com/ethereum/tests/master/vmtests/vmSha3Test.json", &tests)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ for name, test := range tests {
+ state := ethstate.New(helper.NewTrie())
+ for addr, account := range test.Pre {
+ obj := StateObjectFromAccount(addr, account)
+ state.SetStateObject(obj)
+ }
+
+ ret, gas := helper.RunVm(state, test.Env, test.Exec)
+
+ 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.GetStorage(ethutil.BigD(helper.FromHex(addr))).Bytes()
+ vexp := helper.FromHex(value)
+
+ if bytes.Compare(v, vexp) != 0 {
+ t.Errorf("%s's : %s storage failed. Expected %x, get %x\n", name, addr, vexp, v)
+ }
+ }
+ }
+ }
+}