github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/core/state/state_test.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package state 18 19 import ( 20 "bytes" 21 "math/big" 22 "testing" 23 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/core/rawdb" 26 "github.com/ethereum/go-ethereum/crypto" 27 "github.com/ethereum/go-ethereum/ethdb" 28 checker "gopkg.in/check.v1" 29 ) 30 31 type StateSuite struct { 32 db ethdb.Database 33 state *StateDB 34 } 35 36 var _ = checker.Suite(&StateSuite{}) 37 38 var toAddr = common.BytesToAddress 39 40 func (s *StateSuite) TestDump(c *checker.C) { 41 // generate a few entries 42 obj1 := s.state.GetOrNewStateObject(toAddr([]byte{0x01})) 43 obj1.AddBalance(big.NewInt(22)) 44 obj2 := s.state.GetOrNewStateObject(toAddr([]byte{0x01, 0x02})) 45 obj2.SetCode(crypto.Keccak256Hash([]byte{3, 3, 3, 3, 3, 3, 3}), []byte{3, 3, 3, 3, 3, 3, 3}) 46 obj3 := s.state.GetOrNewStateObject(toAddr([]byte{0x02})) 47 obj3.SetBalance(big.NewInt(44)) 48 49 // write some of them to the trie 50 s.state.updateStateObject(obj1) 51 s.state.updateStateObject(obj2) 52 s.state.Commit(false) 53 54 // check that dump contains the state objects that are in trie 55 got := string(s.state.Dump()) 56 want := `{ 57 "root": "71edff0130dd2385947095001c73d9e28d862fc286fca2b922ca6f6f3cddfdd2", 58 "accounts": { 59 "0000000000000000000000000000000000000001": { 60 "balance": "22", 61 "nonce": 0, 62 "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", 63 "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", 64 "code": "", 65 "storage": {} 66 }, 67 "0000000000000000000000000000000000000002": { 68 "balance": "44", 69 "nonce": 0, 70 "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", 71 "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", 72 "code": "", 73 "storage": {} 74 }, 75 "0000000000000000000000000000000000000102": { 76 "balance": "0", 77 "nonce": 0, 78 "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", 79 "codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3", 80 "code": "03030303030303", 81 "storage": {} 82 } 83 } 84 }` 85 if got != want { 86 c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", got, want) 87 } 88 } 89 90 func (s *StateSuite) SetUpTest(c *checker.C) { 91 s.db = rawdb.NewMemoryDatabase() 92 s.state, _ = New(common.Hash{}, NewDatabase(s.db)) 93 } 94 95 func (s *StateSuite) TestNull(c *checker.C) { 96 address := common.HexToAddress("0x823140710bf13990e4500136726d8b55") 97 s.state.CreateAccount(address) 98 //value := common.FromHex("0x823140710bf13990e4500136726d8b55") 99 var value common.Hash 100 101 s.state.SetState(address, common.Hash{}, value) 102 s.state.Commit(false) 103 104 if value := s.state.GetState(address, common.Hash{}); value != (common.Hash{}) { 105 c.Errorf("expected empty current value, got %x", value) 106 } 107 if value := s.state.GetCommittedState(address, common.Hash{}); value != (common.Hash{}) { 108 c.Errorf("expected empty committed value, got %x", value) 109 } 110 } 111 112 func (s *StateSuite) TestSnapshot(c *checker.C) { 113 stateobjaddr := toAddr([]byte("aa")) 114 var storageaddr common.Hash 115 data1 := common.BytesToHash([]byte{42}) 116 data2 := common.BytesToHash([]byte{43}) 117 118 // snapshot the genesis state 119 genesis := s.state.Snapshot() 120 121 // set initial state object value 122 s.state.SetState(stateobjaddr, storageaddr, data1) 123 snapshot := s.state.Snapshot() 124 125 // set a new state object value, revert it and ensure correct content 126 s.state.SetState(stateobjaddr, storageaddr, data2) 127 s.state.RevertToSnapshot(snapshot) 128 129 c.Assert(s.state.GetState(stateobjaddr, storageaddr), checker.DeepEquals, data1) 130 c.Assert(s.state.GetCommittedState(stateobjaddr, storageaddr), checker.DeepEquals, common.Hash{}) 131 132 // revert up to the genesis state and ensure correct content 133 s.state.RevertToSnapshot(genesis) 134 c.Assert(s.state.GetState(stateobjaddr, storageaddr), checker.DeepEquals, common.Hash{}) 135 c.Assert(s.state.GetCommittedState(stateobjaddr, storageaddr), checker.DeepEquals, common.Hash{}) 136 } 137 138 func (s *StateSuite) TestSnapshotEmpty(c *checker.C) { 139 s.state.RevertToSnapshot(s.state.Snapshot()) 140 } 141 142 // use testing instead of checker because checker does not support 143 // printing/logging in tests (-check.vv does not work) 144 func TestSnapshot2(t *testing.T) { 145 state, _ := New(common.Hash{}, NewDatabase(rawdb.NewMemoryDatabase())) 146 147 stateobjaddr0 := toAddr([]byte("so0")) 148 stateobjaddr1 := toAddr([]byte("so1")) 149 var storageaddr common.Hash 150 151 data0 := common.BytesToHash([]byte{17}) 152 data1 := common.BytesToHash([]byte{18}) 153 154 state.SetState(stateobjaddr0, storageaddr, data0) 155 state.SetState(stateobjaddr1, storageaddr, data1) 156 157 // db, trie are already non-empty values 158 so0 := state.getStateObject(stateobjaddr0) 159 so0.SetBalance(big.NewInt(42)) 160 so0.SetNonce(43) 161 so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'}) 162 so0.suicided = false 163 so0.deleted = false 164 state.setStateObject(so0) 165 166 root, _ := state.Commit(false) 167 state.Reset(root) 168 169 // and one with deleted == true 170 so1 := state.getStateObject(stateobjaddr1) 171 so1.SetBalance(big.NewInt(52)) 172 so1.SetNonce(53) 173 so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'}) 174 so1.suicided = true 175 so1.deleted = true 176 state.setStateObject(so1) 177 178 so1 = state.getStateObject(stateobjaddr1) 179 if so1 != nil { 180 t.Fatalf("deleted object not nil when getting") 181 } 182 183 snapshot := state.Snapshot() 184 state.RevertToSnapshot(snapshot) 185 186 so0Restored := state.getStateObject(stateobjaddr0) 187 // Update lazily-loaded values before comparing. 188 so0Restored.GetState(state.db, storageaddr) 189 so0Restored.Code(state.db) 190 // non-deleted is equal (restored) 191 compareStateObjects(so0Restored, so0, t) 192 193 // deleted should be nil, both before and after restore of state copy 194 so1Restored := state.getStateObject(stateobjaddr1) 195 if so1Restored != nil { 196 t.Fatalf("deleted object not nil after restoring snapshot: %+v", so1Restored) 197 } 198 } 199 200 func compareStateObjects(so0, so1 *stateObject, t *testing.T) { 201 if so0.Address() != so1.Address() { 202 t.Fatalf("Address mismatch: have %v, want %v", so0.address, so1.address) 203 } 204 if so0.Balance().Cmp(so1.Balance()) != 0 { 205 t.Fatalf("Balance mismatch: have %v, want %v", so0.Balance(), so1.Balance()) 206 } 207 if so0.Nonce() != so1.Nonce() { 208 t.Fatalf("Nonce mismatch: have %v, want %v", so0.Nonce(), so1.Nonce()) 209 } 210 if so0.data.Root != so1.data.Root { 211 t.Errorf("Root mismatch: have %x, want %x", so0.data.Root[:], so1.data.Root[:]) 212 } 213 if !bytes.Equal(so0.CodeHash(), so1.CodeHash()) { 214 t.Fatalf("CodeHash mismatch: have %v, want %v", so0.CodeHash(), so1.CodeHash()) 215 } 216 if !bytes.Equal(so0.code, so1.code) { 217 t.Fatalf("Code mismatch: have %v, want %v", so0.code, so1.code) 218 } 219 220 if len(so1.dirtyStorage) != len(so0.dirtyStorage) { 221 t.Errorf("Dirty storage size mismatch: have %d, want %d", len(so1.dirtyStorage), len(so0.dirtyStorage)) 222 } 223 for k, v := range so1.dirtyStorage { 224 if so0.dirtyStorage[k] != v { 225 t.Errorf("Dirty storage key %x mismatch: have %v, want %v", k, so0.dirtyStorage[k], v) 226 } 227 } 228 for k, v := range so0.dirtyStorage { 229 if so1.dirtyStorage[k] != v { 230 t.Errorf("Dirty storage key %x mismatch: have %v, want none.", k, v) 231 } 232 } 233 if len(so1.originStorage) != len(so0.originStorage) { 234 t.Errorf("Origin storage size mismatch: have %d, want %d", len(so1.originStorage), len(so0.originStorage)) 235 } 236 for k, v := range so1.originStorage { 237 if so0.originStorage[k] != v { 238 t.Errorf("Origin storage key %x mismatch: have %v, want %v", k, so0.originStorage[k], v) 239 } 240 } 241 for k, v := range so0.originStorage { 242 if so1.originStorage[k] != v { 243 t.Errorf("Origin storage key %x mismatch: have %v, want none.", k, v) 244 } 245 } 246 }