github.com/yinchengtsinghua/golang-Eos-dpos-Ethereum@v0.0.0-20190121132951-92cc4225ed8e/core/state/state_test.go (about)

     1  
     2  //此源码被清华学神尹成大魔王专业翻译分析并修改
     3  //尹成QQ77025077
     4  //尹成微信18510341407
     5  //尹成所在QQ群721929980
     6  //尹成邮箱 yinc13@mails.tsinghua.edu.cn
     7  //尹成毕业于清华大学,微软区块链领域全球最有价值专家
     8  //https://mvp.microsoft.com/zh-cn/PublicProfile/4033620
     9  //版权所有2014 Go Ethereum作者
    10  //此文件是Go以太坊库的一部分。
    11  //
    12  //Go-Ethereum库是免费软件：您可以重新分发它和/或修改
    13  //根据GNU发布的较低通用公共许可证的条款
    14  //自由软件基金会，或者许可证的第3版，或者
    15  //（由您选择）任何更高版本。
    16  //
    17  //Go以太坊图书馆的发行目的是希望它会有用，
    18  //但没有任何保证；甚至没有
    19  //适销性或特定用途的适用性。见
    20  //GNU较低的通用公共许可证，了解更多详细信息。
    21  //
    22  //你应该收到一份GNU较低级别的公共许可证副本
    23  //以及Go以太坊图书馆。如果没有，请参见<http://www.gnu.org/licenses/>。
    24  
    25  package state
    26  
    27  import (
    28  	"bytes"
    29  	"math/big"
    30  	"testing"
    31  
    32  	"github.com/ethereum/go-ethereum/common"
    33  	"github.com/ethereum/go-ethereum/crypto"
    34  	"github.com/ethereum/go-ethereum/ethdb"
    35  	checker "gopkg.in/check.v1"
    36  )
    37  
    38  type StateSuite struct {
    39  	db    *ethdb.MemDatabase
    40  	state *StateDB
    41  }
    42  
    43  var _ = checker.Suite(&StateSuite{})
    44  
    45  var toAddr = common.BytesToAddress
    46  
    47  func (s *StateSuite) TestDump(c *checker.C) {
    48  //生成一些条目
    49  	obj1 := s.state.GetOrNewStateObject(toAddr([]byte{0x01}))
    50  	obj1.AddBalance(big.NewInt(22))
    51  	obj2 := s.state.GetOrNewStateObject(toAddr([]byte{0x01, 0x02}))
    52  	obj2.SetCode(crypto.Keccak256Hash([]byte{3, 3, 3, 3, 3, 3, 3}), []byte{3, 3, 3, 3, 3, 3, 3})
    53  	obj3 := s.state.GetOrNewStateObject(toAddr([]byte{0x02}))
    54  	obj3.SetBalance(big.NewInt(44))
    55  
    56  //写一些给特里亚
    57  	s.state.updateStateObject(obj1)
    58  	s.state.updateStateObject(obj2)
    59  	s.state.Commit(false)
    60  
    61  //检查转储是否包含trie中的状态对象
    62  	got := string(s.state.Dump())
    63  	want := `{
    64      "root": "71edff0130dd2385947095001c73d9e28d862fc286fca2b922ca6f6f3cddfdd2",
    65      "accounts": {
    66          "0000000000000000000000000000000000000001": {
    67              "balance": "22",
    68              "nonce": 0,
    69              "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    70              "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
    71              "code": "",
    72              "storage": {}
    73          },
    74          "0000000000000000000000000000000000000002": {
    75              "balance": "44",
    76              "nonce": 0,
    77              "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    78              "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
    79              "code": "",
    80              "storage": {}
    81          },
    82          "0000000000000000000000000000000000000102": {
    83              "balance": "0",
    84              "nonce": 0,
    85              "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    86              "codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
    87              "code": "03030303030303",
    88              "storage": {}
    89          }
    90      }
    91  }`
    92  	if got != want {
    93  		c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", got, want)
    94  	}
    95  }
    96  
    97  func (s *StateSuite) SetUpTest(c *checker.C) {
    98  	s.db = ethdb.NewMemDatabase()
    99  	s.state, _ = New(common.Hash{}, NewDatabase(s.db))
   100  }
   101  
   102  func (s *StateSuite) TestNull(c *checker.C) {
   103  	address := common.HexToAddress("0x823140710bf13990e4500136726d8b55")
   104  	s.state.CreateAccount(address)
   105  //值：=common.fromhex（“0x823140710BF13990E4500136726D8B55”）
   106  	var value common.Hash
   107  	s.state.SetState(address, common.Hash{}, value)
   108  	s.state.Commit(false)
   109  	value = s.state.GetState(address, common.Hash{})
   110  	if value != (common.Hash{}) {
   111  		c.Errorf("expected empty hash. got %x", value)
   112  	}
   113  }
   114  
   115  func (s *StateSuite) TestSnapshot(c *checker.C) {
   116  	stateobjaddr := toAddr([]byte("aa"))
   117  	var storageaddr common.Hash
   118  	data1 := common.BytesToHash([]byte{42})
   119  	data2 := common.BytesToHash([]byte{43})
   120  
   121  //设置初始状态对象值
   122  	s.state.SetState(stateobjaddr, storageaddr, data1)
   123  //获取当前状态的快照
   124  	snapshot := s.state.Snapshot()
   125  
   126  //设置新状态对象值
   127  	s.state.SetState(stateobjaddr, storageaddr, data2)
   128  //还原快照
   129  	s.state.RevertToSnapshot(snapshot)
   130  
   131  //获取状态存储值
   132  	res := s.state.GetState(stateobjaddr, storageaddr)
   133  
   134  	c.Assert(data1, checker.DeepEquals, res)
   135  }
   136  
   137  func (s *StateSuite) TestSnapshotEmpty(c *checker.C) {
   138  	s.state.RevertToSnapshot(s.state.Snapshot())
   139  }
   140  
   141  //使用测试而不是检查器，因为检查器不支持
   142  //打印/登录测试（-check.vv不工作）
   143  func TestSnapshot2(t *testing.T) {
   144  	state, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
   145  
   146  	stateobjaddr0 := toAddr([]byte("so0"))
   147  	stateobjaddr1 := toAddr([]byte("so1"))
   148  	var storageaddr common.Hash
   149  
   150  	data0 := common.BytesToHash([]byte{17})
   151  	data1 := common.BytesToHash([]byte{18})
   152  
   153  	state.SetState(stateobjaddr0, storageaddr, data0)
   154  	state.SetState(stateobjaddr1, storageaddr, data1)
   155  
   156  //db，trie已经是非空值
   157  	so0 := state.getStateObject(stateobjaddr0)
   158  	so0.SetBalance(big.NewInt(42))
   159  	so0.SetNonce(43)
   160  	so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'})
   161  	so0.suicided = false
   162  	so0.deleted = false
   163  	state.setStateObject(so0)
   164  
   165  	root, _ := state.Commit(false)
   166  	state.Reset(root)
   167  
   168  //删除一个=真
   169  	so1 := state.getStateObject(stateobjaddr1)
   170  	so1.SetBalance(big.NewInt(52))
   171  	so1.SetNonce(53)
   172  	so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'})
   173  	so1.suicided = true
   174  	so1.deleted = true
   175  	state.setStateObject(so1)
   176  
   177  	so1 = state.getStateObject(stateobjaddr1)
   178  	if so1 != nil {
   179  		t.Fatalf("deleted object not nil when getting")
   180  	}
   181  
   182  	snapshot := state.Snapshot()
   183  	state.RevertToSnapshot(snapshot)
   184  
   185  	so0Restored := state.getStateObject(stateobjaddr0)
   186  //在比较之前更新延迟加载的值。
   187  	so0Restored.GetState(state.db, storageaddr)
   188  	so0Restored.Code(state.db)
   189  //未删除等于（还原）
   190  	compareStateObjects(so0Restored, so0, t)
   191  
   192  //在恢复状态副本之前和之后，删除的内容应为零。
   193  	so1Restored := state.getStateObject(stateobjaddr1)
   194  	if so1Restored != nil {
   195  		t.Fatalf("deleted object not nil after restoring snapshot: %+v", so1Restored)
   196  	}
   197  }
   198  
   199  func compareStateObjects(so0, so1 *stateObject, t *testing.T) {
   200  	if so0.Address() != so1.Address() {
   201  		t.Fatalf("Address mismatch: have %v, want %v", so0.address, so1.address)
   202  	}
   203  	if so0.Balance().Cmp(so1.Balance()) != 0 {
   204  		t.Fatalf("Balance mismatch: have %v, want %v", so0.Balance(), so1.Balance())
   205  	}
   206  	if so0.Nonce() != so1.Nonce() {
   207  		t.Fatalf("Nonce mismatch: have %v, want %v", so0.Nonce(), so1.Nonce())
   208  	}
   209  	if so0.data.Root != so1.data.Root {
   210  		t.Errorf("Root mismatch: have %x, want %x", so0.data.Root[:], so1.data.Root[:])
   211  	}
   212  	if !bytes.Equal(so0.CodeHash(), so1.CodeHash()) {
   213  		t.Fatalf("CodeHash mismatch: have %v, want %v", so0.CodeHash(), so1.CodeHash())
   214  	}
   215  	if !bytes.Equal(so0.code, so1.code) {
   216  		t.Fatalf("Code mismatch: have %v, want %v", so0.code, so1.code)
   217  	}
   218  
   219  	if len(so1.cachedStorage) != len(so0.cachedStorage) {
   220  		t.Errorf("Storage size mismatch: have %d, want %d", len(so1.cachedStorage), len(so0.cachedStorage))
   221  	}
   222  	for k, v := range so1.cachedStorage {
   223  		if so0.cachedStorage[k] != v {
   224  			t.Errorf("Storage key %x mismatch: have %v, want %v", k, so0.cachedStorage[k], v)
   225  		}
   226  	}
   227  	for k, v := range so0.cachedStorage {
   228  		if so1.cachedStorage[k] != v {
   229  			t.Errorf("Storage key %x mismatch: have %v, want none.", k, v)
   230  		}
   231  	}
   232  
   233  	if so0.suicided != so1.suicided {
   234  		t.Fatalf("suicided mismatch: have %v, want %v", so0.suicided, so1.suicided)
   235  	}
   236  	if so0.deleted != so1.deleted {
   237  		t.Fatalf("Deleted mismatch: have %v, want %v", so0.deleted, so1.deleted)
   238  	}
   239  }