github.com/cosmos/cosmos-sdk@v0.50.10/types/utils_test.go (about)

     1  package types_test
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/suite"
     9  
    10  	sdk "github.com/cosmos/cosmos-sdk/types"
    11  	"github.com/cosmos/cosmos-sdk/types/address"
    12  )
    13  
    14  type utilsTestSuite struct {
    15  	suite.Suite
    16  }
    17  
    18  func TestUtilsTestSuite(t *testing.T) {
    19  	suite.Run(t, new(utilsTestSuite))
    20  }
    21  
    22  func (s *utilsTestSuite) SetupSuite() {
    23  	s.T().Parallel()
    24  }
    25  
    26  func (s *utilsTestSuite) TestTimeFormatAndParse() {
    27  	cases := []struct {
    28  		RFC3339NanoStr     string
    29  		SDKSortableTimeStr string
    30  		Equal              bool
    31  	}{
    32  		{"2009-11-10T23:00:00Z", "2009-11-10T23:00:00.000000000", true},
    33  		{"2011-01-10T23:10:05.758230235Z", "2011-01-10T23:10:05.758230235", true},
    34  	}
    35  	for _, tc := range cases {
    36  		tc := tc
    37  		timeFromRFC, err := time.Parse(time.RFC3339Nano, tc.RFC3339NanoStr)
    38  		s.Require().Nil(err)
    39  		timeFromSDKFormat, err := time.Parse(sdk.SortableTimeFormat, tc.SDKSortableTimeStr)
    40  		s.Require().Nil(err)
    41  
    42  		s.Require().True(timeFromRFC.Equal(timeFromSDKFormat))
    43  		s.Require().Equal(timeFromRFC.Format(sdk.SortableTimeFormat), tc.SDKSortableTimeStr)
    44  	}
    45  }
    46  
    47  func (s *utilsTestSuite) TestCopyBytes() {
    48  	s.Require().Nil(sdk.CopyBytes(nil))
    49  	s.Require().Equal(0, len(sdk.CopyBytes([]byte{})))
    50  	bs := []byte("test")
    51  	bsCopy := sdk.CopyBytes(bs)
    52  	s.Require().True(bytes.Equal(bs, bsCopy))
    53  }
    54  
    55  func (s *utilsTestSuite) TestUint64ToBigEndian() {
    56  	s.Require().Equal([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, sdk.Uint64ToBigEndian(uint64(0)))
    57  	s.Require().Equal([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa}, sdk.Uint64ToBigEndian(uint64(10)))
    58  }
    59  
    60  func (s *utilsTestSuite) TestFormatTimeBytes() {
    61  	tm, err := time.Parse("Jan 2, 2006 at 3:04pm (MST)", "Mar 3, 2020 at 7:54pm (UTC)")
    62  	s.Require().NoError(err)
    63  	s.Require().Equal("2020-03-03T19:54:00.000000000", string(sdk.FormatTimeBytes(tm)))
    64  }
    65  
    66  func (s *utilsTestSuite) TestFormatTimeString() {
    67  	tm, err := time.Parse("Jan 2, 2006 at 3:04pm (MST)", "Mar 3, 2020 at 7:54pm (UTC)")
    68  	s.Require().NoError(err)
    69  	s.Require().Equal("2020-03-03T19:54:00.000000000", sdk.FormatTimeString(tm))
    70  }
    71  
    72  func (s *utilsTestSuite) TestParseTimeBytes() {
    73  	tm, err := sdk.ParseTimeBytes([]byte("2020-03-03T19:54:00.000000000"))
    74  	s.Require().NoError(err)
    75  	s.Require().True(tm.Equal(time.Date(2020, 3, 3, 19, 54, 0, 0, time.UTC)))
    76  
    77  	_, err = sdk.ParseTimeBytes([]byte{})
    78  	s.Require().Error(err)
    79  }
    80  
    81  func (s *utilsTestSuite) TestParseTime() {
    82  	testCases := []struct {
    83  		name           string
    84  		input          any
    85  		expectErr      bool
    86  		expectedOutput string
    87  	}{
    88  		{
    89  			name:      "valid time string",
    90  			input:     "2020-03-03T19:54:00.000000000",
    91  			expectErr: false,
    92  		},
    93  		{
    94  			name:      "valid time []byte",
    95  			input:     []byte("2020-03-03T19:54:00.000000000"),
    96  			expectErr: false,
    97  		},
    98  		{
    99  			name:      "valid time",
   100  			input:     time.Date(2020, 3, 3, 19, 54, 0, 0, time.UTC),
   101  			expectErr: false,
   102  		},
   103  		{
   104  			name: "valid time different timezone",
   105  			input: func() time.Time {
   106  				ams, _ := time.LoadLocation("Asia/Seoul") // no daylight saving time
   107  				return time.Date(2020, 3, 4, 4, 54, 0, 0, ams)
   108  			}(),
   109  			expectErr: false,
   110  		},
   111  		{
   112  			name:      "invalid time",
   113  			input:     struct{}{},
   114  			expectErr: true,
   115  		},
   116  	}
   117  
   118  	for _, tc := range testCases {
   119  		tc := tc
   120  
   121  		s.Run(tc.name, func() {
   122  			tm, err := sdk.ParseTime(tc.input)
   123  			if tc.expectErr {
   124  				s.Require().Error(err)
   125  			} else {
   126  				s.Require().NoError(err)
   127  				s.Require().True(tm.Equal(time.Date(2020, 3, 3, 19, 54, 0, 0, time.UTC)))
   128  			}
   129  		})
   130  	}
   131  }
   132  
   133  func (s *utilsTestSuite) TestAppendParseBytes() {
   134  	test1 := "test1"
   135  	test2 := "testString2"
   136  	testByte1 := []byte(test1)
   137  	testByte2 := []byte(test2)
   138  
   139  	combinedBytes := sdk.AppendLengthPrefixedBytes(address.MustLengthPrefix(testByte1), address.MustLengthPrefix(testByte2))
   140  	testCombineBytes := append([]byte{}, address.MustLengthPrefix(testByte1)...)
   141  	testCombineBytes = append(testCombineBytes, address.MustLengthPrefix(testByte2)...)
   142  	s.Require().Equal(combinedBytes, testCombineBytes)
   143  
   144  	test1Len, test1LenEndIndex := sdk.ParseLengthPrefixedBytes(combinedBytes, 0, 1)
   145  	parseTest1, parseTest1EndIndex := sdk.ParseLengthPrefixedBytes(combinedBytes, test1LenEndIndex+1, int(test1Len[0]))
   146  	s.Require().Equal(testByte1, parseTest1)
   147  
   148  	test2Len, test2LenEndIndex := sdk.ParseLengthPrefixedBytes(combinedBytes, parseTest1EndIndex+1, 1)
   149  	parseTest2, _ := sdk.ParseLengthPrefixedBytes(combinedBytes, test2LenEndIndex+1, int(test2Len[0]))
   150  	s.Require().Equal(testByte2, parseTest2)
   151  }