neoneo-go/pkg/vm/stack_test.go

package vm

import (
	"math/big"
	"testing"

	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestPushElement(t *testing.T) {
	elems := makeElements(10)
	s := NewStack("test")
	for _, elem := range elems {
		s.Push(elem)
	}

	assert.Equal(t, len(elems), s.Len())

	for i := 0; i < len(elems); i++ {
		assert.Equal(t, elems[len(elems)-1-i], s.Peek(i))
	}
}

func TestStack_PushVal(t *testing.T) {
	type (
		i32      int32
		testByte uint8
	)

	s := NewStack("test")
	require.NotPanics(t, func() { s.PushVal(i32(123)) })
	require.NotPanics(t, func() { s.PushVal(testByte(42)) })
	require.Equal(t, 2, s.Len())
	require.Equal(t, big.NewInt(42), s.Pop().Value())
	require.Equal(t, big.NewInt(123), s.Pop().Value())
}

func TestPopElement(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}

	for i := len(elems) - 1; i >= 0; i-- {
		assert.Equal(t, elems[i], s.Pop())
		assert.Equal(t, i, s.Len())
	}
}

func TestPeekElement(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}
	for i := len(elems) - 1; i >= 0; i-- {
		assert.Equal(t, elems[i], s.Peek(len(elems)-i-1))
	}
}

func TestRemoveAt(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}

	elem := s.RemoveAt(8)
	assert.Equal(t, elems[1], elem)
	assert.Nil(t, elem.prev)
	assert.Nil(t, elem.next)
	assert.Nil(t, elem.stack)

	// Test if the pointers are moved.
	assert.Equal(t, elems[0], s.Peek(8))
	assert.Equal(t, elems[2], s.Peek(7))
}

func TestPushFromOtherStack(t *testing.T) {
	var (
		s1    = NewStack("test")
		s2    = NewStack("test2")
		elems = makeElements(2)
	)
	for _, elem := range elems {
		s1.Push(elem)
	}
	s2.Push(NewElement(100))
	s2.Push(NewElement(101))

	s1.Push(s2.Pop())
	assert.Equal(t, len(elems)+1, s1.Len())
	assert.Equal(t, 1, s2.Len())
}

func TestDupElement(t *testing.T) {
	s := NewStack("test")
	elemA := NewElement(101)
	s.Push(elemA)

	dupped := s.Dup(0)
	s.Push(dupped)
	assert.Equal(t, 2, s.Len())
	assert.Equal(t, dupped, s.Peek(0))
}

func TestBack(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}

	assert.Equal(t, elems[0], s.Back())
}

func TestTop(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}

	assert.Equal(t, elems[len(elems)-1], s.Top())
}

func TestRemoveLastElement(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(2)
	)
	for _, elem := range elems {
		s.Push(elem)
	}
	elem := s.RemoveAt(1)
	assert.Equal(t, elems[0], elem)
	assert.Nil(t, elem.prev)
	assert.Nil(t, elem.next)
	assert.Equal(t, 1, s.Len())
}

func TestIterAfterRemove(t *testing.T) {
	var (
		s     = NewStack("test")
		elems = makeElements(10)
	)
	for _, elem := range elems {
		s.Push(elem)
	}
	s.RemoveAt(0)

	i := 0
	s.Iter(func(elem *Element) {
		i++
	})
	assert.Equal(t, len(elems)-1, i)
}

func TestIteration(t *testing.T) {
	var (
		n     = 10
		s     = NewStack("test")
		elems = makeElements(n)
	)
	for _, elem := range elems {
		s.Push(elem)
	}
	assert.Equal(t, len(elems), s.Len())

	iteratedElems := make([]*Element, 0)

	s.Iter(func(elem *Element) {
		iteratedElems = append(iteratedElems, elem)
	})
	// Top to bottom order of iteration.
	poppedElems := make([]*Element, 0)
	for elem := s.Pop(); elem != nil; elem = s.Pop() {
		poppedElems = append(poppedElems, elem)
	}
	assert.Equal(t, poppedElems, iteratedElems)
}

func TestBackIteration(t *testing.T) {
	var (
		n     = 10
		s     = NewStack("test")
		elems = makeElements(n)
	)
	for _, elem := range elems {
		s.Push(elem)
	}
	assert.Equal(t, len(elems), s.Len())

	iteratedElems := make([]*Element, 0)

	s.IterBack(func(elem *Element) {
		iteratedElems = append(iteratedElems, elem)
	})
	// Bottom to the top order of iteration.
	assert.Equal(t, elems, iteratedElems)
}

