VM: first pass at Random Access Stack object

pkg/vm/stack/stack.go

@@ -0,0 +1,123 @@
+package stack
+
+import (
+	"errors"
+	"fmt"
+)
+
+const (
+	// StackAverageSize is used to set the capacity of the stack
+	// setting this number too low, will cause extra allocations
+	StackAverageSize = 20
+)
+
+// RandomAccess represents a Random Access Stack
+type RandomAccess struct {
+	vals []Item
+}
+
+// New will return a new random access stack
+func New() *RandomAccess {
+	return &RandomAccess{
+		vals: make([]Item, 0, StackAverageSize),
+	}
+}
+
+// Items will return all items in the stack
+func (ras *RandomAccess) items() []Item {
+	return ras.vals
+}
+
+//Len will return the length of the stack
+func (ras *RandomAccess) Len() int {
+	if ras.vals == nil {
+		return -1
+	}
+	return len(ras.vals)
+}
+
+// Clear will remove all items in the stack
+func (ras *RandomAccess) Clear() {
+	ras.vals = make([]Item, 0, StackAverageSize)
+}
+
+// Pop will remove the last stack item that was added
+func (ras *RandomAccess) Pop() (Item, error) {
+	if len(ras.vals) == 0 {
+		return nil, errors.New("There are no items on the stack to pop")
+	}
+	if ras.vals == nil {
+		return nil, errors.New("Cannot pop from a nil stack")
+	}
+
+	l := len(ras.vals)
+	item := ras.vals[l-1]
+	ras.vals = ras.vals[:l-1]
+
+	return item, nil
+}
+
+// Push will put a stack item onto the top of the stack
+func (ras *RandomAccess) Push(item Item) *RandomAccess {
+	if ras.vals == nil {
+		ras.vals = make([]Item, 0, StackAverageSize)
+	}
+
+	ras.vals = append(ras.vals, item)
+
+	return ras
+}
+
+// Insert will push a stackItem onto the stack at position `n`
+// Note; index 0 is the top of the stack, which is the end of slice
+// REDO:
+func (ras *RandomAccess) Insert(n uint16, item Item) (*RandomAccess, error) {
+
+	if n == 0 {
+		return ras.Push(item), nil
+	}
+
+	if ras.vals == nil {
+		ras.vals = make([]Item, 0, StackAverageSize)
+	}
+
+	// Check that we are not inserting out of the bounds
+	stackSize := uint16(len(ras.vals))
+	if n > stackSize-1 {
+		return nil, fmt.Errorf("Tried to insert at index %d when length of stack is %d", n, len(ras.vals))
+	}
+
+	index := stackSize - n
+
+	ras.vals = append(ras.vals, item)
+	copy(ras.vals[index:], ras.vals[index-1:])
+	ras.vals[index] = item
+
+	return ras, nil
+}
+
+// Peek will check an element at a given index
+// Note: 0 is the top of the stack, which is the end of the slice
+func (ras *RandomAccess) Peek(n uint16) (Item, error) {
+
+	stackSize := uint16(len(ras.vals))
+
+	if n == 0 {
+		index := stackSize - 1
+		return ras.vals[index], nil
+	}
+
+	if ras.vals == nil {
+		return nil, errors.New("Cannot peak at a nil stack")
+	}
+
+	// Check that we are not peeking out of the bounds
+
+	if n > stackSize-1 {
+		return nil, fmt.Errorf("Tried to peek at index %d when length of stack is %d", n, len(ras.vals))
+	}
+
+	index := stackSize - n - 1
+
+	return ras.vals[index], nil
+}

pkg/vm/stack/stack_test.go

