github.com/datachainlab/burrow@v0.25.0/execution/evm/state_test.go (about)

     1  package evm
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/hyperledger/burrow/binary"
     8  
     9  	"github.com/hyperledger/burrow/acm/acmstate"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/hyperledger/burrow/execution/errors"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestState_PushError(t *testing.T) {
    17  	st := NewState(newAppState(), blockHashGetter)
    18  	// This will be a wrapped nil - it should not register as first error
    19  	var ex errors.CodedError = (*errors.Exception)(nil)
    20  	st.PushError(ex)
    21  	// This one should
    22  	realErr := errors.ErrorCodef(errors.ErrorCodeInsufficientBalance, "real error")
    23  	st.PushError(realErr)
    24  	assert.True(t, realErr.Equal(st.Error()))
    25  }
    26  
    27  func TestState_CreateAccount(t *testing.T) {
    28  	st := NewState(newAppState(), blockHashGetter)
    29  	address := newAddress("frogs")
    30  	st.CreateAccount(address)
    31  	require.Nil(t, st.Error())
    32  	st.CreateAccount(address)
    33  	assertErrorCode(t, errors.ErrorCodeDuplicateAddress, st.Error())
    34  
    35  	st = NewState(newAppState(), blockHashGetter)
    36  	st.CreateAccount(address)
    37  	require.Nil(t, st.Error())
    38  	st.InitCode(address, []byte{1, 2, 3})
    39  	require.Nil(t, st.Error())
    40  }
    41  
    42  func TestState_Sync(t *testing.T) {
    43  	backend := acmstate.NewCache(newAppState())
    44  	st := NewState(backend, blockHashGetter)
    45  	address := newAddress("frogs")
    46  
    47  	st.CreateAccount(address)
    48  	amt := uint64(1232)
    49  	st.AddToBalance(address, amt)
    50  
    51  	var err error
    52  	err = st.Sync()
    53  	require.Nil(t, err)
    54  	acc, err := backend.GetAccount(address)
    55  	require.NoError(t, err)
    56  	assert.Equal(t, acc.Balance, amt)
    57  }
    58  
    59  func TestState_NewCache(t *testing.T) {
    60  	st := NewState(newAppState(), blockHashGetter)
    61  	address := newAddress("frogs")
    62  
    63  	cache := st.NewCache()
    64  	cache.CreateAccount(address)
    65  	amt := uint64(1232)
    66  	cache.AddToBalance(address, amt)
    67  
    68  	var err error
    69  	assert.Equal(t, uint64(0), st.GetBalance(address))
    70  	require.Nil(t, st.Error())
    71  
    72  	// Sync through to cache
    73  	err = cache.Sync()
    74  	require.NoError(t, err)
    75  	assert.Equal(t, amt, st.GetBalance(address))
    76  	require.Nil(t, st.Error())
    77  
    78  	cache = st.NewCache(acmstate.ReadOnly).NewCache()
    79  	require.Nil(t, st.Error())
    80  	cache.AddToBalance(address, amt)
    81  	assertErrorCode(t, errors.ErrorCodeIllegalWrite, cache.Error())
    82  }
    83  
    84  func blockHashGetter(height uint64) []byte {
    85  	return binary.LeftPadWord256([]byte(fmt.Sprintf("block_hash_%d", height))).Bytes()
    86  }