diff --git a/tests/helper/common.go b/tests/helper/common.go new file mode 100644 index 0000000000..3d539ebb05 --- /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 0000000000..b379695d03 --- /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 0000000000..1f2ee208ab --- /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 0000000000..af828685c6 --- /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 0000000000..49a0bfeae9 --- /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 0000000000..e69de29bb2 diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go new file mode 100644 index 0000000000..ac8d47fe62 --- /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) + } + } + } + } +}