certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

types: tests -> test suites migration (#7400) 

Ref #7362
This commit is contained in:
Alessio Treglia 2020-09-28 12:46:49 +02:00 committed by GitHub
parent 308ee267a8
commit 8601dcdbb7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 653 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crypto/keys/multisig/codec.go
View File

@ -1,11 +1,11 @@
package multisig
import (
"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/sr25519"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
)

38
types/address_test.go
View File

@ -18,12 +18,12 @@ import (
"github.com/cosmos/cosmos-sdk/types"
)
type AddressTestSuite struct {
type addressTestSuite struct {
suite.Suite
}
func TestAddressTestSuite(t *testing.T) {
suite.Run(t, new(AddressTestSuite))
suite.Run(t, new(addressTestSuite))
}
var invalidStrs = []string{
@ -38,14 +38,14 @@ var invalidStrs = []string{
types.Bech32PrefixConsPub + "6789",
}
func (s *AddressTestSuite) testMarshal(original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
func (s *addressTestSuite) testMarshal(original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
bz, err := marshal()
s.Require().Nil(err)
s.Require().Nil(unmarshal(bz))
s.Require().Equal(original, res)
}
func (s *AddressTestSuite) TestEmptyAddresses() {
func (s *addressTestSuite) TestEmptyAddresses() {
s.T().Parallel()
s.Require().Equal((types.AccAddress{}).String(), "")
s.Require().Equal((types.ValAddress{}).String(), "")
@ -64,7 +64,7 @@ func (s *AddressTestSuite) TestEmptyAddresses() {
s.Require().Error(err)
}
func (s *AddressTestSuite) TestRandBech32PubkeyConsistency() {
func (s *addressTestSuite) TestRandBech32PubkeyConsistency() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
@ -106,7 +106,7 @@ func (s *AddressTestSuite) TestRandBech32PubkeyConsistency() {
}
}
func (s *AddressTestSuite) TestYAMLMarshalers() {
func (s *addressTestSuite) TestYAMLMarshalers() {
addr := secp256k1.GenPrivKey().PubKey().Address()
acc := types.AccAddress(addr)
@ -123,7 +123,7 @@ func (s *AddressTestSuite) TestYAMLMarshalers() {
s.Require().Equal(cons.String()+"\n", string(got))
}
func (s *AddressTestSuite) TestRandBech32AccAddrConsistency() {
func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
@ -162,7 +162,7 @@ func (s *AddressTestSuite) TestRandBech32AccAddrConsistency() {
s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())
}
func (s *AddressTestSuite) TestValAddr() {
func (s *addressTestSuite) TestValAddr() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
@ -203,7 +203,7 @@ func (s *AddressTestSuite) TestValAddr() {
s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())
}
func (s *AddressTestSuite) TestConsAddress() {
func (s *addressTestSuite) TestConsAddress() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
@ -253,7 +253,7 @@ func RandString(n int) string {
return string(b)
}
func (s *AddressTestSuite) TestConfiguredPrefix() {
func (s *addressTestSuite) TestConfiguredPrefix() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
for length := 1; length < 10; length++ {
@ -309,7 +309,7 @@ func (s *AddressTestSuite) TestConfiguredPrefix() {
}
}
func (s *AddressTestSuite) TestAddressInterface() {
func (s *addressTestSuite) TestAddressInterface() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
rand.Read(pub.Key)
@ -338,7 +338,7 @@ func (s *AddressTestSuite) TestAddressInterface() {
}
func (s *AddressTestSuite) TestVerifyAddressFormat() {
func (s *addressTestSuite) TestVerifyAddressFormat() {
addr0 := make([]byte, 0)
addr5 := make([]byte, 5)
addr20 := make([]byte, 20)
@ -354,7 +354,7 @@ func (s *AddressTestSuite) TestVerifyAddressFormat() {
s.Require().EqualError(err, "incorrect address length 32")
}
func (s *AddressTestSuite) TestCustomAddressVerifier() {
func (s *addressTestSuite) TestCustomAddressVerifier() {
// Create a 10 byte address
addr := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
accBech := types.AccAddress(addr).String()
@ -390,7 +390,7 @@ func (s *AddressTestSuite) TestCustomAddressVerifier() {
s.Require().Nil(err)
}
func (s *AddressTestSuite) TestBech32ifyAddressBytes() {
func (s *addressTestSuite) TestBech32ifyAddressBytes() {
addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
type args struct {
@ -423,7 +423,7 @@ func (s *AddressTestSuite) TestBech32ifyAddressBytes() {
}
}
func (s *AddressTestSuite) TestMustBech32ifyAddressBytes() {
func (s *addressTestSuite) TestMustBech32ifyAddressBytes() {
addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
type args struct {
@ -455,7 +455,7 @@ func (s *AddressTestSuite) TestMustBech32ifyAddressBytes() {
}
}
func (s *AddressTestSuite) TestAddressTypesEquals() {
func (s *addressTestSuite) TestAddressTypesEquals() {
addr1 := secp256k1.GenPrivKey().PubKey().Address()
accAddr1 := types.AccAddress(addr1)
consAddr1 := types.ConsAddress(addr1)
@ -495,20 +495,20 @@ func (s *AddressTestSuite) TestAddressTypesEquals() {
s.Require().Equal(valAddr1.Equals(valAddr2), valAddr2.Equals(valAddr1))
}
func (s *AddressTestSuite) TestNilAddressTypesEmpty() {
func (s *addressTestSuite) TestNilAddressTypesEmpty() {
s.Require().True(types.AccAddress(nil).Empty())
s.Require().True(types.ConsAddress(nil).Empty())
s.Require().True(types.ValAddress(nil).Empty())
}
func (s *AddressTestSuite) TestGetConsAddress() {
func (s *addressTestSuite) TestGetConsAddress() {
pk := secp256k1.GenPrivKey().PubKey()
s.Require().NotEqual(types.GetConsAddress(pk), pk.Address())
s.Require().True(bytes.Equal(types.GetConsAddress(pk).Bytes(), pk.Address().Bytes()))
s.Require().Panics(func() { types.GetConsAddress(crypto.PubKey(nil)) })
}
func (s *AddressTestSuite) TestGetFromBech32() {
func (s *addressTestSuite) TestGetFromBech32() {
_, err := types.GetFromBech32("", "prefix")
s.Require().Error(err)
s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())

62
types/coin_test.go
View File

@ -16,18 +16,18 @@ var (
testDenom2 = "muon"
)
type CoinTestSuite struct {
type coinTestSuite struct {
suite.Suite
}
func TestCoinTestSuite(t *testing.T) {
suite.Run(t, new(CoinTestSuite))
suite.Run(t, new(coinTestSuite))
}
// ----------------------------------------------------------------------------
// Coin tests
func (s *CoinTestSuite) TestCoin() {
func (s *coinTestSuite) TestCoin() {
s.Require().Panics(func() { sdk.NewInt64Coin(testDenom1, -1) })
s.Require().Panics(func() { sdk.NewCoin(testDenom1, sdk.NewInt(-1)) })
s.Require().Equal(sdk.NewInt(10), sdk.NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount)
@ -36,12 +36,12 @@ func (s *CoinTestSuite) TestCoin() {
s.Require().Equal(sdk.NewInt(5), sdk.NewCoin(testDenom1, sdk.NewInt(5)).Amount)
}
func (s *CoinTestSuite) TestCoin_String() {
func (s *coinTestSuite) TestCoin_String() {
coin := sdk.NewCoin(testDenom1, sdk.NewInt(10))
s.Require().Equal(fmt.Sprintf("10%s", testDenom1), coin.String())
}
func (s *CoinTestSuite) TestIsEqualCoin() {
func (s *coinTestSuite) TestIsEqualCoin() {
cases := []struct {
inputOne sdk.Coin
inputTwo sdk.Coin
@ -64,7 +64,7 @@ func (s *CoinTestSuite) TestIsEqualCoin() {
}
}
func (s *CoinTestSuite) TestCoinIsValid() {
func (s *coinTestSuite) TestCoinIsValid() {
loremIpsum := `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra dui vel nulla aliquet, non dictum elit aliquam. Proin consequat leo in consectetur mattis. Phasellus eget odio luctus, rutrum dolor at, venenatis ante. Praesent metus erat, sodales vitae sagittis eget, commodo non ipsum. Duis eget urna quis erat mattis pulvinar. Vivamus egestas imperdiet sem, porttitor hendrerit lorem pulvinar in. Vivamus laoreet sapien eget libero euismod tristique. Suspendisse tincidunt nulla quis luctus mattis.
Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed id turpis at erat placerat fermentum id sed sapien. Fusce mattis enim id nulla viverra, eget placerat eros aliquet. Nunc fringilla urna ac condimentum ultricies. Praesent in eros ac neque fringilla sodales. Donec ut venenatis eros. Quisque iaculis lectus neque, a varius sem ullamcorper nec. Cras tincidunt dignissim libero nec volutpat. Donec molestie enim sed metus venenatis, quis elementum sem varius. Curabitur eu venenatis nulla.
Cras sit amet ligula vel turpis placerat sollicitudin. Nunc massa odio, eleifend id lacus nec, ultricies elementum arcu. Donec imperdiet nulla lacus, a venenatis lacus fermentum nec. Proin vestibulum dolor enim, vitae posuere velit aliquet non. Suspendisse pharetra condimentum nunc tincidunt viverra. Etiam posuere, ligula ut maximus congue, mauris orci consectetur velit, vel finibus eros metus non tellus. Nullam et dictum metus. Aliquam maximus fermentum mauris elementum aliquet. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Etiam dapibus lectus sed tellus rutrum tincidunt. Nulla at dolor sem. Ut non dictum arcu, eget congue sem.`
@ -94,7 +94,7 @@ func (s *CoinTestSuite) TestCoinIsValid() {
}
}
func (s *CoinTestSuite) TestAddCoin() {
func (s *coinTestSuite) TestAddCoin() {
cases := []struct {
inputOne sdk.Coin
inputTwo sdk.Coin
@ -117,7 +117,7 @@ func (s *CoinTestSuite) TestAddCoin() {
}
}
func (s *CoinTestSuite) TestSubCoin() {
func (s *coinTestSuite) TestSubCoin() {
cases := []struct {
inputOne sdk.Coin
inputTwo sdk.Coin
@ -150,7 +150,7 @@ func (s *CoinTestSuite) TestSubCoin() {
s.Require().Equal(tc.expected, res.Amount.Int64())
}
func (s *CoinTestSuite) TestIsGTECoin() {
func (s *coinTestSuite) TestIsGTECoin() {
cases := []struct {
inputOne sdk.Coin
inputTwo sdk.Coin
@ -173,7 +173,7 @@ func (s *CoinTestSuite) TestIsGTECoin() {
}
}
func (s *CoinTestSuite) TestIsLTCoin() {
func (s *coinTestSuite) TestIsLTCoin() {
cases := []struct {
inputOne sdk.Coin
inputTwo sdk.Coin
@ -199,7 +199,7 @@ func (s *CoinTestSuite) TestIsLTCoin() {
}
}
func (s *CoinTestSuite) TestCoinIsZero() {
func (s *coinTestSuite) TestCoinIsZero() {
coin := sdk.NewInt64Coin(testDenom1, 0)
res := coin.IsZero()
s.Require().True(res)
@ -209,7 +209,7 @@ func (s *CoinTestSuite) TestCoinIsZero() {
s.Require().False(res)
}
func (s *CoinTestSuite) TestFilteredZeroCoins() {
func (s *coinTestSuite) TestFilteredZeroCoins() {
cases := []struct {
name string
input sdk.Coins
@ -264,7 +264,7 @@ func (s *CoinTestSuite) TestFilteredZeroCoins() {
// ----------------------------------------------------------------------------
// Coins tests
func (s *CoinTestSuite) TestCoins_String() {
func (s *coinTestSuite) TestCoins_String() {
cases := []struct {
name string
input sdk.Coins
@ -296,7 +296,7 @@ func (s *CoinTestSuite) TestCoins_String() {
}
}
func (s *CoinTestSuite) TestIsZeroCoins() {
func (s *coinTestSuite) TestIsZeroCoins() {
cases := []struct {
inputOne sdk.Coins
expected bool
@ -314,7 +314,7 @@ func (s *CoinTestSuite) TestIsZeroCoins() {
}
}
func (s *CoinTestSuite) TestEqualCoins() {
func (s *coinTestSuite) TestEqualCoins() {
cases := []struct {
inputOne sdk.Coins
inputTwo sdk.Coins
@ -341,7 +341,7 @@ func (s *CoinTestSuite) TestEqualCoins() {
}
}
func (s *CoinTestSuite) TestAddCoins() {
func (s *coinTestSuite) TestAddCoins() {
zero := sdk.NewInt(0)
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -365,7 +365,7 @@ func (s *CoinTestSuite) TestAddCoins() {
}
}
func (s *CoinTestSuite) TestSubCoins() {
func (s *coinTestSuite) TestSubCoins() {
zero := sdk.NewInt(0)
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -395,7 +395,7 @@ func (s *CoinTestSuite) TestSubCoins() {
}
}
func (s *CoinTestSuite) TestCoins_Validate() {
func (s *coinTestSuite) TestCoins_Validate() {
testCases := []struct {
name string
coins sdk.Coins
@ -572,7 +572,7 @@ func (s *CoinTestSuite) TestCoins_Validate() {
}
}
func (s *CoinTestSuite) TestCoinsGT() {
func (s *coinTestSuite) TestCoinsGT() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -584,7 +584,7 @@ func (s *CoinTestSuite) TestCoinsGT() {
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom2, two}}))
}
func (s *CoinTestSuite) TestCoinsLT() {
func (s *coinTestSuite) TestCoinsLT() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -599,7 +599,7 @@ func (s *CoinTestSuite) TestCoinsLT() {
s.Require().True(sdk.Coins{}.IsAllLT(sdk.Coins{{testDenom1, one}}))
}
func (s *CoinTestSuite) TestCoinsLTE() {
func (s *coinTestSuite) TestCoinsLTE() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -614,7 +614,7 @@ func (s *CoinTestSuite) TestCoinsLTE() {
s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{{testDenom1, one}}))
}
func (s *CoinTestSuite) TestParseCoins() {
func (s *coinTestSuite) TestParseCoins() {
one := sdk.OneInt()
cases := []struct {
@ -652,7 +652,7 @@ func (s *CoinTestSuite) TestParseCoins() {
}
}
func (s *CoinTestSuite) TestSortCoins() {
func (s *coinTestSuite) TestSortCoins() {
good := sdk.Coins{
sdk.NewInt64Coin("gas", 1),
sdk.NewInt64Coin("mineral", 1),
@ -715,7 +715,7 @@ func (s *CoinTestSuite) TestSortCoins() {
}
}
func (s *CoinTestSuite) TestAmountOf() {
func (s *coinTestSuite) TestAmountOf() {
case0 := sdk.Coins{}
case1 := sdk.Coins{
sdk.NewInt64Coin("gold", 0),
@ -757,7 +757,7 @@ func (s *CoinTestSuite) TestAmountOf() {
s.Require().Panics(func() { cases[0].coins.AmountOf("10Invalid") })
}
func (s *CoinTestSuite) TestCoinsIsAnyGTE() {
func (s *coinTestSuite) TestCoinsIsAnyGTE() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -777,7 +777,7 @@ func (s *CoinTestSuite) TestCoinsIsAnyGTE() {
s.Require().True(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
}
func (s *CoinTestSuite) TestCoinsIsAllGT() {
func (s *coinTestSuite) TestCoinsIsAllGT() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -797,7 +797,7 @@ func (s *CoinTestSuite) TestCoinsIsAllGT() {
s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
}
func (s *CoinTestSuite) TestCoinsIsAllGTE() {
func (s *coinTestSuite) TestCoinsIsAllGTE() {
one := sdk.OneInt()
two := sdk.NewInt(2)
@ -819,7 +819,7 @@ func (s *CoinTestSuite) TestCoinsIsAllGTE() {
s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
}
func (s *CoinTestSuite) TestNewCoins() {
func (s *coinTestSuite) TestNewCoins() {
tenatom := sdk.NewInt64Coin("atom", 10)
tenbtc := sdk.NewInt64Coin("btc", 10)
zeroeth := sdk.NewInt64Coin("eth", 0)
@ -847,7 +847,7 @@ func (s *CoinTestSuite) TestNewCoins() {
}
}
func (s *CoinTestSuite) TestCoinsIsAnyGT() {
func (s *coinTestSuite) TestCoinsIsAnyGT() {
twoAtom := sdk.NewInt64Coin("atom", 2)
fiveAtom := sdk.NewInt64Coin("atom", 5)
threeEth := sdk.NewInt64Coin("eth", 3)
@ -874,7 +874,7 @@ func (s *CoinTestSuite) TestCoinsIsAnyGT() {
}
}
func (s *CoinTestSuite) TestMarshalJSONCoins() {
func (s *coinTestSuite) TestMarshalJSONCoins() {
cdc := codec.NewLegacyAmino()
sdk.RegisterLegacyAminoCodec(cdc)
@ -904,7 +904,7 @@ func (s *CoinTestSuite) TestMarshalJSONCoins() {
}
}
func (s *CoinTestSuite) TestCoinAminoEncoding() {
func (s *coinTestSuite) TestCoinAminoEncoding() {
cdc := codec.NewLegacyAmino()
c := sdk.NewInt64Coin(testDenom1, 5)

48
types/config_test.go
View File

@ -4,47 +4,55 @@ import (
"errors"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestConfig_SetCoinType(t *testing.T) {
config := sdk.NewConfig()
config.SetCoinType(1)
require.Equal(t, uint32(1), config.GetCoinType())
config.SetCoinType(99)
require.Equal(t, uint32(99), config.GetCoinType())
config.Seal()
require.Panics(t, func() { config.SetCoinType(99) })
type configTestSuite struct {
suite.Suite
}
func TestConfig_SetTxEncoder(t *testing.T) {
func TestConfigTestSuite(t *testing.T) {
suite.Run(t, new(configTestSuite))
}
func (s *configTestSuite) TestConfig_SetCoinType() {
config := sdk.NewConfig()
config.SetCoinType(1)
s.Require().Equal(uint32(1), config.GetCoinType())
config.SetCoinType(99)
s.Require().Equal(uint32(99), config.GetCoinType())
config.Seal()
s.Require().Panics(func() { config.SetCoinType(99) })
}
func (s *configTestSuite) TestConfig_SetTxEncoder() {
mockErr := errors.New("test")
config := sdk.NewConfig()
require.Nil(t, config.GetTxEncoder())
s.Require().Nil(config.GetTxEncoder())
encFunc := sdk.TxEncoder(func(tx sdk.Tx) ([]byte, error) { return nil, nil })
config.SetTxEncoder(encFunc)
_, err := config.GetTxEncoder()(sdk.Tx(nil))
require.Error(t, mockErr, err)
s.Require().Error(mockErr, err)
config.Seal()
require.Panics(t, func() { config.SetTxEncoder(encFunc) })
s.Require().Panics(func() { config.SetTxEncoder(encFunc) })
}
func TestConfig_SetFullFundraiserPath(t *testing.T) {
func (s *configTestSuite) TestConfig_SetFullFundraiserPath() {
config := sdk.NewConfig()
config.SetFullFundraiserPath("test/path")
require.Equal(t, "test/path", config.GetFullFundraiserPath())
s.Require().Equal("test/path", config.GetFullFundraiserPath())
config.SetFullFundraiserPath("test/poth")
require.Equal(t, "test/poth", config.GetFullFundraiserPath())
s.Require().Equal("test/poth", config.GetFullFundraiserPath())
config.Seal()
require.Panics(t, func() { config.SetFullFundraiserPath("x/test/path") })
s.Require().Panics(func() { config.SetFullFundraiserPath("x/test/path") })
}
func TestKeyringServiceName(t *testing.T) {
require.Equal(t, sdk.DefaultKeyringServiceName, sdk.KeyringServiceName())
func (s *configTestSuite) TestKeyringServiceName() {
s.Require().Equal(sdk.DefaultKeyringServiceName, sdk.KeyringServiceName())
}

18
types/context_test.go
View File

@ -18,15 +18,15 @@ import (
"github.com/cosmos/cosmos-sdk/types"
)
type ContextTestSuite struct {
type contextTestSuite struct {
suite.Suite
}
func TestContextTestSuite(t *testing.T) {
suite.Run(t, new(ContextTestSuite))
suite.Run(t, new(contextTestSuite))
}
func (s *ContextTestSuite) defaultContext(key types.StoreKey) types.Context {
func (s *contextTestSuite) defaultContext(key types.StoreKey) types.Context {
db := dbm.NewMemDB()
cms := store.NewCommitMultiStore(db)
cms.MountStoreWithDB(key, types.StoreTypeIAVL, db)
@ -35,7 +35,7 @@ func (s *ContextTestSuite) defaultContext(key types.StoreKey) types.Context {
return ctx
}
func (s *ContextTestSuite) TestCacheContext() {
func (s *contextTestSuite) TestCacheContext() {
key := types.NewKVStoreKey(s.T().Name() + "_TestCacheContext")
k1 := []byte("hello")
v1 := []byte("world")
@ -62,7 +62,7 @@ func (s *ContextTestSuite) TestCacheContext() {
s.Require().Equal(v2, store.Get(k2))
}
func (s *ContextTestSuite) TestLogContext() {
func (s *contextTestSuite) TestLogContext() {
key := types.NewKVStoreKey(s.T().Name())
ctx := s.defaultContext(key)
ctrl := gomock.NewController(s.T())
@ -86,7 +86,7 @@ func (d dummy) Clone() interface{} {
}
// Testing saving/loading sdk type values to/from the context
func (s *ContextTestSuite) TestContextWithCustom() {
func (s *contextTestSuite) TestContextWithCustom() {
var ctx types.Context
s.Require().True(ctx.IsZero())
@ -144,7 +144,7 @@ func (s *ContextTestSuite) TestContextWithCustom() {
}
// Testing saving/loading of header fields to/from the context
func (s *ContextTestSuite) TestContextHeader() {
func (s *contextTestSuite) TestContextHeader() {
var ctx types.Context
height := int64(5)
@ -164,7 +164,7 @@ func (s *ContextTestSuite) TestContextHeader() {
s.Require().Equal(proposer.Bytes(), ctx.BlockHeader().ProposerAddress)
}
func (s *ContextTestSuite) TestContextHeaderClone() {
func (s *contextTestSuite) TestContextHeaderClone() {
cases := map[string]struct {
h tmproto.Header
}{
@ -220,7 +220,7 @@ func (s *ContextTestSuite) TestContextHeaderClone() {
}
}
func (s *ContextTestSuite) TestUnwrapSDKContext() {
func (s *contextTestSuite) TestUnwrapSDKContext() {
sdkCtx := types.NewContext(nil, tmproto.Header{}, false, nil)
ctx := types.WrapSDKContext(sdkCtx)
sdkCtx2 := types.UnwrapSDKContext(ctx)

82
types/decimal_internal_test.go Normal file
View File

@ -0,0 +1,82 @@
package types
import (
"math/big"
"testing"
"github.com/stretchr/testify/suite"
)
type decimalInternalTestSuite struct {
suite.Suite
}
func TestDecimalInternalTestSuite(t *testing.T) {
suite.Run(t, new(decimalInternalTestSuite))
}
func (s *decimalInternalTestSuite) TestPrecisionMultiplier() {
res := precisionMultiplier(5)
exp := big.NewInt(10000000000000)
s.Require().Equal(0, res.Cmp(exp), "equality was incorrect, res %v, exp %v", res, exp)
}
func (s *decimalInternalTestSuite) TestZeroDeserializationJSON() {
d := Dec{new(big.Int)}
err := cdc.UnmarshalJSON([]byte(`"0"`), &d)
s.Require().Nil(err)
err = cdc.UnmarshalJSON([]byte(`"{}"`), &d)
s.Require().NotNil(err)
}
func (s *decimalInternalTestSuite) TestSerializationGocodecJSON() {
d := MustNewDecFromStr("0.333")
bz, err := cdc.MarshalJSON(d)
s.Require().NoError(err)
d2 := Dec{new(big.Int)}
err = cdc.UnmarshalJSON(bz, &d2)
s.Require().NoError(err)
s.Require().True(d.Equal(d2), "original: %v, unmarshalled: %v", d, d2)
}
func (s *decimalInternalTestSuite) TestDecMarshalJSON() {
decimal := func(i int64) Dec {
d := NewDec(0)
d.i = new(big.Int).SetInt64(i)
return d
}
tests := []struct {
name string
d Dec
want string
wantErr bool // if wantErr = false, will also attempt unmarshaling
}{
{"zero", decimal(0), "\"0.000000000000000000\"", false},
{"one", decimal(1), "\"0.000000000000000001\"", false},
{"ten", decimal(10), "\"0.000000000000000010\"", false},
{"12340", decimal(12340), "\"0.000000000000012340\"", false},
{"zeroInt", NewDec(0), "\"0.000000000000000000\"", false},
{"oneInt", NewDec(1), "\"1.000000000000000000\"", false},
{"tenInt", NewDec(10), "\"10.000000000000000000\"", false},
{"12340Int", NewDec(12340), "\"12340.000000000000000000\"", false},
}
for _, tt := range tests {
tt := tt
s.T().Run(tt.name, func(t *testing.T) {
got, err := tt.d.MarshalJSON()
if (err != nil) != tt.wantErr {
t.Errorf("Dec.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
s.Require().Equal(tt.want, string(got), "incorrect marshalled value")
unmarshalledDec := NewDec(0)
err := unmarshalledDec.UnmarshalJSON(got)
s.Require().NoError(err)
s.Require().Equal(tt.d, unmarshalledDec, "incorrect unmarshalled value")
}
})
}
}

567
types/decimal_test.go
View File

@ -1,4 +1,4 @@
package types
package types_test
import (
"bytes"
@ -7,186 +7,191 @@ import (
"math/big"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
yaml "gopkg.in/yaml.v2"
sdk "github.com/cosmos/cosmos-sdk/types"
)
type decimalTestSuite struct {
suite.Suite
}
func TestDecimalTestSuite(t *testing.T) {
suite.Run(t, new(decimalTestSuite))
}
// create a decimal from a decimal string (ex. "1234.5678")
func mustNewDecFromStr(t *testing.T, str string) (d Dec) {
d, err := NewDecFromStr(str)
require.NoError(t, err)
func (s *decimalTestSuite) mustNewDecFromStr(str string) (d sdk.Dec) {
d, err := sdk.NewDecFromStr(str)
s.Require().NoError(err)
return d
}
//_______________________________________
func TestPrecisionMultiplier(t *testing.T) {
res := precisionMultiplier(5)
exp := big.NewInt(10000000000000)
require.Equal(t, 0, res.Cmp(exp), "equality was incorrect, res %v, exp %v", res, exp)
}
func TestNewDecFromStr(t *testing.T) {
func (s *decimalTestSuite) TestNewDecFromStr() {
largeBigInt, success := new(big.Int).SetString("3144605511029693144278234343371835", 10)
require.True(t, success)
s.Require().True(success)
tests := []struct {
decimalStr string
expErr bool
exp Dec
exp sdk.Dec
}{
{"", true, Dec{}},
{"0.-75", true, Dec{}},
{"0", false, NewDec(0)},
{"1", false, NewDec(1)},
{"1.1", false, NewDecWithPrec(11, 1)},
{"0.75", false, NewDecWithPrec(75, 2)},
{"0.8", false, NewDecWithPrec(8, 1)},
{"0.11111", false, NewDecWithPrec(11111, 5)},
{"314460551102969.3144278234343371835", true, NewDec(3141203149163817869)},
{"", true, sdk.Dec{}},
{"0.-75", true, sdk.Dec{}},
{"0", false, sdk.NewDec(0)},
{"1", false, sdk.NewDec(1)},
{"1.1", false, sdk.NewDecWithPrec(11, 1)},
{"0.75", false, sdk.NewDecWithPrec(75, 2)},
{"0.8", false, sdk.NewDecWithPrec(8, 1)},
{"0.11111", false, sdk.NewDecWithPrec(11111, 5)},
{"314460551102969.3144278234343371835", true, sdk.NewDec(3141203149163817869)},
{"314460551102969314427823434337.1835718092488231350",
true, NewDecFromBigIntWithPrec(largeBigInt, 4)},
true, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
{"314460551102969314427823434337.1835",
false, NewDecFromBigIntWithPrec(largeBigInt, 4)},
{".", true, Dec{}},
{".0", true, NewDec(0)},
{"1.", true, NewDec(1)},
{"foobar", true, Dec{}},
{"0.foobar", true, Dec{}},
{"0.foobar.", true, Dec{}},
false, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
{".", true, sdk.Dec{}},
{".0", true, sdk.NewDec(0)},
{"1.", true, sdk.NewDec(1)},
{"foobar", true, sdk.Dec{}},
{"0.foobar", true, sdk.Dec{}},
{"0.foobar.", true, sdk.Dec{}},
}
for tcIndex, tc := range tests {
res, err := NewDecFromStr(tc.decimalStr)
res, err := sdk.NewDecFromStr(tc.decimalStr)
if tc.expErr {
require.NotNil(t, err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
s.Require().NotNil(err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
} else {
require.Nil(t, err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
require.True(t, res.Equal(tc.exp), "equality was incorrect, res %v, exp %v, tc %v", res, tc.exp, tcIndex)
s.Require().Nil(err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
s.Require().True(res.Equal(tc.exp), "equality was incorrect, res %v, exp %v, tc %v", res, tc.exp, tcIndex)
}
// negative tc
res, err = NewDecFromStr("-" + tc.decimalStr)
res, err = sdk.NewDecFromStr("-" + tc.decimalStr)
if tc.expErr {
require.NotNil(t, err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
s.Require().NotNil(err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
} else {
require.Nil(t, err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
exp := tc.exp.Mul(NewDec(-1))
require.True(t, res.Equal(exp), "equality was incorrect, res %v, exp %v, tc %v", res, exp, tcIndex)
s.Require().Nil(err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
exp := tc.exp.Mul(sdk.NewDec(-1))
s.Require().True(res.Equal(exp), "equality was incorrect, res %v, exp %v, tc %v", res, exp, tcIndex)
}
}
}
func TestDecString(t *testing.T) {
func (s *decimalTestSuite) TestDecString() {
tests := []struct {
d Dec
d sdk.Dec
want string
}{
{NewDec(0), "0.000000000000000000"},
{NewDec(1), "1.000000000000000000"},
{NewDec(10), "10.000000000000000000"},
{NewDec(12340), "12340.000000000000000000"},
{NewDecWithPrec(12340, 4), "1.234000000000000000"},
{NewDecWithPrec(12340, 5), "0.123400000000000000"},
{NewDecWithPrec(12340, 8), "0.000123400000000000"},
{NewDecWithPrec(1009009009009009009, 17), "10.090090090090090090"},
{sdk.NewDec(0), "0.000000000000000000"},
{sdk.NewDec(1), "1.000000000000000000"},
{sdk.NewDec(10), "10.000000000000000000"},
{sdk.NewDec(12340), "12340.000000000000000000"},
{sdk.NewDecWithPrec(12340, 4), "1.234000000000000000"},
{sdk.NewDecWithPrec(12340, 5), "0.123400000000000000"},
{sdk.NewDecWithPrec(12340, 8), "0.000123400000000000"},
{sdk.NewDecWithPrec(1009009009009009009, 17), "10.090090090090090090"},
}
for tcIndex, tc := range tests {
assert.Equal(t, tc.want, tc.d.String(), "bad String(), index: %v", tcIndex)
s.Require().Equal(tc.want, tc.d.String(), "bad String(), index: %v", tcIndex)
}
}
func TestEqualities(t *testing.T) {
func (s *decimalTestSuite) TestEqualities() {
tests := []struct {
d1, d2 Dec
d1, d2 sdk.Dec
gt, lt, eq bool
}{
{NewDec(0), NewDec(0), false, false, true},
{NewDecWithPrec(0, 2), NewDecWithPrec(0, 4), false, false, true},
{NewDecWithPrec(100, 0), NewDecWithPrec(100, 0), false, false, true},
{NewDecWithPrec(-100, 0), NewDecWithPrec(-100, 0), false, false, true},
{NewDecWithPrec(-1, 1), NewDecWithPrec(-1, 1), false, false, true},
{NewDecWithPrec(3333, 3), NewDecWithPrec(3333, 3), false, false, true},
{sdk.NewDec(0), sdk.NewDec(0), false, false, true},
{sdk.NewDecWithPrec(0, 2), sdk.NewDecWithPrec(0, 4), false, false, true},
{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(100, 0), false, false, true},
{sdk.NewDecWithPrec(-100, 0), sdk.NewDecWithPrec(-100, 0), false, false, true},
{sdk.NewDecWithPrec(-1, 1), sdk.NewDecWithPrec(-1, 1), false, false, true},
{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(3333, 3), false, false, true},
{NewDecWithPrec(0, 0), NewDecWithPrec(3333, 3), false, true, false},
{NewDecWithPrec(0, 0), NewDecWithPrec(100, 0), false, true, false},
{NewDecWithPrec(-1, 0), NewDecWithPrec(3333, 3), false, true, false},
{NewDecWithPrec(-1, 0), NewDecWithPrec(100, 0), false, true, false},
{NewDecWithPrec(1111, 3), NewDecWithPrec(100, 0), false, true, false},
{NewDecWithPrec(1111, 3), NewDecWithPrec(3333, 3), false, true, false},
{NewDecWithPrec(-3333, 3), NewDecWithPrec(-1111, 3), false, true, false},
{sdk.NewDecWithPrec(0, 0), sdk.NewDecWithPrec(3333, 3), false, true, false},
{sdk.NewDecWithPrec(0, 0), sdk.NewDecWithPrec(100, 0), false, true, false},
{sdk.NewDecWithPrec(-1, 0), sdk.NewDecWithPrec(3333, 3), false, true, false},
{sdk.NewDecWithPrec(-1, 0), sdk.NewDecWithPrec(100, 0), false, true, false},
{sdk.NewDecWithPrec(1111, 3), sdk.NewDecWithPrec(100, 0), false, true, false},
{sdk.NewDecWithPrec(1111, 3), sdk.NewDecWithPrec(3333, 3), false, true, false},
{sdk.NewDecWithPrec(-3333, 3), sdk.NewDecWithPrec(-1111, 3), false, true, false},
{NewDecWithPrec(3333, 3), NewDecWithPrec(0, 0), true, false, false},
{NewDecWithPrec(100, 0), NewDecWithPrec(0, 0), true, false, false},
{NewDecWithPrec(3333, 3), NewDecWithPrec(-1, 0), true, false, false},
{NewDecWithPrec(100, 0), NewDecWithPrec(-1, 0), true, false, false},
{NewDecWithPrec(100, 0), NewDecWithPrec(1111, 3), true, false, false},
{NewDecWithPrec(3333, 3), NewDecWithPrec(1111, 3), true, false, false},
{NewDecWithPrec(-1111, 3), NewDecWithPrec(-3333, 3), true, false, false},
{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(0, 0), true, false, false},
{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(0, 0), true, false, false},
{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(-1, 0), true, false, false},
{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(-1, 0), true, false, false},
{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(1111, 3), true, false, false},
{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(1111, 3), true, false, false},
{sdk.NewDecWithPrec(-1111, 3), sdk.NewDecWithPrec(-3333, 3), true, false, false},
}
for tcIndex, tc := range tests {
require.Equal(t, tc.gt, tc.d1.GT(tc.d2), "GT result is incorrect, tc %d", tcIndex)
require.Equal(t, tc.lt, tc.d1.LT(tc.d2), "LT result is incorrect, tc %d", tcIndex)
require.Equal(t, tc.eq, tc.d1.Equal(tc.d2), "equality result is incorrect, tc %d", tcIndex)
s.Require().Equal(tc.gt, tc.d1.GT(tc.d2), "GT result is incorrect, tc %d", tcIndex)
s.Require().Equal(tc.lt, tc.d1.LT(tc.d2), "LT result is incorrect, tc %d", tcIndex)
s.Require().Equal(tc.eq, tc.d1.Equal(tc.d2), "equality result is incorrect, tc %d", tcIndex)
}
}
func TestDecsEqual(t *testing.T) {
func (s *decimalTestSuite) TestDecsEqual() {
tests := []struct {
d1s, d2s []Dec
d1s, d2s []sdk.Dec
eq bool
}{
{[]Dec{NewDec(0)}, []Dec{NewDec(0)}, true},
{[]Dec{NewDec(0)}, []Dec{NewDec(1)}, false},
{[]Dec{NewDec(0)}, []Dec{}, false},
{[]Dec{NewDec(0), NewDec(1)}, []Dec{NewDec(0), NewDec(1)}, true},
{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(1), NewDec(0)}, true},
{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(0), NewDec(1)}, false},
{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(1)}, false},
{[]Dec{NewDec(1), NewDec(2)}, []Dec{NewDec(2), NewDec(4)}, false},
{[]Dec{NewDec(3), NewDec(18)}, []Dec{NewDec(1), NewDec(6)}, false},
{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(0)}, true},
{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1)}, false},
{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{}, false},
{[]sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, []sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, true},
{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, true},
{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, false},
{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1)}, false},
{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(2)}, []sdk.Dec{sdk.NewDec(2), sdk.NewDec(4)}, false},
{[]sdk.Dec{sdk.NewDec(3), sdk.NewDec(18)}, []sdk.Dec{sdk.NewDec(1), sdk.NewDec(6)}, false},
}
for tcIndex, tc := range tests {
require.Equal(t, tc.eq, DecsEqual(tc.d1s, tc.d2s), "equality of decional arrays is incorrect, tc %d", tcIndex)
require.Equal(t, tc.eq, DecsEqual(tc.d2s, tc.d1s), "equality of decional arrays is incorrect (converse), tc %d", tcIndex)
s.Require().Equal(tc.eq, sdk.DecsEqual(tc.d1s, tc.d2s), "equality of decional arrays is incorrect, tc %d", tcIndex)
s.Require().Equal(tc.eq, sdk.DecsEqual(tc.d2s, tc.d1s), "equality of decional arrays is incorrect (converse), tc %d", tcIndex)
}
}
func TestArithmetic(t *testing.T) {
func (s *decimalTestSuite) TestArithmetic() {
tests := []struct {
d1, d2 Dec
expMul, expMulTruncate Dec
expQuo, expQuoRoundUp, expQuoTruncate Dec
expAdd, expSub Dec
d1, d2 sdk.Dec
expMul, expMulTruncate sdk.Dec
expQuo, expQuoRoundUp, expQuoTruncate sdk.Dec
expAdd, expSub sdk.Dec
}{
// d1 d2 MUL MulTruncate QUO QUORoundUp QUOTrunctate ADD SUB
{NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0)},
{NewDec(1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(1), NewDec(1)},
{NewDec(0), NewDec(1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(1), NewDec(-1)},
{NewDec(0), NewDec(-1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(-1), NewDec(1)},
{NewDec(-1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(-1), NewDec(-1)},
{sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0)},
{sdk.NewDec(1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(1)},
{sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(-1)},
{sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(1)},
{sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(-1)},
{NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(2), NewDec(0)},
{NewDec(-1), NewDec(-1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(-2), NewDec(0)},
{NewDec(1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(0), NewDec(2)},
{NewDec(-1), NewDec(1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(0), NewDec(-2)},
{sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(2), sdk.NewDec(0)},
{sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(-2), sdk.NewDec(0)},
{sdk.NewDec(1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(2)},
{sdk.NewDec(-1), sdk.NewDec(1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(-2)},
{NewDec(3), NewDec(7), NewDec(21), NewDec(21),
NewDecWithPrec(428571428571428571, 18), NewDecWithPrec(428571428571428572, 18), NewDecWithPrec(428571428571428571, 18),
NewDec(10), NewDec(-4)},
{NewDec(2), NewDec(4), NewDec(8), NewDec(8), NewDecWithPrec(5, 1), NewDecWithPrec(5, 1), NewDecWithPrec(5, 1),
NewDec(6), NewDec(-2)},
{sdk.NewDec(3), sdk.NewDec(7), sdk.NewDec(21), sdk.NewDec(21),
sdk.NewDecWithPrec(428571428571428571, 18), sdk.NewDecWithPrec(428571428571428572, 18), sdk.NewDecWithPrec(428571428571428571, 18),
sdk.NewDec(10), sdk.NewDec(-4)},
{sdk.NewDec(2), sdk.NewDec(4), sdk.NewDec(8), sdk.NewDec(8), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1),
sdk.NewDec(6), sdk.NewDec(-2)},
{NewDec(100), NewDec(100), NewDec(10000), NewDec(10000), NewDec(1), NewDec(1), NewDec(1), NewDec(200), NewDec(0)},
{sdk.NewDec(100), sdk.NewDec(100), sdk.NewDec(10000), sdk.NewDec(10000), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(200), sdk.NewDec(0)},
{NewDecWithPrec(15, 1), NewDecWithPrec(15, 1), NewDecWithPrec(225, 2), NewDecWithPrec(225, 2),
NewDec(1), NewDec(1), NewDec(1), NewDec(3), NewDec(0)},
{NewDecWithPrec(3333, 4), NewDecWithPrec(333, 4), NewDecWithPrec(1109889, 8), NewDecWithPrec(1109889, 8),
MustNewDecFromStr("10.009009009009009009"), MustNewDecFromStr("10.009009009009009010"), MustNewDecFromStr("10.009009009009009009"),
NewDecWithPrec(3666, 4), NewDecWithPrec(3, 1)},
{sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(225, 2), sdk.NewDecWithPrec(225, 2),
sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(3), sdk.NewDec(0)},
{sdk.NewDecWithPrec(3333, 4), sdk.NewDecWithPrec(333, 4), sdk.NewDecWithPrec(1109889, 8), sdk.NewDecWithPrec(1109889, 8),
sdk.MustNewDecFromStr("10.009009009009009009"), sdk.MustNewDecFromStr("10.009009009009009010"), sdk.MustNewDecFromStr("10.009009009009009009"),
sdk.NewDecWithPrec(3666, 4), sdk.NewDecWithPrec(3, 1)},
}
for tcIndex, tc := range tests {
@ -195,227 +200,167 @@ func TestArithmetic(t *testing.T) {
resSub := tc.d1.Sub(tc.d2)
resMul := tc.d1.Mul(tc.d2)
resMulTruncate := tc.d1.MulTruncate(tc.d2)
require.True(t, tc.expAdd.Equal(resAdd), "exp %v, res %v, tc %d", tc.expAdd, resAdd, tcIndex)
require.True(t, tc.expSub.Equal(resSub), "exp %v, res %v, tc %d", tc.expSub, resSub, tcIndex)
require.True(t, tc.expMul.Equal(resMul), "exp %v, res %v, tc %d", tc.expMul, resMul, tcIndex)
require.True(t, tc.expMulTruncate.Equal(resMulTruncate), "exp %v, res %v, tc %d", tc.expMulTruncate, resMulTruncate, tcIndex)
s.Require().True(tc.expAdd.Equal(resAdd), "exp %v, res %v, tc %d", tc.expAdd, resAdd, tcIndex)
s.Require().True(tc.expSub.Equal(resSub), "exp %v, res %v, tc %d", tc.expSub, resSub, tcIndex)
s.Require().True(tc.expMul.Equal(resMul), "exp %v, res %v, tc %d", tc.expMul, resMul, tcIndex)
s.Require().True(tc.expMulTruncate.Equal(resMulTruncate), "exp %v, res %v, tc %d", tc.expMulTruncate, resMulTruncate, tcIndex)
if tc.d2.IsZero() { // panic for divide by zero
require.Panics(t, func() { tc.d1.Quo(tc.d2) })
s.Require().Panics(func() { tc.d1.Quo(tc.d2) })
} else {
resQuo := tc.d1.Quo(tc.d2)
require.True(t, tc.expQuo.Equal(resQuo), "exp %v, res %v, tc %d", tc.expQuo.String(), resQuo.String(), tcIndex)
s.Require().True(tc.expQuo.Equal(resQuo), "exp %v, res %v, tc %d", tc.expQuo.String(), resQuo.String(), tcIndex)
resQuoRoundUp := tc.d1.QuoRoundUp(tc.d2)
require.True(t, tc.expQuoRoundUp.Equal(resQuoRoundUp), "exp %v, res %v, tc %d",
s.Require().True(tc.expQuoRoundUp.Equal(resQuoRoundUp), "exp %v, res %v, tc %d",
tc.expQuoRoundUp.String(), resQuoRoundUp.String(), tcIndex)
resQuoTruncate := tc.d1.QuoTruncate(tc.d2)
require.True(t, tc.expQuoTruncate.Equal(resQuoTruncate), "exp %v, res %v, tc %d",
s.Require().True(tc.expQuoTruncate.Equal(resQuoTruncate), "exp %v, res %v, tc %d",
tc.expQuoTruncate.String(), resQuoTruncate.String(), tcIndex)
}
}
}
func TestBankerRoundChop(t *testing.T) {
func (s *decimalTestSuite) TestBankerRoundChop() {
tests := []struct {
d1 Dec
d1 sdk.Dec
exp int64
}{
{mustNewDecFromStr(t, "0.25"), 0},
{mustNewDecFromStr(t, "0"), 0},
{mustNewDecFromStr(t, "1"), 1},
{mustNewDecFromStr(t, "0.75"), 1},
{mustNewDecFromStr(t, "0.5"), 0},
{mustNewDecFromStr(t, "7.5"), 8},
{mustNewDecFromStr(t, "1.5"), 2},
{mustNewDecFromStr(t, "2.5"), 2},
{mustNewDecFromStr(t, "0.545"), 1}, // 0.545-> 1 even though 5 is first decimal and 1 not even
{mustNewDecFromStr(t, "1.545"), 2},
{s.mustNewDecFromStr("0.25"), 0},
{s.mustNewDecFromStr("0"), 0},
{s.mustNewDecFromStr("1"), 1},
{s.mustNewDecFromStr("0.75"), 1},
{s.mustNewDecFromStr("0.5"), 0},
{s.mustNewDecFromStr("7.5"), 8},
{s.mustNewDecFromStr("1.5"), 2},
{s.mustNewDecFromStr("2.5"), 2},
{s.mustNewDecFromStr("0.545"), 1}, // 0.545-> 1 even though 5 is first decimal and 1 not even
{s.mustNewDecFromStr("1.545"), 2},
}
for tcIndex, tc := range tests {
resNeg := tc.d1.Neg().RoundInt64()
require.Equal(t, -1*tc.exp, resNeg, "negative tc %d", tcIndex)
s.Require().Equal(-1*tc.exp, resNeg, "negative tc %d", tcIndex)
resPos := tc.d1.RoundInt64()
require.Equal(t, tc.exp, resPos, "positive tc %d", tcIndex)
s.Require().Equal(tc.exp, resPos, "positive tc %d", tcIndex)
}
}
func TestTruncate(t *testing.T) {
func (s *decimalTestSuite) TestTruncate() {
tests := []struct {
d1 Dec
d1 sdk.Dec
exp int64
}{
{mustNewDecFromStr(t, "0"), 0},
{mustNewDecFromStr(t, "0.25"), 0},
{mustNewDecFromStr(t, "0.75"), 0},
{mustNewDecFromStr(t, "1"), 1},
{mustNewDecFromStr(t, "1.5"), 1},
{mustNewDecFromStr(t, "7.5"), 7},
{mustNewDecFromStr(t, "7.6"), 7},
{mustNewDecFromStr(t, "7.4"), 7},
{mustNewDecFromStr(t, "100.1"), 100},
{mustNewDecFromStr(t, "1000.1"), 1000},
{s.mustNewDecFromStr("0"), 0},
{s.mustNewDecFromStr("0.25"), 0},
{s.mustNewDecFromStr("0.75"), 0},
{s.mustNewDecFromStr("1"), 1},
{s.mustNewDecFromStr("1.5"), 1},
{s.mustNewDecFromStr("7.5"), 7},
{s.mustNewDecFromStr("7.6"), 7},
{s.mustNewDecFromStr("7.4"), 7},
{s.mustNewDecFromStr("100.1"), 100},
{s.mustNewDecFromStr("1000.1"), 1000},
}
for tcIndex, tc := range tests {
resNeg := tc.d1.Neg().TruncateInt64()
require.Equal(t, -1*tc.exp, resNeg, "negative tc %d", tcIndex)
s.Require().Equal(-1*tc.exp, resNeg, "negative tc %d", tcIndex)
resPos := tc.d1.TruncateInt64()
require.Equal(t, tc.exp, resPos, "positive tc %d", tcIndex)
s.Require().Equal(tc.exp, resPos, "positive tc %d", tcIndex)
}
}
func TestDecMarshalJSON(t *testing.T) {
decimal := func(i int64) Dec {
d := NewDec(0)
d.i = new(big.Int).SetInt64(i)
return d
}
tests := []struct {
name string
d Dec
want string
wantErr bool // if wantErr = false, will also attempt unmarshaling
}{
{"zero", decimal(0), "\"0.000000000000000000\"", false},
{"one", decimal(1), "\"0.000000000000000001\"", false},
{"ten", decimal(10), "\"0.000000000000000010\"", false},
{"12340", decimal(12340), "\"0.000000000000012340\"", false},
{"zeroInt", NewDec(0), "\"0.000000000000000000\"", false},
{"oneInt", NewDec(1), "\"1.000000000000000000\"", false},
{"tenInt", NewDec(10), "\"10.000000000000000000\"", false},
{"12340Int", NewDec(12340), "\"12340.000000000000000000\"", false},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
got, err := tt.d.MarshalJSON()
if (err != nil) != tt.wantErr {
t.Errorf("Dec.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
assert.Equal(t, tt.want, string(got), "incorrect marshalled value")
unmarshalledDec := NewDec(0)
err := unmarshalledDec.UnmarshalJSON(got)
assert.NoError(t, err)
assert.Equal(t, tt.d, unmarshalledDec, "incorrect unmarshalled value")
}
})
}
}
func TestZeroDeserializationJSON(t *testing.T) {
d := Dec{new(big.Int)}
err := cdc.UnmarshalJSON([]byte(`"0"`), &d)
require.Nil(t, err)
err = cdc.UnmarshalJSON([]byte(`"{}"`), &d)
require.NotNil(t, err)
}
func TestSerializationGocodecJSON(t *testing.T) {
d := mustNewDecFromStr(t, "0.333")
bz, err := cdc.MarshalJSON(d)
require.NoError(t, err)
d2 := Dec{new(big.Int)}
err = cdc.UnmarshalJSON(bz, &d2)
require.NoError(t, err)
require.True(t, d.Equal(d2), "original: %v, unmarshalled: %v", d, d2)
}
func TestStringOverflow(t *testing.T) {
func (s *decimalTestSuite) TestStringOverflow() {
// two random 64 bit primes
dec1, err := NewDecFromStr("51643150036226787134389711697696177267")
require.NoError(t, err)
dec2, err := NewDecFromStr("-31798496660535729618459429845579852627")
require.NoError(t, err)
dec1, err := sdk.NewDecFromStr("51643150036226787134389711697696177267")
s.Require().NoError(err)
dec2, err := sdk.NewDecFromStr("-31798496660535729618459429845579852627")
s.Require().NoError(err)
dec3 := dec1.Add(dec2)
require.Equal(t,
s.Require().Equal(
"19844653375691057515930281852116324640.000000000000000000",
dec3.String(),
)
}
func TestDecMulInt(t *testing.T) {
func (s *decimalTestSuite) TestDecMulInt() {
tests := []struct {
sdkDec Dec
sdkInt Int
want Dec
sdkDec sdk.Dec
sdkInt sdk.Int
want sdk.Dec
}{
{NewDec(10), NewInt(2), NewDec(20)},
{NewDec(1000000), NewInt(100), NewDec(100000000)},
{NewDecWithPrec(1, 1), NewInt(10), NewDec(1)},
{NewDecWithPrec(1, 5), NewInt(20), NewDecWithPrec(2, 4)},
{sdk.NewDec(10), sdk.NewInt(2), sdk.NewDec(20)},
{sdk.NewDec(1000000), sdk.NewInt(100), sdk.NewDec(100000000)},
{sdk.NewDecWithPrec(1, 1), sdk.NewInt(10), sdk.NewDec(1)},
{sdk.NewDecWithPrec(1, 5), sdk.NewInt(20), sdk.NewDecWithPrec(2, 4)},
}
for i, tc := range tests {
got := tc.sdkDec.MulInt(tc.sdkInt)
require.Equal(t, tc.want, got, "Incorrect result on test case %d", i)
s.Require().Equal(tc.want, got, "Incorrect result on test case %d", i)
}
}
func TestDecCeil(t *testing.T) {
func (s *decimalTestSuite) TestDecCeil() {
testCases := []struct {
input Dec
expected Dec
input sdk.Dec
expected sdk.Dec
}{
{NewDecWithPrec(1000000000000000, Precision), NewDec(1)}, // 0.001 => 1.0
{NewDecWithPrec(-1000000000000000, Precision), ZeroDec()}, // -0.001 => 0.0
{ZeroDec(), ZeroDec()}, // 0.0 => 0.0
{NewDecWithPrec(900000000000000000, Precision), NewDec(1)}, // 0.9 => 1.0
{NewDecWithPrec(4001000000000000000, Precision), NewDec(5)}, // 4.001 => 5.0
{NewDecWithPrec(-4001000000000000000, Precision), NewDec(-4)}, // -4.001 => -4.0
{NewDecWithPrec(4700000000000000000, Precision), NewDec(5)}, // 4.7 => 5.0
{NewDecWithPrec(-4700000000000000000, Precision), NewDec(-4)}, // -4.7 => -4.0
{sdk.NewDecWithPrec(1000000000000000, sdk.Precision), sdk.NewDec(1)}, // 0.001 => 1.0
{sdk.NewDecWithPrec(-1000000000000000, sdk.Precision), sdk.ZeroDec()}, // -0.001 => 0.0
{sdk.ZeroDec(), sdk.ZeroDec()}, // 0.0 => 0.0
{sdk.NewDecWithPrec(900000000000000000, sdk.Precision), sdk.NewDec(1)}, // 0.9 => 1.0
{sdk.NewDecWithPrec(4001000000000000000, sdk.Precision), sdk.NewDec(5)}, // 4.001 => 5.0
{sdk.NewDecWithPrec(-4001000000000000000, sdk.Precision), sdk.NewDec(-4)}, // -4.001 => -4.0
{sdk.NewDecWithPrec(4700000000000000000, sdk.Precision), sdk.NewDec(5)}, // 4.7 => 5.0
{sdk.NewDecWithPrec(-4700000000000000000, sdk.Precision), sdk.NewDec(-4)}, // -4.7 => -4.0
}
for i, tc := range testCases {
res := tc.input.Ceil()
require.Equal(t, tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
s.Require().Equal(tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
}
}
func TestPower(t *testing.T) {
func (s *decimalTestSuite) TestPower() {
testCases := []struct {
input Dec
input sdk.Dec
power uint64
expected Dec
expected sdk.Dec
}{
{OneDec(), 10, OneDec()}, // 1.0 ^ (10) => 1.0
{NewDecWithPrec(5, 1), 2, NewDecWithPrec(25, 2)}, // 0.5 ^ 2 => 0.25
{NewDecWithPrec(2, 1), 2, NewDecWithPrec(4, 2)}, // 0.2 ^ 2 => 0.04
{NewDecFromInt(NewInt(3)), 3, NewDecFromInt(NewInt(27))}, // 3 ^ 3 => 27
{NewDecFromInt(NewInt(-3)), 4, NewDecFromInt(NewInt(81))}, // -3 ^ 4 = 81
{NewDecWithPrec(1414213562373095049, 18), 2, NewDecFromInt(NewInt(2))}, // 1.414213562373095049 ^ 2 = 2
{sdk.OneDec(), 10, sdk.OneDec()}, // 1.0 ^ (10) => 1.0
{sdk.NewDecWithPrec(5, 1), 2, sdk.NewDecWithPrec(25, 2)}, // 0.5 ^ 2 => 0.25
{sdk.NewDecWithPrec(2, 1), 2, sdk.NewDecWithPrec(4, 2)}, // 0.2 ^ 2 => 0.04
{sdk.NewDecFromInt(sdk.NewInt(3)), 3, sdk.NewDecFromInt(sdk.NewInt(27))}, // 3 ^ 3 => 27
{sdk.NewDecFromInt(sdk.NewInt(-3)), 4, sdk.NewDecFromInt(sdk.NewInt(81))}, // -3 ^ 4 = 81
{sdk.NewDecWithPrec(1414213562373095049, 18), 2, sdk.NewDecFromInt(sdk.NewInt(2))}, // 1.414213562373095049 ^ 2 = 2
}
for i, tc := range testCases {
res := tc.input.Power(tc.power)
require.True(t, tc.expected.Sub(res).Abs().LTE(SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
s.Require().True(tc.expected.Sub(res).Abs().LTE(sdk.SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
}
}
func TestApproxRoot(t *testing.T) {
func (s *decimalTestSuite) TestApproxRoot() {
testCases := []struct {
input Dec
input sdk.Dec
root uint64
expected Dec
expected sdk.Dec
}{
{OneDec(), 10, OneDec()}, // 1.0 ^ (0.1) => 1.0
{NewDecWithPrec(25, 2), 2, NewDecWithPrec(5, 1)}, // 0.25 ^ (0.5) => 0.5
{NewDecWithPrec(4, 2), 2, NewDecWithPrec(2, 1)}, // 0.04 ^ (0.5) => 0.2
{NewDecFromInt(NewInt(27)), 3, NewDecFromInt(NewInt(3))}, // 27 ^ (1/3) => 3
{NewDecFromInt(NewInt(-81)), 4, NewDecFromInt(NewInt(-3))}, // -81 ^ (0.25) => -3
{NewDecFromInt(NewInt(2)), 2, NewDecWithPrec(1414213562373095049, 18)}, // 2 ^ (0.5) => 1.414213562373095049
{NewDecWithPrec(1005, 3), 31536000, MustNewDecFromStr("1.000000000158153904")}, // 1.005 ^ (1/31536000) ≈ 1.00000000016
{SmallestDec(), 2, NewDecWithPrec(1, 9)}, // 1e-18 ^ (0.5) => 1e-9
{SmallestDec(), 3, MustNewDecFromStr("0.000000999999999997")}, // 1e-18 ^ (1/3) => 1e-6
{NewDecWithPrec(1, 8), 3, MustNewDecFromStr("0.002154434690031900")}, // 1e-8 ^ (1/3) ≈ 0.00215443469
{sdk.OneDec(), 10, sdk.OneDec()}, // 1.0 ^ (0.1) => 1.0
{sdk.NewDecWithPrec(25, 2), 2, sdk.NewDecWithPrec(5, 1)}, // 0.25 ^ (0.5) => 0.5
{sdk.NewDecWithPrec(4, 2), 2, sdk.NewDecWithPrec(2, 1)}, // 0.04 ^ (0.5) => 0.2
{sdk.NewDecFromInt(sdk.NewInt(27)), 3, sdk.NewDecFromInt(sdk.NewInt(3))}, // 27 ^ (1/3) => 3
{sdk.NewDecFromInt(sdk.NewInt(-81)), 4, sdk.NewDecFromInt(sdk.NewInt(-3))}, // -81 ^ (0.25) => -3
{sdk.NewDecFromInt(sdk.NewInt(2)), 2, sdk.NewDecWithPrec(1414213562373095049, 18)}, // 2 ^ (0.5) => 1.414213562373095049
{sdk.NewDecWithPrec(1005, 3), 31536000, sdk.MustNewDecFromStr("1.000000000158153904")}, // 1.005 ^ (1/31536000) ≈ 1.00000000016
{sdk.SmallestDec(), 2, sdk.NewDecWithPrec(1, 9)}, // 1e-18 ^ (0.5) => 1e-9
{sdk.SmallestDec(), 3, sdk.MustNewDecFromStr("0.000000999999999997")}, // 1e-18 ^ (1/3) => 1e-6
{sdk.NewDecWithPrec(1, 8), 3, sdk.MustNewDecFromStr("0.002154434690031900")}, // 1e-8 ^ (1/3) ≈ 0.00215443469
}
// In the case of 1e-8 ^ (1/3), the result repeats every 5 iterations starting from iteration 24
@ -424,88 +369,88 @@ func TestApproxRoot(t *testing.T) {
for i, tc := range testCases {
res, err := tc.input.ApproxRoot(tc.root)
require.NoError(t, err)
require.True(t, tc.expected.Sub(res).Abs().LTE(SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
s.Require().NoError(err)
s.Require().True(tc.expected.Sub(res).Abs().LTE(sdk.SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
}
}
func TestApproxSqrt(t *testing.T) {
func (s *decimalTestSuite) TestApproxSqrt() {
testCases := []struct {
input Dec
expected Dec
input sdk.Dec
expected sdk.Dec
}{
{OneDec(), OneDec()}, // 1.0 => 1.0
{NewDecWithPrec(25, 2), NewDecWithPrec(5, 1)}, // 0.25 => 0.5
{NewDecWithPrec(4, 2), NewDecWithPrec(2, 1)}, // 0.09 => 0.3
{NewDecFromInt(NewInt(9)), NewDecFromInt(NewInt(3))}, // 9 => 3
{NewDecFromInt(NewInt(-9)), NewDecFromInt(NewInt(-3))}, // -9 => -3
{NewDecFromInt(NewInt(2)), NewDecWithPrec(1414213562373095049, 18)}, // 2 => 1.414213562373095049
{sdk.OneDec(), sdk.OneDec()}, // 1.0 => 1.0
{sdk.NewDecWithPrec(25, 2), sdk.NewDecWithPrec(5, 1)}, // 0.25 => 0.5
{sdk.NewDecWithPrec(4, 2), sdk.NewDecWithPrec(2, 1)}, // 0.09 => 0.3
{sdk.NewDecFromInt(sdk.NewInt(9)), sdk.NewDecFromInt(sdk.NewInt(3))}, // 9 => 3
{sdk.NewDecFromInt(sdk.NewInt(-9)), sdk.NewDecFromInt(sdk.NewInt(-3))}, // -9 => -3
{sdk.NewDecFromInt(sdk.NewInt(2)), sdk.NewDecWithPrec(1414213562373095049, 18)}, // 2 => 1.414213562373095049
}
for i, tc := range testCases {
res, err := tc.input.ApproxSqrt()
require.NoError(t, err)
require.Equal(t, tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
s.Require().NoError(err)
s.Require().Equal(tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
}
}
func TestDecSortableBytes(t *testing.T) {
func (s *decimalTestSuite) TestDecSortableBytes() {
tests := []struct {
d Dec
d sdk.Dec
want []byte
}{
{NewDec(0), []byte("000000000000000000.000000000000000000")},
{NewDec(1), []byte("000000000000000001.000000000000000000")},
{NewDec(10), []byte("000000000000000010.000000000000000000")},
{NewDec(12340), []byte("000000000000012340.000000000000000000")},
{NewDecWithPrec(12340, 4), []byte("000000000000000001.234000000000000000")},
{NewDecWithPrec(12340, 5), []byte("000000000000000000.123400000000000000")},
{NewDecWithPrec(12340, 8), []byte("000000000000000000.000123400000000000")},
{NewDecWithPrec(1009009009009009009, 17), []byte("000000000000000010.090090090090090090")},
{NewDecWithPrec(-1009009009009009009, 17), []byte("-000000000000000010.090090090090090090")},
{NewDec(1000000000000000000), []byte("max")},
{NewDec(-1000000000000000000), []byte("--")},
{sdk.NewDec(0), []byte("000000000000000000.000000000000000000")},
{sdk.NewDec(1), []byte("000000000000000001.000000000000000000")},
{sdk.NewDec(10), []byte("000000000000000010.000000000000000000")},
{sdk.NewDec(12340), []byte("000000000000012340.000000000000000000")},
{sdk.NewDecWithPrec(12340, 4), []byte("000000000000000001.234000000000000000")},
{sdk.NewDecWithPrec(12340, 5), []byte("000000000000000000.123400000000000000")},
{sdk.NewDecWithPrec(12340, 8), []byte("000000000000000000.000123400000000000")},
{sdk.NewDecWithPrec(1009009009009009009, 17), []byte("000000000000000010.090090090090090090")},
{sdk.NewDecWithPrec(-1009009009009009009, 17), []byte("-000000000000000010.090090090090090090")},
{sdk.NewDec(1000000000000000000), []byte("max")},
{sdk.NewDec(-1000000000000000000), []byte("--")},
}
for tcIndex, tc := range tests {
assert.Equal(t, tc.want, SortableDecBytes(tc.d), "bad String(), index: %v", tcIndex)
s.Require().Equal(tc.want, sdk.SortableDecBytes(tc.d), "bad String(), index: %v", tcIndex)
}
assert.Panics(t, func() { SortableDecBytes(NewDec(1000000000000000001)) })
assert.Panics(t, func() { SortableDecBytes(NewDec(-1000000000000000001)) })
s.Require().Panics(func() { sdk.SortableDecBytes(sdk.NewDec(1000000000000000001)) })
s.Require().Panics(func() { sdk.SortableDecBytes(sdk.NewDec(-1000000000000000001)) })
}
func TestDecEncoding(t *testing.T) {
func (s *decimalTestSuite) TestDecEncoding() {
testCases := []struct {
input Dec
input sdk.Dec
rawBz string
jsonStr string
yamlStr string
}{
{
NewDec(0), "30",
sdk.NewDec(0), "30",
"\"0.000000000000000000\"",
"\"0.000000000000000000\"\n",
},
{
NewDecWithPrec(4, 2),
sdk.NewDecWithPrec(4, 2),
"3430303030303030303030303030303030",
"\"0.040000000000000000\"",
"\"0.040000000000000000\"\n",
},
{
NewDecWithPrec(-4, 2),
sdk.NewDecWithPrec(-4, 2),
"2D3430303030303030303030303030303030",
"\"-0.040000000000000000\"",
"\"-0.040000000000000000\"\n",
},
{
NewDecWithPrec(1414213562373095049, 18),
sdk.NewDecWithPrec(1414213562373095049, 18),
"31343134323133353632333733303935303439",
"\"1.414213562373095049\"",
"\"1.414213562373095049\"\n",
},
{
NewDecWithPrec(-1414213562373095049, 18),
sdk.NewDecWithPrec(-1414213562373095049, 18),
"2D31343134323133353632333733303935303439",
"\"-1.414213562373095049\"",
"\"-1.414213562373095049\"\n",
@ -514,38 +459,38 @@ func TestDecEncoding(t *testing.T) {
for _, tc := range testCases {
bz, err := tc.input.Marshal()
require.NoError(t, err)
require.Equal(t, tc.rawBz, fmt.Sprintf("%X", bz))
s.Require().NoError(err)
s.Require().Equal(tc.rawBz, fmt.Sprintf("%X", bz))
var other Dec
require.NoError(t, (&other).Unmarshal(bz))
require.True(t, tc.input.Equal(other))
var other sdk.Dec
s.Require().NoError((&other).Unmarshal(bz))
s.Require().True(tc.input.Equal(other))
bz, err = json.Marshal(tc.input)
require.NoError(t, err)
require.Equal(t, tc.jsonStr, string(bz))
require.NoError(t, json.Unmarshal(bz, &other))
require.True(t, tc.input.Equal(other))
s.Require().NoError(err)
s.Require().Equal(tc.jsonStr, string(bz))
s.Require().NoError(json.Unmarshal(bz, &other))
s.Require().True(tc.input.Equal(other))
bz, err = yaml.Marshal(tc.input)
require.NoError(t, err)
require.Equal(t, tc.yamlStr, string(bz))
s.Require().NoError(err)
s.Require().Equal(tc.yamlStr, string(bz))
}
}
func BenchmarkMarshalTo(b *testing.B) {
bis := []struct {
in Dec
in sdk.Dec
want []byte
}{
{
NewDec(1e8), []byte{
sdk.NewDec(1e8), []byte{
0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
},
},
{NewDec(0), []byte{0x30}},
{sdk.NewDec(0), []byte{0x30}},
}
data := make([]byte, 100)

42
types/denom_test.go → types/denom_internal_test.go
View File

@ -3,7 +3,7 @@ package types
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)
var (
@ -13,36 +13,44 @@ var (
natom = "natom" // 10^-9 (nano)
)
func TestRegisterDenom(t *testing.T) {
type internalDenomTestSuite struct {
suite.Suite
}
func TestInternalDenomTestSuite(t *testing.T) {
suite.Run(t, new(internalDenomTestSuite))
}
func (s *internalDenomTestSuite) TestRegisterDenom() {
atomUnit := OneDec() // 1 (base denom unit)
require.NoError(t, RegisterDenom(atom, atomUnit))
require.Error(t, RegisterDenom(atom, atomUnit))
s.Require().NoError(RegisterDenom(atom, atomUnit))
s.Require().Error(RegisterDenom(atom, atomUnit))
res, ok := GetDenomUnit(atom)
require.True(t, ok)
require.Equal(t, atomUnit, res)
s.Require().True(ok)
s.Require().Equal(atomUnit, res)
res, ok = GetDenomUnit(matom)
require.False(t, ok)
require.Equal(t, ZeroDec(), res)
s.Require().False(ok)
s.Require().Equal(ZeroDec(), res)
// reset registration
denomUnits = map[string]Dec{}
}
func TestConvertCoins(t *testing.T) {
func (s *internalDenomTestSuite) TestConvertCoins() {
atomUnit := OneDec() // 1 (base denom unit)
require.NoError(t, RegisterDenom(atom, atomUnit))
s.Require().NoError(RegisterDenom(atom, atomUnit))
matomUnit := NewDecWithPrec(1, 3) // 10^-3 (milli)
require.NoError(t, RegisterDenom(matom, matomUnit))
s.Require().NoError(RegisterDenom(matom, matomUnit))
uatomUnit := NewDecWithPrec(1, 6) // 10^-6 (micro)
require.NoError(t, RegisterDenom(uatom, uatomUnit))
s.Require().NoError(RegisterDenom(uatom, uatomUnit))
natomUnit := NewDecWithPrec(1, 9) // 10^-9 (nano)
require.NoError(t, RegisterDenom(natom, natomUnit))
s.Require().NoError(RegisterDenom(natom, natomUnit))
testCases := []struct {
input Coin
@ -68,12 +76,12 @@ func TestConvertCoins(t *testing.T) {
for i, tc := range testCases {
res, err := ConvertCoin(tc.input, tc.denom)
require.Equal(
t, tc.expErr, err != nil,
s.Require().Equal(
tc.expErr, err != nil,
"unexpected error; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
)
require.Equal(
t, tc.result, res,
s.Require().Equal(
tc.result, res,
"invalid result; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
)
}

92
types/events_test.go
View File

@ -1,77 +1,87 @@
package types
package types_test
import (
"encoding/json"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestAppendEvents(t *testing.T) {
e1 := NewEvent("transfer", NewAttribute("sender", "foo"))
e2 := NewEvent("transfer", NewAttribute("sender", "bar"))
a := Events{e1}
b := Events{e2}
type eventsTestSuite struct {
suite.Suite
}
func TestEventsTestSuite(t *testing.T) {
suite.Run(t, new(eventsTestSuite))
}
func (s *eventsTestSuite) TestAppendEvents() {
e1 := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))
e2 := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "bar"))
a := sdk.Events{e1}
b := sdk.Events{e2}
c := a.AppendEvents(b)
require.Equal(t, c, Events{e1, e2})
require.Equal(t, c, Events{e1}.AppendEvent(NewEvent("transfer", NewAttribute("sender", "bar"))))
require.Equal(t, c, Events{e1}.AppendEvents(Events{e2}))
s.Require().Equal(c, sdk.Events{e1, e2})
s.Require().Equal(c, sdk.Events{e1}.AppendEvent(sdk.NewEvent("transfer", sdk.NewAttribute("sender", "bar"))))
s.Require().Equal(c, sdk.Events{e1}.AppendEvents(sdk.Events{e2}))
}
func TestAppendAttributes(t *testing.T) {
e := NewEvent("transfer", NewAttribute("sender", "foo"))
e = e.AppendAttributes(NewAttribute("recipient", "bar"))
require.Len(t, e.Attributes, 2)
require.Equal(t, e, NewEvent("transfer", NewAttribute("sender", "foo"), NewAttribute("recipient", "bar")))
func (s *eventsTestSuite) TestAppendAttributes() {
e := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))
e = e.AppendAttributes(sdk.NewAttribute("recipient", "bar"))
s.Require().Len(e.Attributes, 2)
s.Require().Equal(e, sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"), sdk.NewAttribute("recipient", "bar")))
}
func TestEmptyEvents(t *testing.T) {
require.Equal(t, EmptyEvents(), Events{})
func (s *eventsTestSuite) TestEmptyEvents() {
s.Require().Equal(sdk.EmptyEvents(), sdk.Events{})
}
func TestAttributeString(t *testing.T) {
require.Equal(t, "foo: bar", NewAttribute("foo", "bar").String())
func (s *eventsTestSuite) TestAttributeString() {
s.Require().Equal("foo: bar", sdk.NewAttribute("foo", "bar").String())
}
func TestToABCIEvents(t *testing.T) {
e := Events{NewEvent("transfer", NewAttribute("sender", "foo"))}
func (s *eventsTestSuite) TestToABCIEvents() {
e := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
abciEvents := e.ToABCIEvents()
require.Len(t, abciEvents, 1)
require.Equal(t, abciEvents[0].Type, e[0].Type)
require.Equal(t, abciEvents[0].Attributes, e[0].Attributes)
s.Require().Len(abciEvents, 1)
s.Require().Equal(abciEvents[0].Type, e[0].Type)
s.Require().Equal(abciEvents[0].Attributes, e[0].Attributes)
}
func TestEventManager(t *testing.T) {
em := NewEventManager()
event := NewEvent("reward", NewAttribute("x", "y"))
events := Events{NewEvent("transfer", NewAttribute("sender", "foo"))}
func (s *eventsTestSuite) TestEventManager() {
em := sdk.NewEventManager()
event := sdk.NewEvent("reward", sdk.NewAttribute("x", "y"))
events := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
em.EmitEvents(events)
em.EmitEvent(event)
require.Len(t, em.Events(), 2)
require.Equal(t, em.Events(), events.AppendEvent(event))
s.Require().Len(em.Events(), 2)
s.Require().Equal(em.Events(), events.AppendEvent(event))
}
func TestStringifyEvents(t *testing.T) {
e := Events{
NewEvent("message", NewAttribute("sender", "foo")),
NewEvent("message", NewAttribute("module", "bank")),
func (s *eventsTestSuite) TestStringifyEvents() {
e := sdk.Events{
sdk.NewEvent("message", sdk.NewAttribute("sender", "foo")),
sdk.NewEvent("message", sdk.NewAttribute("module", "bank")),
}
se := StringifyEvents(e.ToABCIEvents())
se := sdk.StringifyEvents(e.ToABCIEvents())
expectedTxtStr := "\t\t- message\n\t\t\t- sender: foo\n\t\t\t- module: bank"
require.Equal(t, expectedTxtStr, se.String())
s.Require().Equal(expectedTxtStr, se.String())
bz, err := json.Marshal(se)
require.NoError(t, err)
s.Require().NoError(err)
expectedJSONStr := "[{\"type\":\"message\",\"attributes\":[{\"key\":\"sender\",\"value\":\"foo\"},{\"key\":\"module\",\"value\":\"bank\"}]}]"
require.Equal(t, expectedJSONStr, string(bz))
s.Require().Equal(expectedJSONStr, string(bz))
}
func TestMarkEventsToIndex(t *testing.T) {
func (s *eventsTestSuite) TestMarkEventsToIndex() {
events := []abci.Event{
{
Type: "message",
@ -166,8 +176,8 @@ func TestMarkEventsToIndex(t *testing.T) {
for name, tc := range testCases {
tc := tc
t.Run(name, func(t *testing.T) {
require.Equal(t, tc.expected, MarkEventsToIndex(tc.events, tc.indexSet))
s.T().Run(name, func(_ *testing.T) {
s.Require().Equal(tc.expected, sdk.MarkEventsToIndex(tc.events, tc.indexSet))
})
}
}

17
types/invariant_test.go
View File

@ -3,13 +3,20 @@ package types_test
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestFormatInvariant(t *testing.T) {
t.Parallel()
require.Equal(t, ": invariant\n\n", sdk.FormatInvariant("", "", ""))
require.Equal(t, "module: name invariant\nmsg\n", sdk.FormatInvariant("module", "name", "msg"))
type invariantTestSuite struct {
suite.Suite
}
func TestInvariantTestSuite(t *testing.T) {
suite.Run(t, new(invariantTestSuite))
}
func (s *invariantTestSuite) TestFormatInvariant() {
s.Require().Equal(": invariant\n\n", sdk.FormatInvariant("", "", ""))
s.Require().Equal("module: name invariant\nmsg\n", sdk.FormatInvariant("module", "name", "msg"))
}

90
types/result_test.go
View File

@ -5,7 +5,8 @@ import (
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/bytes"
ctypes "github.com/tendermint/tendermint/rpc/core/types"
@ -14,33 +15,38 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestParseABCILog(t *testing.T) {
t.Parallel()
logs := `[{"log":"","msg_index":1,"success":true}]`
res, err := sdk.ParseABCILogs(logs)
require.NoError(t, err)
require.Len(t, res, 1)
require.Equal(t, res[0].Log, "")
require.Equal(t, res[0].MsgIndex, uint32(1))
type resultTestStuite struct {
suite.Suite
}
func TestABCIMessageLog(t *testing.T) {
t.Parallel()
func TestRTestStuite(t *testing.T) {
suite.Run(t, new(resultTestStuite))
}
func (s *resultTestStuite) TestParseABCILog() {
logs := `[{"log":"","msg_index":1,"success":true}]`
res, err := sdk.ParseABCILogs(logs)
s.Require().NoError(err)
s.Require().Len(res, 1)
s.Require().Equal(res[0].Log, "")
s.Require().Equal(res[0].MsgIndex, uint32(1))
}
func (s *resultTestStuite) TestABCIMessageLog() {
cdc := codec.NewLegacyAmino()
events := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
msgLog := sdk.NewABCIMessageLog(0, "", events)
msgLogs := sdk.ABCIMessageLogs{msgLog}
bz, err := cdc.MarshalJSON(msgLogs)
require.NoError(t, err)
require.Equal(t, string(bz), msgLogs.String())
s.Require().NoError(err)
s.Require().Equal(string(bz), msgLogs.String())
}
func TestNewSearchTxsResult(t *testing.T) {
t.Parallel()
func (s *resultTestStuite) TestNewSearchTxsResult() {
got := sdk.NewSearchTxsResult(150, 20, 2, 20, []*sdk.TxResponse{})
require.Equal(t, &sdk.SearchTxsResult{
s.Require().Equal(&sdk.SearchTxsResult{
TotalCount: 150,
Count: 20,
PageNumber: 2,
@ -50,21 +56,7 @@ func TestNewSearchTxsResult(t *testing.T) {
}, got)
}
/*
Codespace: res.TxResult.Codespace,
Code: res.TxResult.Code,
Data: strings.ToUpper(hex.EncodeToString(res.TxResult.Data)),
RawLog: res.TxResult.Log,
Logs: parsedLogs,
Info: res.TxResult.Info,
GasWanted: res.TxResult.GasWanted,
GasUsed: res.TxResult.GasUsed,
Tx: tx,
Timestamp: timestamp,
*/
func TestResponseResultTx(t *testing.T) {
t.Parallel()
func (s *resultTestStuite) TestResponseResultTx() {
deliverTxResult := abci.ResponseDeliverTx{
Codespace: "codespace",
Code: 1,
@ -80,7 +72,9 @@ func TestResponseResultTx(t *testing.T) {
TxResult: deliverTxResult,
}
logs, err := sdk.ParseABCILogs(`[]`)
require.NoError(t, err)
s.Require().NoError(err)
want := &sdk.TxResponse{
TxHash: "74657374",
Height: 10,
@ -96,9 +90,9 @@ func TestResponseResultTx(t *testing.T) {
Timestamp: "timestamp",
}
require.Equal(t, want, sdk.NewResponseResultTx(resultTx, nil, "timestamp"))
require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseResultTx(nil, nil, "timestamp"))
require.Equal(t, `Response:
s.Require().Equal(want, sdk.NewResponseResultTx(resultTx, nil, "timestamp"))
s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseResultTx(nil, nil, "timestamp"))
s.Require().Equal(`Response:
Height: 10
TxHash: 74657374
Code: 1
@ -110,8 +104,8 @@ func TestResponseResultTx(t *testing.T) {
GasUsed: 90
Codespace: codespace
Timestamp: timestamp`, sdk.NewResponseResultTx(resultTx, nil, "timestamp").String())
require.True(t, sdk.TxResponse{}.Empty())
require.False(t, want.Empty())
s.Require().True(sdk.TxResponse{}.Empty())
s.Require().False(want.Empty())
resultBroadcastTx := &ctypes.ResultBroadcastTx{
Code: 1,
@ -120,7 +114,8 @@ func TestResponseResultTx(t *testing.T) {
Log: `[]`,
Hash: bytes.HexBytes([]byte("test")),
}
require.Equal(t, &sdk.TxResponse{
s.Require().Equal(&sdk.TxResponse{
Code: 1,
Codespace: "codespace",
Data: "64617461",
@ -128,16 +123,15 @@ func TestResponseResultTx(t *testing.T) {
Logs: logs,
TxHash: "74657374",
}, sdk.NewResponseFormatBroadcastTx(resultBroadcastTx))
require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTx(nil))
s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTx(nil))
}
func TestResponseFormatBroadcastTxCommit(t *testing.T) {
func (s *resultTestStuite) TestResponseFormatBroadcastTxCommit() {
// test nil
require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTxCommit(nil))
s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTxCommit(nil))
logs, err := sdk.ParseABCILogs(`[]`)
require.NoError(t, err)
s.Require().NoError(err)
// test checkTx
checkTxResult := &ctypes.ResultBroadcastTxCommit{
@ -166,7 +160,6 @@ func TestResponseFormatBroadcastTxCommit(t *testing.T) {
Codespace: "codespace",
},
}
want := &sdk.TxResponse{
Height: 10,
TxHash: "74657374",
@ -179,6 +172,7 @@ func TestResponseFormatBroadcastTxCommit(t *testing.T) {
GasWanted: 99,
GasUsed: 100,
}
require.Equal(t, want, sdk.NewResponseFormatBroadcastTxCommit(checkTxResult))
require.Equal(t, want, sdk.NewResponseFormatBroadcastTxCommit(deliverTxResult))
s.Require().Equal(want, sdk.NewResponseFormatBroadcastTxCommit(checkTxResult))
s.Require().Equal(want, sdk.NewResponseFormatBroadcastTxCommit(deliverTxResult))
}

31
types/router_test.go
View File

@ -1,37 +1,47 @@
package types
package types_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestNilRoute(t *testing.T) {
type routeTestSuite struct {
suite.Suite
}
func TestRouteTestSuite(t *testing.T) {
suite.Run(t, new(routeTestSuite))
}
func (s *routeTestSuite) TestNilRoute() {
tests := []struct {
name string
route Route
route sdk.Route
expected bool
}{
{
name: "all empty",
route: NewRoute("", nil),
route: sdk.NewRoute("", nil),
expected: true,
},
{
name: "only path",
route: NewRoute("some", nil),
route: sdk.NewRoute("some", nil),
expected: true,
},
{
name: "only handler",
route: NewRoute("", func(ctx Context, msg Msg) (*Result, error) {
route: sdk.NewRoute("", func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
return nil, nil
}),
expected: true,
},
{
name: "correct route",
route: NewRoute("some", func(ctx Context, msg Msg) (*Result, error) {
route: sdk.NewRoute("some", func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
return nil, nil
}),
expected: false,
@ -39,9 +49,6 @@ func TestNilRoute(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
assert.Equal(t, tt.expected, tt.route.Empty())
})
s.Require().Equal(tt.expected, tt.route.Empty())
}
}

32
types/staking_test.go
View File

@ -3,22 +3,30 @@ package types_test
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestBondStatus(t *testing.T) {
require.False(t, sdk.Unbonded.Equal(sdk.Bonded))
require.False(t, sdk.Unbonded.Equal(sdk.Unbonding))
require.False(t, sdk.Bonded.Equal(sdk.Unbonding))
require.Panicsf(t, func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet
require.Equal(t, sdk.BondStatusUnbonded, sdk.Unbonded.String())
require.Equal(t, sdk.BondStatusBonded, sdk.Bonded.String())
require.Equal(t, sdk.BondStatusUnbonding, sdk.Unbonding.String())
type stakingTestSuite struct {
suite.Suite
}
func TestTokensToConsensusPower(t *testing.T) {
require.Equal(t, int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999)))
require.Equal(t, int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000)))
func TestStakingTestSuite(t *testing.T) {
suite.Run(t, new(stakingTestSuite))
}
func (s *stakingTestSuite) TestBondStatus() {
s.Require().False(sdk.Unbonded.Equal(sdk.Bonded))
s.Require().False(sdk.Unbonded.Equal(sdk.Unbonding))
s.Require().False(sdk.Bonded.Equal(sdk.Unbonding))
s.Require().Panicsf(func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet
s.Require().Equal(sdk.BondStatusUnbonded, sdk.Unbonded.String())
s.Require().Equal(sdk.BondStatusBonded, sdk.Bonded.String())
s.Require().Equal(sdk.BondStatusUnbonding, sdk.Unbonding.String())
}
func (s *stakingTestSuite) TestTokensToConsensusPower() {
s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999)))
s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000)))
}

75
types/store_test.go
View File

@ -3,7 +3,7 @@ package types_test
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/store/rootmulti"
@ -11,7 +11,15 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestPrefixEndBytes(t *testing.T) {
type storeTestSuite struct {
suite.Suite
}
func TestStoreTestSuite(t *testing.T) {
suite.Run(t, new(storeTestSuite))
}
func (s *storeTestSuite) TestPrefixEndBytes() {
var testCases = []struct {
prefix []byte
expected []byte
@ -27,69 +35,64 @@ func TestPrefixEndBytes(t *testing.T) {
for _, test := range testCases {
end := sdk.PrefixEndBytes(test.prefix)
require.Equal(t, test.expected, end)
s.Require().Equal(test.expected, end)
}
}
func TestCommitID(t *testing.T) {
func (s *storeTestSuite) TestCommitID() {
var empty sdk.CommitID
require.True(t, empty.IsZero())
s.Require().True(empty.IsZero())
var nonempty = sdk.CommitID{
Version: 1,
Hash: []byte("testhash"),
}
require.False(t, nonempty.IsZero())
s.Require().False(nonempty.IsZero())
}
func TestNewKVStoreKeys(t *testing.T) {
t.Parallel()
require.Equal(t, map[string]*sdk.KVStoreKey{}, sdk.NewKVStoreKeys())
require.Equal(t, 1, len(sdk.NewKVStoreKeys("one")))
func (s *storeTestSuite) TestNewKVStoreKeys() {
s.Require().Equal(map[string]*sdk.KVStoreKey{}, sdk.NewKVStoreKeys())
s.Require().Equal(1, len(sdk.NewKVStoreKeys("one")))
}
func TestNewTransientStoreKeys(t *testing.T) {
t.Parallel()
require.Equal(t, map[string]*sdk.TransientStoreKey{}, sdk.NewTransientStoreKeys())
require.Equal(t, 1, len(sdk.NewTransientStoreKeys("one")))
func (s *storeTestSuite) TestNewTransientStoreKeys() {
s.Require().Equal(map[string]*sdk.TransientStoreKey{}, sdk.NewTransientStoreKeys())
s.Require().Equal(1, len(sdk.NewTransientStoreKeys("one")))
}
func TestNewInfiniteGasMeter(t *testing.T) {
t.Parallel()
func (s *storeTestSuite) TestNewInfiniteGasMeter() {
gm := sdk.NewInfiniteGasMeter()
require.NotNil(t, gm)
s.Require().NotNil(gm)
_, ok := gm.(types.GasMeter)
require.True(t, ok)
s.Require().True(ok)
}
func TestStoreTypes(t *testing.T) {
t.Parallel()
require.Equal(t, sdk.InclusiveEndBytes([]byte("endbytes")), types.InclusiveEndBytes([]byte("endbytes")))
func (s *storeTestSuite) TestStoreTypes() {
s.Require().Equal(sdk.InclusiveEndBytes([]byte("endbytes")), types.InclusiveEndBytes([]byte("endbytes")))
}
func TestDiffKVStores(t *testing.T) {
t.Parallel()
store1, store2 := initTestStores(t)
func (s *storeTestSuite) TestDiffKVStores() {
store1, store2 := s.initTestStores()
// Two equal stores
k1, v1 := []byte("k1"), []byte("v1")
store1.Set(k1, v1)
store2.Set(k1, v1)
checkDiffResults(t, store1, store2)
s.checkDiffResults(store1, store2)
// delete k1 from store2, which is now empty
store2.Delete(k1)
checkDiffResults(t, store1, store2)
s.checkDiffResults(store1, store2)
// set k1 in store2, different value than what store1 holds for k1
v2 := []byte("v2")
store2.Set(k1, v2)
checkDiffResults(t, store1, store2)
s.checkDiffResults(store1, store2)
// add k2 to store2
k2 := []byte("k2")
store2.Set(k2, v2)
checkDiffResults(t, store1, store2)
s.checkDiffResults(store1, store2)
// Reset stores
store1.Delete(k1)
@ -101,24 +104,24 @@ func TestDiffKVStores(t *testing.T) {
k1Prefixed := append(prefix, k1...)
store1.Set(k1Prefixed, v1)
store2.Set(k1Prefixed, v2)
checkDiffResults(t, store1, store2)
s.checkDiffResults(store1, store2)
}
func initTestStores(t *testing.T) (types.KVStore, types.KVStore) {
func (s *storeTestSuite) initTestStores() (types.KVStore, types.KVStore) {
db := dbm.NewMemDB()
ms := rootmulti.NewStore(db)
key1 := types.NewKVStoreKey("store1")
key2 := types.NewKVStoreKey("store2")
require.NotPanics(t, func() { ms.MountStoreWithDB(key1, types.StoreTypeIAVL, db) })
require.NotPanics(t, func() { ms.MountStoreWithDB(key2, types.StoreTypeIAVL, db) })
require.NoError(t, ms.LoadLatestVersion())
s.Require().NotPanics(func() { ms.MountStoreWithDB(key1, types.StoreTypeIAVL, db) })
s.Require().NotPanics(func() { ms.MountStoreWithDB(key2, types.StoreTypeIAVL, db) })
s.Require().NoError(ms.LoadLatestVersion())
return ms.GetKVStore(key1), ms.GetKVStore(key2)
}
func checkDiffResults(t *testing.T, store1, store2 types.KVStore) {
func (s *storeTestSuite) checkDiffResults(store1, store2 types.KVStore) {
kvAs1, kvBs1 := sdk.DiffKVStores(store1, store2, nil)
kvAs2, kvBs2 := types.DiffKVStores(store1, store2, nil)
require.Equal(t, kvAs1, kvAs2)
require.Equal(t, kvBs1, kvBs2)
s.Require().Equal(kvAs1, kvAs2)
s.Require().Equal(kvBs1, kvBs2)
}

28
types/tx_msg_test.go
View File

@ -3,23 +3,29 @@ package types_test
import (
"testing"
"github.com/stretchr/testify/suite"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
"github.com/stretchr/testify/require"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestTestMsg(t *testing.T) {
t.Parallel()
type msgTestSuite struct {
suite.Suite
}
func TestMsgTestSuite(t *testing.T) {
suite.Run(t, new(msgTestSuite))
}
func (s *msgTestSuite) TestTestMsg() {
addr := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
accAddr := sdk.AccAddress(addr)
msg := testdata.NewTestMsg(accAddr)
require.NotNil(t, msg)
require.Equal(t, "TestMsg", msg.Route())
require.Equal(t, "Test message", msg.Type())
require.Nil(t, msg.ValidateBasic())
require.NotPanics(t, func() { msg.GetSignBytes() })
require.Equal(t, []sdk.AccAddress{accAddr}, msg.GetSigners())
s.Require().NotNil(msg)
s.Require().Equal("TestMsg", msg.Route())
s.Require().Equal("Test message", msg.Type())
s.Require().Nil(msg.ValidateBasic())
s.Require().NotPanics(func() { msg.GetSignBytes() })
s.Require().Equal([]sdk.AccAddress{accAddr}, msg.GetSigners())
}

3
x/genutil/utils.go
View File

@ -5,13 +5,14 @@ import (
"path/filepath"
"time"
"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
tmos "github.com/tendermint/tendermint/libs/os"
"github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/privval"
tmtypes "github.com/tendermint/tendermint/types"
"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
)
// ExportGenesisFile creates and writes the genesis configuration to disk. An