github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/core/state/native_state_test.go (about)

     1  package state
     2  
     3  import (
     4  	"math/big"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
     8  	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestNEP17Balance_Bytes(t *testing.T) {
    13  	var b NEP17Balance
    14  	b.Balance.SetInt64(0x12345678910)
    15  
    16  	data, err := stackitem.SerializeConvertible(&b)
    17  	require.NoError(t, err)
    18  	require.Equal(t, data, b.Bytes(nil))
    19  
    20  	t.Run("reuse buffer", func(t *testing.T) {
    21  		buf := make([]byte, 100)
    22  		ret := b.Bytes(buf[:0])
    23  		require.Equal(t, ret, buf[:len(ret)])
    24  	})
    25  
    26  	actual, err := NEP17BalanceFromBytes(data)
    27  	require.NoError(t, err)
    28  	require.Equal(t, &b, actual)
    29  }
    30  
    31  func TestNEP17BalanceFromBytesInvalid(t *testing.T) {
    32  	b, err := NEP17BalanceFromBytes(nil) // 0 is ok
    33  	require.NoError(t, err)
    34  	require.Equal(t, int64(0), b.Balance.Int64())
    35  
    36  	_, err = NEP17BalanceFromBytes([]byte{byte(stackitem.StructT)})
    37  	require.Error(t, err)
    38  
    39  	_, err = NEP17BalanceFromBytes([]byte{byte(stackitem.IntegerT), 4, 0, 1, 2, 3})
    40  	require.Error(t, err)
    41  
    42  	_, err = NEP17BalanceFromBytes([]byte{byte(stackitem.StructT), 0, byte(stackitem.IntegerT), 1, 1})
    43  	require.Error(t, err)
    44  
    45  	_, err = NEP17BalanceFromBytes([]byte{byte(stackitem.StructT), 1, byte(stackitem.ByteArrayT), 1, 1})
    46  	require.Error(t, err)
    47  
    48  	_, err = NEP17BalanceFromBytes([]byte{byte(stackitem.StructT), 1, byte(stackitem.IntegerT), 2, 1})
    49  	require.Error(t, err)
    50  }
    51  
    52  func TestNEOBalanceSerialization(t *testing.T) {
    53  	var b = NEOBalance{
    54  		NEP17Balance:  NEP17Balance{*big.NewInt(100500)},
    55  		BalanceHeight: 42,
    56  	}
    57  	si, err := b.ToStackItem()
    58  	require.NoError(t, err)
    59  
    60  	var bb NEOBalance
    61  	require.NoError(t, bb.FromStackItem(si))
    62  	require.Equal(t, b, bb)
    63  
    64  	b.VoteTo, err = keys.NewPublicKeyFromString("03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c")
    65  	require.NoError(t, err)
    66  	b.LastGasPerVote = *big.NewInt(100500)
    67  
    68  	si, err = b.ToStackItem()
    69  	require.NoError(t, err)
    70  	bb = NEOBalance{}
    71  	require.NoError(t, bb.FromStackItem(si))
    72  	require.Equal(t, b, bb)
    73  
    74  	b.VoteTo = nil
    75  	si, err = b.ToStackItem()
    76  	require.NoError(t, err)
    77  	bb = NEOBalance{}
    78  	require.NoError(t, bb.FromStackItem(si))
    79  	require.Equal(t, b, bb)
    80  }
    81  
    82  func BenchmarkNEP17BalanceBytes(b *testing.B) {
    83  	var bl NEP17Balance
    84  	bl.Balance.SetInt64(0x12345678910)
    85  
    86  	b.Run("stackitem", func(b *testing.B) {
    87  		b.ReportAllocs()
    88  		for i := 0; i < b.N; i++ {
    89  			_, _ = stackitem.SerializeConvertible(&bl)
    90  		}
    91  	})
    92  	b.Run("bytes", func(b *testing.B) {
    93  		b.ReportAllocs()
    94  		for i := 0; i < b.N; i++ {
    95  			_ = bl.Bytes(nil)
    96  		}
    97  	})
    98  	b.Run("bytes, prealloc", func(b *testing.B) {
    99  		bs := bl.Bytes(nil)
   100  
   101  		b.ResetTimer()
   102  		b.ReportAllocs()
   103  		for i := 0; i < b.N; i++ {
   104  			_ = bl.Bytes(bs[:0])
   105  		}
   106  	})
   107  }
   108  
   109  func BenchmarkNEP17BalanceFromBytes(b *testing.B) {
   110  	var bl NEP17Balance
   111  	bl.Balance.SetInt64(0x12345678910)
   112  
   113  	buf := bl.Bytes(nil)
   114  
   115  	b.Run("stackitem", func(b *testing.B) {
   116  		b.ReportAllocs()
   117  		for i := 0; i < b.N; i++ {
   118  			_ = stackitem.DeserializeConvertible(buf, new(NEP17Balance))
   119  		}
   120  	})
   121  	b.Run("from bytes", func(b *testing.B) {
   122  		b.ReportAllocs()
   123  		for i := 0; i < b.N; i++ {
   124  			_, _ = NEP17BalanceFromBytes(buf)
   125  		}
   126  	})
   127  }