github.com/ontio/ontology@v1.14.4/vm/neovm/value_stack_test.go (about)

     1  /*
     2   * Copyright (C) 2018 The ontology Authors
     3   * This file is part of The ontology library.
     4   *
     5   * The ontology is free software: you can redistribute it and/or modify
     6   * it under the terms of the GNU Lesser General Public License as published by
     7   * the Free Software Foundation, either version 3 of the License, or
     8   * (at your option) any later version.
     9   *
    10   * The ontology is distributed in the hope that it will be useful,
    11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13   * GNU Lesser General Public License for more details.
    14   *
    15   * You should have received a copy of the GNU Lesser General Public License
    16   * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
    17   */
    18  
    19  package neovm
    20  
    21  import (
    22  	"math/big"
    23  	"testing"
    24  
    25  	"github.com/ontio/ontology/vm/neovm/types"
    26  	"github.com/stretchr/testify/assert"
    27  )
    28  
    29  func TestValueStack_Count(t *testing.T) {
    30  	r := NewValueStack(4)
    31  	val, err := types.VmValueFromBigInt(big.NewInt(9999))
    32  	assert.Equal(t, err, nil)
    33  	err = r.Push(val)
    34  	assert.Equal(t, err, nil)
    35  	val2, err := types.VmValueFromBigInt(big.NewInt(8888))
    36  	assert.Equal(t, err, nil)
    37  	r.Push(val2)
    38  	assert.Equal(t, r.Count(), 2)
    39  
    40  }
    41  
    42  func TestValueStack_Pop(t *testing.T) {
    43  	r := NewValueStack(4)
    44  	val, err := types.VmValueFromBigInt(big.NewInt(9999))
    45  	assert.Equal(t, err, nil)
    46  	err = r.Push(val)
    47  	assert.Equal(t, err, nil)
    48  	val2, err := types.VmValueFromBigInt(big.NewInt(8888))
    49  	assert.Equal(t, err, nil)
    50  	r.Push(val2)
    51  	val, err = r.Remove(0)
    52  	assert.Equal(t, err, nil)
    53  	i, err := val.AsInt64()
    54  	assert.Equal(t, err, nil)
    55  	assert.Equal(t, i, int64(8888))
    56  
    57  }
    58  
    59  func TestValueStack_Peek(t *testing.T) {
    60  	r := NewValueStack(4)
    61  	val, err := types.VmValueFromBigInt(big.NewInt(9999))
    62  	assert.Equal(t, err, nil)
    63  	err = r.Push(val)
    64  	assert.Equal(t, err, nil)
    65  	val2, err := types.VmValueFromBigInt(big.NewInt(8888))
    66  	assert.Equal(t, err, nil)
    67  	r.Push(val2)
    68  	val, err = r.Peek(0)
    69  	assert.Equal(t, err, nil)
    70  	val2, err = r.Peek(1)
    71  	assert.Equal(t, err, nil)
    72  
    73  	v, err := val.AsInt64()
    74  	assert.Equal(t, err, nil)
    75  	v2, err := val2.AsInt64()
    76  	assert.Equal(t, err, nil)
    77  	if v != int64(8888) || v2 != int64(9999) {
    78  		t.Fatal("stack peek test failed.")
    79  	}
    80  }
    81  
    82  func TestValueStack_Swap(t *testing.T) {
    83  	r := NewValueStack(4)
    84  	val, err := types.VmValueFromBigInt(big.NewInt(9999))
    85  	assert.Equal(t, err, nil)
    86  	err = r.Push(val)
    87  	assert.Equal(t, err, nil)
    88  	val2, err := types.VmValueFromBigInt(big.NewInt(8888))
    89  	assert.Equal(t, err, nil)
    90  	r.Push(val2)
    91  	val3, err := types.VmValueFromBigInt(big.NewInt(7777))
    92  	assert.Equal(t, err, nil)
    93  	r.Push(val3)
    94  
    95  	r.Swap(0, 2)
    96  
    97  	val, err = r.Pop()
    98  	assert.Equal(t, err, nil)
    99  	v0, err := val.AsInt64()
   100  	assert.Equal(t, err, nil)
   101  	r.Pop()
   102  	val2, err = r.Pop()
   103  	assert.Equal(t, err, nil)
   104  	v2, err := val2.AsInt64()
   105  	assert.Equal(t, err, nil)
   106  	assert.Equal(t, v0, int64(9999))
   107  	assert.Equal(t, v2, int64(7777))
   108  }
   109  
   110  func TestValueStack_CopyTo(t *testing.T) {
   111  	r := NewValueStack(0)
   112  	val, err := types.VmValueFromBigInt(big.NewInt(9999))
   113  	assert.Equal(t, err, nil)
   114  	r.Push(val)
   115  	val2, err := types.VmValueFromBigInt(big.NewInt(8888))
   116  	assert.Equal(t, err, nil)
   117  	r.Push(val2)
   118  
   119  	e := NewValueStack(0)
   120  	err = r.CopyTo(e)
   121  	assert.Equal(t, err, nil)
   122  
   123  	for k, v := range r.data {
   124  		if !v.Equals(e.data[k]) {
   125  			t.Fatal("stack copyto test failed.")
   126  		}
   127  	}
   128  }