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

     1  package evm
     2  
     3  import (
     4  	"math"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/require"
     8  
     9  	"github.com/hyperledger/burrow/binary"
    10  	"github.com/hyperledger/burrow/execution/errors"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestStack_MaxDepthInt32(t *testing.T) {
    15  	var gaz uint64 = math.MaxUint64
    16  	st := NewStack(0, 0, &gaz, errors.FirstOnly())
    17  
    18  	err := st.ensureCapacity(math.MaxInt32 + 1)
    19  	assert.Error(t, err)
    20  }
    21  
    22  // Test static memory allocation with unlimited depth - memory should grow
    23  func TestStack_UnlimitedAllocation(t *testing.T) {
    24  	err := errors.FirstOnly()
    25  	var gaz uint64 = math.MaxUint64
    26  	st := NewStack(0, 0, &gaz, err)
    27  
    28  	st.Push64(math.MaxInt64)
    29  	require.NoError(t, err.Error())
    30  	assert.Equal(t, 1, len(st.slice))
    31  	assert.Equal(t, 1, cap(st.slice))
    32  }
    33  
    34  // Test static memory allocation with maximum == initial capacity - memory should not grow
    35  func TestStack_StaticAllocation(t *testing.T) {
    36  	err := errors.FirstOnly()
    37  	var gaz uint64 = math.MaxUint64
    38  	st := NewStack(4, 4, &gaz, err)
    39  
    40  	for i := 0; i < 4; i++ {
    41  		st.Push64(math.MaxInt64)
    42  		assert.NoError(t, err.Error())
    43  	}
    44  
    45  	assert.Equal(t, 4, cap(st.slice), "Slice capacity should not grow")
    46  }
    47  
    48  // Test writing beyond the current capacity - memory should grow
    49  func TestDynamicMemory_PushAhead(t *testing.T) {
    50  	err := errors.FirstOnly()
    51  	var gaz uint64 = math.MaxUint64
    52  	st := NewStack(2, 4, &gaz, err)
    53  
    54  	for i := 0; i < 4; i++ {
    55  		st.Push64(math.MaxInt64)
    56  		assert.NoError(t, err.Error())
    57  	}
    58  
    59  	st.Push64(math.MaxInt64)
    60  	assert.Equal(t, errors.ErrorCodeDataStackOverflow, err.Error().ErrorCode())
    61  }
    62  
    63  func TestStack_ZeroInitialCapacity(t *testing.T) {
    64  	err := errors.FirstOnly()
    65  	var gaz uint64 = math.MaxUint64
    66  	st := NewStack(0, 16, &gaz, err)
    67  	require.NoError(t, err.Error())
    68  	st.Push64(math.MaxInt64)
    69  	assert.Equal(t, []binary.Word256{binary.Int64ToWord256(math.MaxInt64)}, st.slice)
    70  }
    71  
    72  func TestStack_ensureCapacity(t *testing.T) {
    73  	var gaz uint64 = math.MaxUint64
    74  	st := NewStack(4, 16, &gaz, errors.FirstOnly())
    75  	// Check we can grow within bounds
    76  	err := st.ensureCapacity(8)
    77  	assert.NoError(t, err)
    78  	expected := make([]binary.Word256, 8)
    79  	assert.Equal(t, expected, st.slice)
    80  
    81  	// Check we can grow to bounds
    82  	err = st.ensureCapacity(16)
    83  	assert.NoError(t, err)
    84  	expected = make([]binary.Word256, 16)
    85  	assert.Equal(t, expected, st.slice)
    86  
    87  	err = st.ensureCapacity(1)
    88  	assert.NoError(t, err)
    89  	assert.Equal(t, 16, len(st.slice))
    90  
    91  	err = st.ensureCapacity(17)
    92  	assert.Error(t, err, "Should not be possible to grow over capacity")
    93  }