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

     1  package state
     2  
     3  import (
     4  	"math/big"
     5  	"math/rand"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/nspcc-dev/neo-go/internal/random"
    10  	"github.com/nspcc-dev/neo-go/internal/testserdes"
    11  	"github.com/nspcc-dev/neo-go/pkg/util"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestTokenTransferLog_Append17(t *testing.T) {
    16  	r := rand.New(rand.NewSource(time.Now().UnixNano()))
    17  	expected := []*NEP17Transfer{
    18  		random17Transfer(r),
    19  		random17Transfer(r),
    20  		random17Transfer(r),
    21  		random17Transfer(r),
    22  	}
    23  
    24  	lg := new(TokenTransferLog)
    25  	for _, tr := range expected {
    26  		require.NoError(t, lg.Append(tr))
    27  	}
    28  
    29  	require.Equal(t, len(expected), lg.Size())
    30  
    31  	i := len(expected) - 1
    32  	cont, err := lg.ForEachNEP17(func(tr *NEP17Transfer) (bool, error) {
    33  		require.Equal(t, expected[i], tr)
    34  		i--
    35  		return true, nil
    36  	})
    37  	require.NoError(t, err)
    38  	require.True(t, cont)
    39  }
    40  
    41  func TestTokenTransferLog_Append(t *testing.T) {
    42  	r := rand.New(rand.NewSource(time.Now().UnixNano()))
    43  	expected := []*NEP11Transfer{
    44  		random11Transfer(r),
    45  		random11Transfer(r),
    46  		random11Transfer(r),
    47  		random11Transfer(r),
    48  	}
    49  
    50  	lg := new(TokenTransferLog)
    51  	for _, tr := range expected {
    52  		require.NoError(t, lg.Append(tr))
    53  	}
    54  
    55  	require.Equal(t, len(expected), lg.Size())
    56  
    57  	i := len(expected) - 1
    58  	cont, err := lg.ForEachNEP11(func(tr *NEP11Transfer) (bool, error) {
    59  		require.Equal(t, expected[i], tr)
    60  		i--
    61  		return true, nil
    62  	})
    63  	require.NoError(t, err)
    64  	require.True(t, cont)
    65  }
    66  
    67  func BenchmarkTokenTransferLog_Append(b *testing.B) {
    68  	r := rand.New(rand.NewSource(time.Now().UnixNano()))
    69  	ts := make([]*NEP17Transfer, TokenTransferBatchSize)
    70  	for i := range ts {
    71  		ts[i] = random17Transfer(r)
    72  	}
    73  
    74  	lg := new(TokenTransferLog)
    75  	b.ResetTimer()
    76  	b.ReportAllocs()
    77  	for i := 0; i < b.N; i++ {
    78  		for _, tr := range ts {
    79  			err := lg.Append(tr)
    80  			if err != nil {
    81  				b.FailNow()
    82  			}
    83  		}
    84  	}
    85  }
    86  
    87  func TestNEP17Transfer_DecodeBinary(t *testing.T) {
    88  	expected := &NEP17Transfer{
    89  		Asset:        123,
    90  		Counterparty: util.Uint160{5, 6, 7},
    91  		Amount:       big.NewInt(42),
    92  		Block:        12345,
    93  		Timestamp:    54321,
    94  		Tx:           util.Uint256{8, 5, 3},
    95  	}
    96  
    97  	testserdes.EncodeDecodeBinary(t, expected, new(NEP17Transfer))
    98  }
    99  
   100  func TestNEP11Transfer_DecodeBinary(t *testing.T) {
   101  	expected := &NEP11Transfer{
   102  		NEP17Transfer: NEP17Transfer{
   103  			Asset:        123,
   104  			Counterparty: util.Uint160{5, 6, 7},
   105  			Amount:       big.NewInt(42),
   106  			Block:        12345,
   107  			Timestamp:    54321,
   108  			Tx:           util.Uint256{8, 5, 3},
   109  		},
   110  		ID: []byte{42, 42, 42},
   111  	}
   112  
   113  	testserdes.EncodeDecodeBinary(t, expected, new(NEP11Transfer))
   114  }
   115  
   116  func random17Transfer(r *rand.Rand) *NEP17Transfer {
   117  	return &NEP17Transfer{
   118  		Amount:       big.NewInt(int64(r.Uint64())),
   119  		Block:        r.Uint32(),
   120  		Asset:        int32(random.Int(10, 10000000)),
   121  		Counterparty: random.Uint160(),
   122  		Tx:           random.Uint256(),
   123  	}
   124  }
   125  
   126  func random11Transfer(r *rand.Rand) *NEP11Transfer {
   127  	return &NEP11Transfer{
   128  		NEP17Transfer: NEP17Transfer{
   129  			Amount:       big.NewInt(int64(r.Uint64())),
   130  			Block:        r.Uint32(),
   131  			Asset:        int32(random.Int(10, 10000000)),
   132  			Counterparty: random.Uint160(),
   133  			Tx:           random.Uint256(),
   134  		},
   135  		ID: random.Uint256().BytesBE(),
   136  	}
   137  }