@@ -0,0 +1,188 @@
+package stack
+
+import (
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStackPushPop(t *testing.T) {
+	// Create two stack Integers
+	a, err := NewInt(big.NewInt(10))
+	if err != nil {
+		t.Fail()
+	}
+	b, err := NewInt(big.NewInt(20))
+	if err != nil {
+		t.Fail()
+	}
+
+	// Create a new stack
+	testStack := New()
+
+	// Push to stack
+	testStack.Push(a).Push(b)
+
+	// There should only be two values on the stack
+	assert.Equal(t, 2, testStack.Len())
+
+	// Pop first element and it should be equal to b
+	stackElement, err := testStack.Pop()
+	if err != nil {
+		t.Fail()
+	}
+	item, err := stackElement.Integer()
+	if err != nil {
+		t.Fail()
+	}
+	assert.Equal(t, true, item.Equal(b))
+
+	// Pop second element and it should be equal to a
+	stackElement, err = testStack.Pop()
+	if err != nil {
+		t.Fail()
+	}
+	item, err = stackElement.Integer()
+	if err != nil {
+		t.Fail()
+	}
+	assert.Equal(t, true, item.Equal(a))
+
+	// We should get an error as there are nomore items left to pop
+	stackElement, err = testStack.Pop()
+	assert.NotNil(t, err)
+
+}
+
+// For this test to pass, we should get an error when popping from a nil stack
+// and we should initialise and push an element if pushing to an empty stack
+func TestPushPopNil(t *testing.T) {
+
+	// stack is nil when initialised without New constructor
+	testStack := RandomAccess{}
+
+	// Popping from nil stack
+	// - should give an error
+	// - element returned should be nil
+	stackElement, err := testStack.Pop()
+	assert.NotNil(t, err)
+	assert.Nil(t, stackElement)
+
+	// stack should still be nil after failing to pop
+	assert.Nil(t, testStack.vals)
+
+	// create a random test stack item
+	a, err := NewInt(big.NewInt(2))
+	assert.Nil(t, err)
+
+	// push random item to stack
+	testStack.Push(a)
+
+	// push should initialise the stack and put one element on the stack
+	assert.Equal(t, 1, testStack.Len())
+}
+
+// Test passes if we can peek and modify an item
+//without modifying the value on the stack
+func TestStackPeekMutability(t *testing.T) {
+
+	testStack := New()
+
+	a, err := NewInt(big.NewInt(2))
+	assert.Nil(t, err)
+	b, err := NewInt(big.NewInt(3))
+	assert.Nil(t, err)
+
+	testStack.Push(a).Push(b)
+
+	peekedItem := testPeakInteger(t, testStack, 0)
+	assert.Equal(t, true, peekedItem.Equal(b))
+
+	// Check that by modifying the peeked value,
+	// we did not modify the item on the stack
+	peekedItem = a
+	peekedItem.val = big.NewInt(0)
+
+	// Pop item from stack and check it is still the same
+	poppedItem := testPopInteger(t, testStack)
+	assert.Equal(t, true, poppedItem.Equal(b))
+}
+func TestStackPeek(t *testing.T) {
+
+	testStack := New()
+
+	values := []int64{23, 45, 67, 89, 12, 344}
+	for _, val := range values {
+		a := testMakeStackInt(t, val)
+		testStack.Push(a)
+	}
+
+	// i starts at 0, j starts at len(values)-1
+	for i, j := 0, len(values)-1; j >= 0; i, j = i+1, j-1 {
+
+		peekedItem := testPeakInteger(t, testStack, uint16(i))
+		a := testMakeStackInt(t, values[j])
+
+		fmt.Printf("%#v\n", peekedItem.val.Int64())
+
+		assert.Equal(t, true, a.Equal(peekedItem))
+
+	}
+
+}
+
+func TestStackInsert(t *testing.T) {
+
+	testStack := New()
+
+	a := testMakeStackInt(t, 2)
+	b := testMakeStackInt(t, 4)
+	c := testMakeStackInt(t, 6)
+
+	// insert on an empty stack should put element on top
+	_, err := testStack.Insert(0, a)
+	assert.Equal(t, err, nil)
+	_, err = testStack.Insert(0, b)
+	assert.Equal(t, err, nil)
+	_, err = testStack.Insert(1, c)
+	assert.Equal(t, err, nil)
+
+	// Order should be [a,c,b]
+	pop1 := testPopInteger(t, testStack)
+	pop2 := testPopInteger(t, testStack)
+	pop3 := testPopInteger(t, testStack)
+
+	assert.Equal(t, true, pop1.Equal(b))
+	assert.Equal(t, true, pop2.Equal(c))
+	assert.Equal(t, true, pop3.Equal(a))
+
+}
+
+// helper functions
+func testPeakInteger(t *testing.T, tStack *RandomAccess, n uint16) *Int {
+	stackElement, err := tStack.Peek(n)
+	assert.Nil(t, err)
+	item, err := stackElement.Integer()
+	if err != nil {
+		t.Fail()
+	}
+	return item
+}
+
+func testPopInteger(t *testing.T, tStack *RandomAccess) *Int {
+	stackElement, err := tStack.Pop()
+	assert.Nil(t, err)
+	item, err := stackElement.Integer()
+	if err != nil {
+		t.Fail()
+	}
+	return item
+}
+
+func testMakeStackInt(t *testing.T, num int64) *Int {
+	a, err := NewInt(big.NewInt(num))
+	assert.Nil(t, err)
+	return a
+}