github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/util/uint256_test.go (about)

     1  package util_test
     2  
     3  import (
     4  	"encoding/hex"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/internal/testserdes"
     8  	"github.com/nspcc-dev/neo-go/pkg/util"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestUint256UnmarshalJSON(t *testing.T) {
    14  	str := "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
    15  	expected, err := util.Uint256DecodeStringLE(str)
    16  	require.NoError(t, err)
    17  
    18  	// UnmarshalJSON decodes hex-strings
    19  	var u1, u2 util.Uint256
    20  
    21  	require.NoError(t, u1.UnmarshalJSON([]byte(`"`+str+`"`)))
    22  	assert.True(t, expected.Equals(u1))
    23  
    24  	testserdes.MarshalUnmarshalJSON(t, &expected, &u2)
    25  
    26  	// UnmarshalJSON does not accepts numbers
    27  	assert.Error(t, u2.UnmarshalJSON([]byte("123")))
    28  }
    29  
    30  func TestUint256DecodeString(t *testing.T) {
    31  	hexStr := "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
    32  	val, err := util.Uint256DecodeStringLE(hexStr)
    33  	require.NoError(t, err)
    34  	assert.Equal(t, hexStr, val.StringLE())
    35  
    36  	valBE, err := util.Uint256DecodeStringBE(hexStr)
    37  	require.NoError(t, err)
    38  	assert.Equal(t, val, valBE.Reverse())
    39  
    40  	bs, err := hex.DecodeString(hexStr)
    41  	require.NoError(t, err)
    42  
    43  	val1, err := util.Uint256DecodeBytesBE(bs)
    44  	assert.NoError(t, err)
    45  	assert.Equal(t, hexStr, val1.String())
    46  	assert.Equal(t, val, val1.Reverse())
    47  
    48  	_, err = util.Uint256DecodeStringLE(hexStr[1:])
    49  	assert.Error(t, err)
    50  
    51  	_, err = util.Uint256DecodeStringBE(hexStr[1:])
    52  	assert.Error(t, err)
    53  
    54  	hexStr = "zzz7308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
    55  	_, err = util.Uint256DecodeStringLE(hexStr)
    56  	assert.Error(t, err)
    57  
    58  	_, err = util.Uint256DecodeStringBE(hexStr)
    59  	assert.Error(t, err)
    60  }
    61  
    62  func TestUint256DecodeBytes(t *testing.T) {
    63  	hexStr := "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
    64  	b, err := hex.DecodeString(hexStr)
    65  	require.NoError(t, err)
    66  
    67  	val, err := util.Uint256DecodeBytesLE(b)
    68  	require.NoError(t, err)
    69  	assert.Equal(t, hexStr, val.StringLE())
    70  
    71  	_, err = util.Uint256DecodeBytesBE(b[1:])
    72  	assert.Error(t, err)
    73  }
    74  
    75  func TestUInt256Equals(t *testing.T) {
    76  	a := "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
    77  	b := "e287c5b29a1b66092be6803c59c765308ac20287e1b4977fd399da5fc8f66ab5"
    78  
    79  	ua, err := util.Uint256DecodeStringLE(a)
    80  	require.NoError(t, err)
    81  
    82  	ub, err := util.Uint256DecodeStringLE(b)
    83  	require.NoError(t, err)
    84  	assert.False(t, ua.Equals(ub), "%s and %s cannot be equal", ua, ub)
    85  	assert.True(t, ua.Equals(ua), "%s and %s must be equal", ua, ua)
    86  	assert.Zero(t, ua.CompareTo(ua), "%s and %s must be equal", ua, ua)
    87  }
    88  
    89  func TestUint256_Serializable(t *testing.T) {
    90  	a := util.Uint256{
    91  		1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
    92  		17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
    93  	}
    94  
    95  	var b util.Uint256
    96  	testserdes.EncodeDecodeBinary(t, &a, &b)
    97  }
    98  
    99  func BenchmarkUint256DecodeStringLE(b *testing.B) {
   100  	a := "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"
   101  
   102  	b.ResetTimer()
   103  	b.ReportAllocs()
   104  	for i := 0; i < b.N; i++ {
   105  		_, err := util.Uint256DecodeStringLE(a)
   106  		if err != nil {
   107  			b.FailNow()
   108  		}
   109  	}
   110  }