2015-07-06 17:54:22 -07:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 09:48:40 -07:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-06 17:54:22 -07:00
|
|
|
//
|
2015-07-23 09:35:11 -07:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-06 17:54:22 -07:00
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2015-07-22 09:48:40 -07:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-06 17:54:22 -07:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2014-10-31 06:45:03 -07:00
|
|
|
package trie
|
2014-02-14 14:56:09 -08:00
|
|
|
|
|
|
|
import (
|
2014-11-18 10:52:45 -08:00
|
|
|
"bytes"
|
2015-06-30 05:54:37 -07:00
|
|
|
"encoding/binary"
|
2014-05-25 15:09:38 -07:00
|
|
|
"fmt"
|
2015-06-30 05:54:37 -07:00
|
|
|
"io/ioutil"
|
2016-09-29 07:51:32 -07:00
|
|
|
"math/rand"
|
2015-06-30 05:54:37 -07:00
|
|
|
"os"
|
2016-09-29 07:51:32 -07:00
|
|
|
"reflect"
|
2014-11-18 10:52:45 -08:00
|
|
|
"testing"
|
2016-09-29 07:51:32 -07:00
|
|
|
"testing/quick"
|
2014-11-15 18:21:55 -08:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
"github.com/davecgh/go-spew/spew"
|
2015-03-16 03:27:38 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2015-06-30 05:54:37 -07:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2014-02-14 14:56:09 -08:00
|
|
|
)
|
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
func init() {
|
|
|
|
spew.Config.Indent = " "
|
|
|
|
spew.Config.DisableMethods = true
|
2014-02-15 04:21:11 -08:00
|
|
|
}
|
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
// Used for testing
|
|
|
|
func newEmpty() *Trie {
|
|
|
|
db, _ := ethdb.NewMemDatabase()
|
|
|
|
trie, _ := New(common.Hash{}, db)
|
|
|
|
return trie
|
2015-03-03 03:15:58 -08:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestEmptyTrie(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
var trie Trie
|
2015-01-08 02:47:04 -08:00
|
|
|
res := trie.Hash()
|
2015-07-05 16:19:48 -07:00
|
|
|
exp := emptyRoot
|
|
|
|
if res != common.Hash(exp) {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("expected %x got %x", exp, res)
|
|
|
|
}
|
2014-02-15 04:21:11 -08:00
|
|
|
}
|
|
|
|
|
2015-03-19 02:57:02 -07:00
|
|
|
func TestNull(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
var trie Trie
|
2015-03-19 02:57:02 -07:00
|
|
|
key := make([]byte, 32)
|
|
|
|
value := common.FromHex("0x823140710bf13990e4500136726d8b55")
|
|
|
|
trie.Update(key, value)
|
|
|
|
value = trie.Get(key)
|
|
|
|
}
|
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
func TestMissingRoot(t *testing.T) {
|
|
|
|
db, _ := ethdb.NewMemDatabase()
|
|
|
|
trie, err := New(common.HexToHash("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), db)
|
|
|
|
if trie != nil {
|
|
|
|
t.Error("New returned non-nil trie for invalid root")
|
|
|
|
}
|
2015-11-25 09:28:21 -08:00
|
|
|
if _, ok := err.(*MissingNodeError); !ok {
|
2016-04-15 02:06:57 -07:00
|
|
|
t.Errorf("New returned wrong error: %v", err)
|
2015-07-05 16:19:48 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-25 09:28:21 -08:00
|
|
|
func TestMissingNode(t *testing.T) {
|
|
|
|
db, _ := ethdb.NewMemDatabase()
|
|
|
|
trie, _ := New(common.Hash{}, db)
|
|
|
|
updateString(trie, "120000", "qwerqwerqwerqwerqwerqwerqwerqwer")
|
|
|
|
updateString(trie, "123456", "asdfasdfasdfasdfasdfasdfasdfasdf")
|
|
|
|
root, _ := trie.Commit()
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err := trie.TryGet([]byte("120000"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err = trie.TryGet([]byte("120099"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err = trie.TryGet([]byte("123456"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
err = trie.TryUpdate([]byte("120099"), []byte("zxcvzxcvzxcvzxcvzxcvzxcvzxcvzxcv"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
err = trie.TryDelete([]byte("123456"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
db.Delete(common.FromHex("e1d943cc8f061a0c0b98162830b970395ac9315654824bf21b73b891365262f9"))
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err = trie.TryGet([]byte("120000"))
|
|
|
|
if _, ok := err.(*MissingNodeError); !ok {
|
|
|
|
t.Errorf("Wrong error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err = trie.TryGet([]byte("120099"))
|
|
|
|
if _, ok := err.(*MissingNodeError); !ok {
|
|
|
|
t.Errorf("Wrong error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
_, err = trie.TryGet([]byte("123456"))
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
err = trie.TryUpdate([]byte("120099"), []byte("zxcv"))
|
|
|
|
if _, ok := err.(*MissingNodeError); !ok {
|
|
|
|
t.Errorf("Wrong error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
trie, _ = New(root, db)
|
|
|
|
err = trie.TryDelete([]byte("123456"))
|
|
|
|
if _, ok := err.(*MissingNodeError); !ok {
|
|
|
|
t.Errorf("Wrong error: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestInsert(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2014-02-15 04:21:11 -08:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
updateString(trie, "doe", "reindeer")
|
|
|
|
updateString(trie, "dog", "puppy")
|
|
|
|
updateString(trie, "dogglesworth", "cat")
|
2014-02-15 04:21:11 -08:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
exp := common.HexToHash("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3")
|
2015-01-08 02:47:04 -08:00
|
|
|
root := trie.Hash()
|
2015-07-05 16:19:48 -07:00
|
|
|
if root != exp {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("exp %x got %x", exp, root)
|
|
|
|
}
|
2014-02-20 05:40:00 -08:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
trie = newEmpty()
|
|
|
|
updateString(trie, "A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
2014-02-20 05:40:00 -08:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
exp = common.HexToHash("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab")
|
|
|
|
root, err := trie.Commit()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("commit error: %v", err)
|
|
|
|
}
|
|
|
|
if root != exp {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("exp %x got %x", exp, root)
|
|
|
|
}
|
2014-02-20 05:40:00 -08:00
|
|
|
}
|
2014-02-24 03:11:00 -08:00
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestGet(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
|
|
|
updateString(trie, "doe", "reindeer")
|
|
|
|
updateString(trie, "dog", "puppy")
|
|
|
|
updateString(trie, "dogglesworth", "cat")
|
|
|
|
|
|
|
|
for i := 0; i < 2; i++ {
|
|
|
|
res := getString(trie, "dog")
|
|
|
|
if !bytes.Equal(res, []byte("puppy")) {
|
|
|
|
t.Errorf("expected puppy got %x", res)
|
|
|
|
}
|
2014-05-25 15:09:38 -07:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
unknown := getString(trie, "unknown")
|
|
|
|
if unknown != nil {
|
|
|
|
t.Errorf("expected nil got %x", unknown)
|
|
|
|
}
|
2014-06-30 04:08:00 -07:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
if i == 1 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
trie.Commit()
|
2014-06-17 09:05:46 -07:00
|
|
|
}
|
2014-06-30 04:08:00 -07:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestDelete(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2015-01-08 02:47:04 -08:00
|
|
|
vals := []struct{ k, v string }{
|
|
|
|
{"do", "verb"},
|
|
|
|
{"ether", "wookiedoo"},
|
|
|
|
{"horse", "stallion"},
|
|
|
|
{"shaman", "horse"},
|
|
|
|
{"doge", "coin"},
|
|
|
|
{"ether", ""},
|
|
|
|
{"dog", "puppy"},
|
|
|
|
{"shaman", ""},
|
2014-06-17 09:05:46 -07:00
|
|
|
}
|
2015-01-08 02:47:04 -08:00
|
|
|
for _, val := range vals {
|
|
|
|
if val.v != "" {
|
2015-07-05 16:19:48 -07:00
|
|
|
updateString(trie, val.k, val.v)
|
2015-01-08 02:47:04 -08:00
|
|
|
} else {
|
2015-07-05 16:19:48 -07:00
|
|
|
deleteString(trie, val.k)
|
2015-01-08 02:47:04 -08:00
|
|
|
}
|
2014-06-30 04:08:00 -07:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
hash := trie.Hash()
|
2015-07-05 16:19:48 -07:00
|
|
|
exp := common.HexToHash("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84")
|
|
|
|
if hash != exp {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("expected %x got %x", exp, hash)
|
2014-06-30 04:08:00 -07:00
|
|
|
}
|
2015-01-08 02:47:04 -08:00
|
|
|
}
|
2014-05-26 16:08:51 -07:00
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestEmptyValues(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2014-06-30 04:08:00 -07:00
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
vals := []struct{ k, v string }{
|
|
|
|
{"do", "verb"},
|
|
|
|
{"ether", "wookiedoo"},
|
|
|
|
{"horse", "stallion"},
|
|
|
|
{"shaman", "horse"},
|
|
|
|
{"doge", "coin"},
|
|
|
|
{"ether", ""},
|
|
|
|
{"dog", "puppy"},
|
|
|
|
{"shaman", ""},
|
2014-06-30 04:08:00 -07:00
|
|
|
}
|
2015-01-08 02:47:04 -08:00
|
|
|
for _, val := range vals {
|
2015-07-05 16:19:48 -07:00
|
|
|
updateString(trie, val.k, val.v)
|
2014-07-01 00:55:20 -07:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
hash := trie.Hash()
|
2015-07-05 16:19:48 -07:00
|
|
|
exp := common.HexToHash("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84")
|
|
|
|
if hash != exp {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("expected %x got %x", exp, hash)
|
2014-06-17 09:05:46 -07:00
|
|
|
}
|
2014-07-01 00:55:20 -07:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
func TestReplication(t *testing.T) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2015-01-08 02:47:04 -08:00
|
|
|
vals := []struct{ k, v string }{
|
|
|
|
{"do", "verb"},
|
|
|
|
{"ether", "wookiedoo"},
|
|
|
|
{"horse", "stallion"},
|
|
|
|
{"shaman", "horse"},
|
|
|
|
{"doge", "coin"},
|
|
|
|
{"dog", "puppy"},
|
|
|
|
{"somethingveryoddindeedthis is", "myothernodedata"},
|
2014-06-17 09:05:46 -07:00
|
|
|
}
|
2015-01-08 02:47:04 -08:00
|
|
|
for _, val := range vals {
|
2015-07-05 16:19:48 -07:00
|
|
|
updateString(trie, val.k, val.v)
|
2015-01-08 02:47:04 -08:00
|
|
|
}
|
2015-07-05 16:19:48 -07:00
|
|
|
exp, err := trie.Commit()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("commit error: %v", err)
|
2015-01-08 02:47:04 -08:00
|
|
|
}
|
2014-07-15 06:29:54 -07:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
// create a new trie on top of the database and check that lookups work.
|
|
|
|
trie2, err := New(exp, trie.db)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't recreate trie at %x: %v", exp, err)
|
|
|
|
}
|
|
|
|
for _, kv := range vals {
|
|
|
|
if string(getString(trie2, kv.k)) != kv.v {
|
|
|
|
t.Errorf("trie2 doesn't have %q => %q", kv.k, kv.v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
hash, err := trie2.Commit()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("commit error: %v", err)
|
|
|
|
}
|
|
|
|
if hash != exp {
|
2015-01-08 02:47:04 -08:00
|
|
|
t.Errorf("root failure. expected %x got %x", exp, hash)
|
|
|
|
}
|
2014-07-17 02:21:18 -07:00
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
// perform some insertions on the new trie.
|
|
|
|
vals2 := []struct{ k, v string }{
|
2015-01-08 02:47:04 -08:00
|
|
|
{"do", "verb"},
|
|
|
|
{"ether", "wookiedoo"},
|
|
|
|
{"horse", "stallion"},
|
2015-07-05 16:19:48 -07:00
|
|
|
// {"shaman", "horse"},
|
|
|
|
// {"doge", "coin"},
|
|
|
|
// {"ether", ""},
|
|
|
|
// {"dog", "puppy"},
|
|
|
|
// {"somethingveryoddindeedthis is", "myothernodedata"},
|
|
|
|
// {"shaman", ""},
|
2014-10-10 08:00:06 -07:00
|
|
|
}
|
2015-07-05 16:19:48 -07:00
|
|
|
for _, val := range vals2 {
|
|
|
|
updateString(trie2, val.k, val.v)
|
2014-10-10 08:00:06 -07:00
|
|
|
}
|
2016-05-19 03:24:14 -07:00
|
|
|
if hash := trie2.Hash(); hash != exp {
|
2015-07-05 16:19:48 -07:00
|
|
|
t.Errorf("root failure. expected %x got %x", exp, hash)
|
|
|
|
}
|
|
|
|
}
|
2014-11-14 13:19:50 -08:00
|
|
|
|
2015-01-08 02:47:04 -08:00
|
|
|
// Not an actual test
|
|
|
|
func TestOutput(t *testing.T) {
|
|
|
|
t.Skip()
|
|
|
|
|
|
|
|
base := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2015-01-08 02:47:04 -08:00
|
|
|
for i := 0; i < 50; i++ {
|
2015-07-05 16:19:48 -07:00
|
|
|
updateString(trie, fmt.Sprintf("%s%d", base, i), "valueeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
|
2015-01-08 02:47:04 -08:00
|
|
|
}
|
|
|
|
fmt.Println("############################## FULL ################################")
|
|
|
|
fmt.Println(trie.root)
|
|
|
|
|
|
|
|
trie.Commit()
|
|
|
|
fmt.Println("############################## SMALL ################################")
|
2015-07-05 16:19:48 -07:00
|
|
|
trie2, _ := New(trie.Hash(), trie.db)
|
|
|
|
getString(trie2, base+"20")
|
2015-01-08 02:47:04 -08:00
|
|
|
fmt.Println(trie2.root)
|
|
|
|
}
|
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
func TestLargeValue(t *testing.T) {
|
|
|
|
trie := newEmpty()
|
|
|
|
trie.Update([]byte("key1"), []byte{99, 99, 99, 99})
|
|
|
|
trie.Update([]byte("key2"), bytes.Repeat([]byte{1}, 32))
|
|
|
|
trie.Hash()
|
2016-09-29 07:51:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type randTestStep struct {
|
|
|
|
op int
|
|
|
|
key []byte // for opUpdate, opDelete, opGet
|
|
|
|
value []byte // for opUpdate
|
|
|
|
}
|
|
|
|
|
|
|
|
type randTest []randTestStep
|
|
|
|
|
|
|
|
const (
|
|
|
|
opUpdate = iota
|
|
|
|
opDelete
|
|
|
|
opGet
|
|
|
|
opCommit
|
|
|
|
opHash
|
|
|
|
opReset
|
|
|
|
opItercheckhash
|
|
|
|
opMax // boundary value, not an actual op
|
|
|
|
)
|
|
|
|
|
|
|
|
func (randTest) Generate(r *rand.Rand, size int) reflect.Value {
|
|
|
|
var allKeys [][]byte
|
|
|
|
genKey := func() []byte {
|
|
|
|
if len(allKeys) < 2 || r.Intn(100) < 10 {
|
|
|
|
// new key
|
|
|
|
key := make([]byte, r.Intn(50))
|
|
|
|
randRead(r, key)
|
|
|
|
allKeys = append(allKeys, key)
|
|
|
|
return key
|
|
|
|
}
|
|
|
|
// use existing key
|
|
|
|
return allKeys[r.Intn(len(allKeys))]
|
|
|
|
}
|
|
|
|
|
|
|
|
var steps randTest
|
|
|
|
for i := 0; i < size; i++ {
|
|
|
|
step := randTestStep{op: r.Intn(opMax)}
|
|
|
|
switch step.op {
|
|
|
|
case opUpdate:
|
|
|
|
step.key = genKey()
|
|
|
|
step.value = make([]byte, 8)
|
|
|
|
binary.BigEndian.PutUint64(step.value, uint64(i))
|
|
|
|
case opGet, opDelete:
|
|
|
|
step.key = genKey()
|
|
|
|
}
|
|
|
|
steps = append(steps, step)
|
|
|
|
}
|
|
|
|
return reflect.ValueOf(steps)
|
|
|
|
}
|
|
|
|
|
|
|
|
// rand.Rand provides a Read method in Go 1.7 and later, but
|
|
|
|
// we can't use it yet.
|
|
|
|
func randRead(r *rand.Rand, b []byte) {
|
|
|
|
pos := 0
|
|
|
|
val := 0
|
|
|
|
for n := 0; n < len(b); n++ {
|
|
|
|
if pos == 0 {
|
|
|
|
val = r.Int()
|
|
|
|
pos = 7
|
|
|
|
}
|
|
|
|
b[n] = byte(val)
|
|
|
|
val >>= 8
|
|
|
|
pos--
|
|
|
|
}
|
|
|
|
}
|
2015-07-05 16:19:48 -07:00
|
|
|
|
2016-09-29 07:51:32 -07:00
|
|
|
func runRandTest(rt randTest) bool {
|
|
|
|
db, _ := ethdb.NewMemDatabase()
|
|
|
|
tr, _ := New(common.Hash{}, db)
|
|
|
|
values := make(map[string]string) // tracks content of the trie
|
|
|
|
|
|
|
|
for _, step := range rt {
|
|
|
|
switch step.op {
|
|
|
|
case opUpdate:
|
|
|
|
tr.Update(step.key, step.value)
|
|
|
|
values[string(step.key)] = string(step.value)
|
|
|
|
case opDelete:
|
|
|
|
tr.Delete(step.key)
|
|
|
|
delete(values, string(step.key))
|
|
|
|
case opGet:
|
|
|
|
v := tr.Get(step.key)
|
|
|
|
want := values[string(step.key)]
|
|
|
|
if string(v) != want {
|
|
|
|
fmt.Printf("mismatch for key 0x%x, got 0x%x want 0x%x", step.key, v, want)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
case opCommit:
|
|
|
|
if _, err := tr.Commit(); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
case opHash:
|
|
|
|
tr.Hash()
|
|
|
|
case opReset:
|
|
|
|
hash, err := tr.Commit()
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
newtr, err := New(hash, db)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
tr = newtr
|
|
|
|
case opItercheckhash:
|
|
|
|
checktr, _ := New(common.Hash{}, nil)
|
|
|
|
it := tr.Iterator()
|
|
|
|
for it.Next() {
|
|
|
|
checktr.Update(it.Key, it.Value)
|
|
|
|
}
|
|
|
|
if tr.Hash() != checktr.Hash() {
|
|
|
|
fmt.Println("hashes not equal")
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestRandom(t *testing.T) {
|
|
|
|
if err := quick.Check(runRandTest, nil); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-07-05 16:19:48 -07:00
|
|
|
}
|
|
|
|
|
2015-06-30 05:54:37 -07:00
|
|
|
func BenchmarkGet(b *testing.B) { benchGet(b, false) }
|
|
|
|
func BenchmarkGetDB(b *testing.B) { benchGet(b, true) }
|
|
|
|
func BenchmarkUpdateBE(b *testing.B) { benchUpdate(b, binary.BigEndian) }
|
|
|
|
func BenchmarkUpdateLE(b *testing.B) { benchUpdate(b, binary.LittleEndian) }
|
|
|
|
func BenchmarkHashBE(b *testing.B) { benchHash(b, binary.BigEndian) }
|
|
|
|
func BenchmarkHashLE(b *testing.B) { benchHash(b, binary.LittleEndian) }
|
|
|
|
|
|
|
|
const benchElemCount = 20000
|
|
|
|
|
|
|
|
func benchGet(b *testing.B, commit bool) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := new(Trie)
|
2015-06-30 05:54:37 -07:00
|
|
|
if commit {
|
2016-10-14 09:04:33 -07:00
|
|
|
_, tmpdb := tempDB()
|
2015-07-05 16:19:48 -07:00
|
|
|
trie, _ = New(common.Hash{}, tmpdb)
|
2015-06-30 05:54:37 -07:00
|
|
|
}
|
|
|
|
k := make([]byte, 32)
|
|
|
|
for i := 0; i < benchElemCount; i++ {
|
|
|
|
binary.LittleEndian.PutUint64(k, uint64(i))
|
|
|
|
trie.Update(k, k)
|
|
|
|
}
|
|
|
|
binary.LittleEndian.PutUint64(k, benchElemCount/2)
|
|
|
|
if commit {
|
|
|
|
trie.Commit()
|
|
|
|
}
|
|
|
|
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
trie.Get(k)
|
|
|
|
}
|
2016-10-14 09:04:33 -07:00
|
|
|
b.StopTimer()
|
|
|
|
|
|
|
|
if commit {
|
|
|
|
ldb := trie.db.(*ethdb.LDBDatabase)
|
|
|
|
ldb.Close()
|
|
|
|
os.RemoveAll(ldb.Path())
|
|
|
|
}
|
2015-06-30 05:54:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func benchUpdate(b *testing.B, e binary.ByteOrder) *Trie {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2015-06-30 05:54:37 -07:00
|
|
|
k := make([]byte, 32)
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
e.PutUint64(k, uint64(i))
|
|
|
|
trie.Update(k, k)
|
|
|
|
}
|
|
|
|
return trie
|
|
|
|
}
|
|
|
|
|
|
|
|
func benchHash(b *testing.B, e binary.ByteOrder) {
|
2015-07-05 16:19:48 -07:00
|
|
|
trie := newEmpty()
|
2015-06-30 05:54:37 -07:00
|
|
|
k := make([]byte, 32)
|
|
|
|
for i := 0; i < benchElemCount; i++ {
|
|
|
|
e.PutUint64(k, uint64(i))
|
|
|
|
trie.Update(k, k)
|
|
|
|
}
|
|
|
|
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
trie.Hash()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-05 16:19:48 -07:00
|
|
|
func tempDB() (string, Database) {
|
2015-06-30 05:54:37 -07:00
|
|
|
dir, err := ioutil.TempDir("", "trie-bench")
|
|
|
|
if err != nil {
|
|
|
|
panic(fmt.Sprintf("can't create temporary directory: %v", err))
|
|
|
|
}
|
2016-02-19 04:29:19 -08:00
|
|
|
db, err := ethdb.NewLDBDatabase(dir, 256, 0)
|
2015-06-30 05:54:37 -07:00
|
|
|
if err != nil {
|
|
|
|
panic(fmt.Sprintf("can't create temporary database: %v", err))
|
|
|
|
}
|
|
|
|
return dir, db
|
|
|
|
}
|
2015-07-05 16:19:48 -07:00
|
|
|
|
|
|
|
func getString(trie *Trie, k string) []byte {
|
|
|
|
return trie.Get([]byte(k))
|
|
|
|
}
|
|
|
|
|
|
|
|
func updateString(trie *Trie, k, v string) {
|
|
|
|
trie.Update([]byte(k), []byte(v))
|
|
|
|
}
|
|
|
|
|
|
|
|
func deleteString(trie *Trie, k string) {
|
|
|
|
trie.Delete([]byte(k))
|
|
|
|
}
|