github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/common/coin_test.go (about)

     1  package common
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  // ------------------
    12  // test sdk.SysCoin
    13  func TestParseDecCoinByDecimal(t *testing.T) {
    14  
    15  	decCoin, err := sdk.ParseDecCoin("1000.01" + NativeToken)
    16  	require.Nil(t, err)
    17  	require.Equal(t, "1000.010000000000000000"+NativeToken, decCoin.String())
    18  
    19  	//----------------
    20  	// test sdk.Dec
    21  	//require.Equal(t, uint64(100001000000), decCoin.Amount.Uint64())
    22  	//require.Equal(t, int64(100001000000), decCoin.Amount.Int64())
    23  	require.Equal(t, false, decCoin.Amount.IsInteger())
    24  
    25  	require.Equal(t, "1000.010000000000000000", decCoin.Amount.String())
    26  
    27  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
    28  	require.Nil(t, err)
    29  	require.Equal(t, "1000.010000000000000000", decCoinAmountYaml)
    30  
    31  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
    32  	require.Nil(t, err)
    33  	require.Equal(t, "\"1000.010000000000000000\"", string(decCoinAmountJSON))
    34  }
    35  
    36  func TestDecCoin(t *testing.T) {
    37  
    38  	decCoin, err := sdk.ParseDecCoin("0.000000000000000100" + NativeToken)
    39  	require.Nil(t, err)
    40  	require.Equal(t, "0.000000000000000100"+NativeToken, decCoin.String())
    41  
    42  	//----------------
    43  	// test sdk.Dec
    44  	require.Equal(t, uint64(100), decCoin.Amount.Uint64())
    45  	require.Equal(t, int64(100), decCoin.Amount.Int64())
    46  
    47  	fmt.Printf("%v\n", decCoin.Amount.Uint64())
    48  	fmt.Printf("%v\n", decCoin.Amount.Int64())
    49  	require.Equal(t, false, decCoin.Amount.IsInteger())
    50  
    51  	require.Equal(t, "0.000000000000000100", decCoin.Amount.String())
    52  
    53  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
    54  	require.Nil(t, err)
    55  	require.Equal(t, "0.000000000000000100", decCoinAmountYaml)
    56  
    57  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
    58  	require.Nil(t, err)
    59  	require.Equal(t, "\"0.000000000000000100\"", string(decCoinAmountJSON))
    60  }
    61  func TestDecCoin3(t *testing.T) {
    62  
    63  	decCoin := sdk.NewDecCoinFromDec(NativeToken, sdk.NewDec(9))
    64  	//require.Nil(t, err)
    65  	require.Equal(t, "9.000000000000000000"+NativeToken, decCoin.String())
    66  
    67  	//----------------
    68  	// test sdk.Dec
    69  	//require.Equal(t, uint64(600000000000000000000), decCoin.Amount.Uint64())
    70  	//require.Equal(t, int64(600000000000000000000), decCoin.Amount.Int64())
    71  
    72  	fmt.Printf("%v\n", decCoin.Amount.Uint64())
    73  	fmt.Printf("%v\n", decCoin.Amount.Int64())
    74  	require.Equal(t, true, decCoin.Amount.IsInteger())
    75  
    76  	require.Equal(t, "9.000000000000000000", decCoin.Amount.String())
    77  
    78  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
    79  	require.Nil(t, err)
    80  	require.Equal(t, "9.000000000000000000", decCoinAmountYaml)
    81  
    82  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
    83  	require.Nil(t, err)
    84  	require.Equal(t, "\"9.000000000000000000\"", string(decCoinAmountJSON))
    85  }
    86  func TestDecCoin5(t *testing.T) {
    87  
    88  	num := "299999999999999999999999999999999999999999999999999"
    89  
    90  	int1, ok := sdk.NewIntFromString(num)
    91  	if !ok {
    92  		panic("")
    93  	}
    94  	fmt.Printf("int1: %v\n", int1.String())
    95  
    96  	dec1 := sdk.MustNewDecFromStr(num + ".000000000000000000")
    97  	decCoin := sdk.NewDecCoinFromDec(NativeToken, dec1)
    98  	//require.Nil(t, err)
    99  	require.Equal(t, num+".000000000000000000"+NativeToken, decCoin.String())
   100  
   101  	//----------------
   102  	// test sdk.Dec
   103  	//require.Equal(t, uint64(600000000000000000000), decCoin.Amount.Uint64())
   104  	//require.Equal(t, int64(600000000000000000000), decCoin.Amount.Int64())
   105  
   106  	fmt.Printf("%v\n", decCoin.Amount.Uint64())
   107  	fmt.Printf("%v\n", decCoin.Amount.Int64())
   108  	require.Equal(t, true, decCoin.Amount.IsInteger())
   109  
   110  	require.Equal(t, num+".000000000000000000", decCoin.Amount.String())
   111  
   112  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
   113  	require.Nil(t, err)
   114  	require.Equal(t, num+".000000000000000000", decCoinAmountYaml)
   115  
   116  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
   117  	require.Nil(t, err)
   118  	require.Equal(t, "\""+num+".000000000000000000\"", string(decCoinAmountJSON))
   119  }
   120  func TestDecCoin4(t *testing.T) {
   121  
   122  	decCoin := sdk.NewDecCoinFromDec(NativeToken, sdk.NewDec(9))
   123  	//require.Nil(t, err)
   124  	require.Equal(t, "9.000000000000000000"+NativeToken, decCoin.String())
   125  
   126  	//----------------
   127  	// test sdk.Dec
   128  	//require.Equal(t, uint64(600000000000000000000), decCoin.Amount.Uint64())
   129  	//require.Equal(t, int64(600000000000000000000), decCoin.Amount.Int64())
   130  
   131  	fmt.Printf("%v\n", decCoin.Amount.Uint64())
   132  	fmt.Printf("%v\n", decCoin.Amount.Int64())
   133  	require.Equal(t, true, decCoin.Amount.IsInteger())
   134  
   135  	require.Equal(t, "9.000000000000000000", decCoin.Amount.String())
   136  
   137  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
   138  	require.Nil(t, err)
   139  	require.Equal(t, "9.000000000000000000", decCoinAmountYaml)
   140  
   141  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
   142  	require.Nil(t, err)
   143  	require.Equal(t, "\"9.000000000000000000\"", string(decCoinAmountJSON))
   144  }
   145  
   146  func TestIntCoin(t *testing.T) {
   147  	intCoin, err := sdk.ParseCoin("100001" + NativeToken)
   148  	require.Nil(t, err)
   149  
   150  	fmt.Printf("%v\n", intCoin.String())
   151  
   152  	fmt.Printf("%v\n", intCoin.Amount.Uint64())
   153  	fmt.Printf("%v\n", intCoin.Amount.Int64())
   154  
   155  	require.Equal(t, "100001.000000000000000000"+NativeToken, intCoin.String())
   156  
   157  	//----------------
   158  	// test sdk.Dec
   159  	//require.Equal(t, uint64(100001), intCoin.Amount.Uint64())
   160  	//require.Equal(t, int64(100001), intCoin.Amount.Int64())
   161  
   162  	require.Equal(t, "100001.000000000000000000", intCoin.Amount.String())
   163  
   164  	intCoinAmountYaml, err := intCoin.Amount.MarshalYAML()
   165  	require.Nil(t, err)
   166  	require.Equal(t, "100001.000000000000000000", intCoinAmountYaml)
   167  
   168  	intCoinAmountJSON, err := intCoin.Amount.MarshalJSON()
   169  	require.Nil(t, err)
   170  	require.Equal(t, "\"100001.000000000000000000\"", string(intCoinAmountJSON))
   171  }
   172  
   173  func TestIntCoin2(t *testing.T) {
   174  	intCoin, err := sdk.ParseCoin("100001" + NativeToken)
   175  	require.Nil(t, err)
   176  
   177  	fmt.Printf("%v\n", intCoin.String())
   178  
   179  	fmt.Printf("%v\n", intCoin.Amount.Uint64())
   180  	fmt.Printf("%v\n", intCoin.Amount.Int64())
   181  
   182  	require.Equal(t, "100001.000000000000000000"+NativeToken, intCoin.String())
   183  
   184  	//----------------
   185  	// test sdk.Dec
   186  	//require.Equal(t, uint64(100001), intCoin.Amount.Uint64())
   187  	//require.Equal(t, int64(100001), intCoin.Amount.Int64())
   188  
   189  	require.Equal(t, "100001.000000000000000000", intCoin.Amount.String())
   190  
   191  	intCoinAmountYaml, err := intCoin.Amount.MarshalYAML()
   192  	require.Nil(t, err)
   193  	require.Equal(t, "100001.000000000000000000", intCoinAmountYaml)
   194  
   195  	intCoinAmountJSON, err := intCoin.Amount.MarshalJSON()
   196  	require.Nil(t, err)
   197  	require.Equal(t, "\"100001.000000000000000000\"", string(intCoinAmountJSON))
   198  }
   199  
   200  func TestParseDecCoinByInteger(t *testing.T) {
   201  
   202  	decCoin, err := sdk.ParseDecCoin("1000" + NativeToken)
   203  	require.Nil(t, err)
   204  
   205  	require.Equal(t, "1000.000000000000000000"+NativeToken, decCoin.String())
   206  
   207  	//----------------
   208  	// test sdk.Dec
   209  	//require.Equal(t, uint64(100000000000), decCoin.Amount.Uint64())
   210  	//require.Equal(t, int64(100000000000), decCoin.Amount.Int64())
   211  	require.Equal(t, true, decCoin.Amount.IsInteger())
   212  
   213  	require.Equal(t, "1000.000000000000000000", decCoin.Amount.String())
   214  
   215  	decCoinAmountYaml, err := decCoin.Amount.MarshalYAML()
   216  	require.Nil(t, err)
   217  	require.Equal(t, "1000.000000000000000000", decCoinAmountYaml)
   218  
   219  	decCoinAmountJSON, err := decCoin.Amount.MarshalJSON()
   220  	require.Nil(t, err)
   221  	require.Equal(t, "\"1000.000000000000000000\"", string(decCoinAmountJSON))
   222  }
   223  
   224  // --------------
   225  // test sdk.Coin
   226  func TestParseIntCoinByDecimal(t *testing.T) {
   227  	ret, err := sdk.ParseCoin("1000.1" + NativeToken)
   228  	require.Nil(t, err)
   229  	fmt.Println(ret.String())
   230  }
   231  
   232  // --------------------
   233  // test sdk.NewCoin. Dangerous!
   234  func TestSdkNewCoin(t *testing.T) {
   235  	// dangerous to use!!!
   236  	intCoin := sdk.NewCoin(NativeToken, sdk.NewInt(1000))
   237  	require.Equal(t, "1000.000000000000000000"+NativeToken, intCoin.String())
   238  }
   239  
   240  // --------------------
   241  // test sdk.NewDecCoin
   242  func TestSdkNewDecCoin(t *testing.T) {
   243  	// safe to use
   244  	intCoin := sdk.NewDecCoin(NativeToken, sdk.NewInt(1000))
   245  	require.Equal(t, "1000.000000000000000000"+NativeToken, intCoin.String())
   246  }