func TestPushVal(t *testing.T) {
	s := NewStack("test")

	// integer
	s.PushVal(2)
	elem := s.Pop()
	assert.Equal(t, int64(2), elem.BigInt().Int64())

	// byteArray
	s.PushVal([]byte("foo"))
	elem = s.Pop()
	assert.Equal(t, "foo", string(elem.Bytes()))

	// boolean
	s.PushVal(true)
	elem = s.Pop()
	assert.Equal(t, true, elem.Bool())

	// array
	s.PushVal([]stackitem.Item{stackitem.NewBool(true), stackitem.NewBool(false), stackitem.NewBool(true)})
	elem = s.Pop()
	assert.IsType(t, elem.value, &stackitem.Array{})
}

func TestStack_ToArray(t *testing.T) {
	t.Run("Empty", func(t *testing.T) {
		s := NewStack("test")
		items := s.ToArray()
		require.Equal(t, 0, len(items))
	})
	t.Run("NonEmpty", func(t *testing.T) {
		s := NewStack("test")
		expected := []stackitem.Item{stackitem.Make(1), stackitem.Make(true)}
		for i := range expected {
			s.PushVal(expected[i])
		}
		require.Equal(t, expected, s.ToArray())
	})
}

func TestSwapElemValues(t *testing.T) {
	s := NewStack("test")

	s.PushVal(2)
	s.PushVal(4)

	assert.NoError(t, s.Swap(0, 1))
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())

	s.PushVal(1)
	s.PushVal(2)
	s.PushVal(3)
	s.PushVal(4)

	assert.NoError(t, s.Swap(1, 3))
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(1), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(3), s.Pop().BigInt().Int64())

	s.PushVal(1)
	s.PushVal(2)
	s.PushVal(3)
	s.PushVal(4)

	assert.Error(t, s.Swap(-1, 0))
	assert.Error(t, s.Swap(0, -3))
	assert.Error(t, s.Swap(0, 4))
	assert.Error(t, s.Swap(5, 0))

	assert.NoError(t, s.Swap(1, 1))
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(3), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(1), s.Pop().BigInt().Int64())
}

func TestRoll(t *testing.T) {
	s := NewStack("test")

	s.PushVal(1)
	s.PushVal(2)
	s.PushVal(3)
	s.PushVal(4)

	assert.NoError(t, s.Roll(2))
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(3), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(1), s.Pop().BigInt().Int64())

	s.PushVal(1)
	s.PushVal(2)
	s.PushVal(3)
	s.PushVal(4)

	assert.NoError(t, s.Roll(3))
	assert.Equal(t, int64(1), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(3), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())

	s.PushVal(1)
	s.PushVal(2)
	s.PushVal(3)
	s.PushVal(4)

	assert.Error(t, s.Roll(-1))
	assert.Error(t, s.Roll(4))

	assert.NoError(t, s.Roll(0))
	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(3), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(2), s.Pop().BigInt().Int64())
	assert.Equal(t, int64(1), s.Pop().BigInt().Int64())
}

func TestPopSigElements(t *testing.T) {
	s := NewStack("test")

	_, err := s.PopSigElements()
	assert.NotNil(t, err)

	s.PushVal([]stackitem.Item{})
	_, err = s.PopSigElements()
	assert.NotNil(t, err)

	s.PushVal([]stackitem.Item{stackitem.NewBool(false)})
	_, err = s.PopSigElements()
	assert.NotNil(t, err)

	b1 := []byte("smth")
	b2 := []byte("strange")
	s.PushVal([]stackitem.Item{stackitem.NewByteArray(b1), stackitem.NewByteArray(b2)})
	z, err := s.PopSigElements()
	assert.Nil(t, err)
	assert.Equal(t, z, [][]byte{b1, b2})

	s.PushVal(2)
	_, err = s.PopSigElements()
	assert.NotNil(t, err)

	s.PushVal(b1)
	s.PushVal(2)
	_, err = s.PopSigElements()
	assert.NotNil(t, err)

	s.PushVal(b2)
	s.PushVal(b1)
	s.PushVal(2)
	z, err = s.PopSigElements()
	assert.Nil(t, err)
	assert.Equal(t, z, [][]byte{b1, b2})
}

func makeElements(n int) []*Element {
	elems := make([]*Element, n)
	for i := 0; i < n; i++ {
		elems[i] = NewElement(i)
	}
	return elems
}