2020-09-27 14:51:14 -07:00
|
|
|
package types_test
|
2016-04-01 15:19:07 -07:00
|
|
|
|
|
|
|
import (
|
2020-06-30 11:11:29 -07:00
|
|
|
"fmt"
|
2019-02-15 07:33:23 -08:00
|
|
|
"strings"
|
2016-04-01 15:19:07 -07:00
|
|
|
"testing"
|
2017-02-22 14:30:50 -08:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
"github.com/stretchr/testify/suite"
|
2019-07-22 08:26:42 -07:00
|
|
|
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2016-04-01 15:19:07 -07:00
|
|
|
)
|
|
|
|
|
2019-02-15 07:33:23 -08:00
|
|
|
var (
|
|
|
|
testDenom1 = "atom"
|
|
|
|
testDenom2 = "muon"
|
|
|
|
)
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
type coinTestSuite struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
suite.Suite
|
2021-05-05 08:55:28 -07:00
|
|
|
ca0, ca1, ca2, cm0, cm1, cm2 sdk.Coin
|
2020-09-27 14:51:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestCoinTestSuite(t *testing.T) {
|
2020-09-28 03:46:49 -07:00
|
|
|
suite.Run(t, new(coinTestSuite))
|
2020-09-27 14:51:14 -07:00
|
|
|
}
|
|
|
|
|
2020-09-29 04:29:10 -07:00
|
|
|
func (s *coinTestSuite) SetupSuite() {
|
|
|
|
s.T().Parallel()
|
2021-05-05 08:55:28 -07:00
|
|
|
zero := sdk.NewInt(0)
|
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
s.ca0, s.ca1, s.ca2 = sdk.Coin{testDenom1, zero}, sdk.Coin{testDenom1, one}, sdk.Coin{testDenom1, two}
|
|
|
|
s.cm0, s.cm1, s.cm2 = sdk.Coin{testDenom2, zero}, sdk.Coin{testDenom2, one}, sdk.Coin{testDenom2, two}
|
2020-09-29 04:29:10 -07:00
|
|
|
}
|
|
|
|
|
2018-11-20 01:22:35 -08:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Coin tests
|
2018-03-25 10:35:45 -07:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoin() {
|
2020-09-27 14:51:14 -07:00
|
|
|
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)
|
|
|
|
s.Require().Equal(sdk.NewInt(10), sdk.NewCoin(strings.ToUpper(testDenom1), sdk.NewInt(10)).Amount)
|
|
|
|
s.Require().Equal(sdk.NewInt(5), sdk.NewInt64Coin(testDenom1, 5).Amount)
|
|
|
|
s.Require().Equal(sdk.NewInt(5), sdk.NewCoin(testDenom1, sdk.NewInt(5)).Amount)
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoin_String() {
|
2020-09-27 14:51:14 -07:00
|
|
|
coin := sdk.NewCoin(testDenom1, sdk.NewInt(10))
|
|
|
|
s.Require().Equal(fmt.Sprintf("10%s", testDenom1), coin.String())
|
2020-06-30 11:11:29 -07:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestIsEqualCoin() {
|
2018-03-25 10:35:45 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
2018-03-25 10:35:45 -07:00
|
|
|
expected bool
|
2019-02-15 07:33:23 -08:00
|
|
|
panics bool
|
2018-03-25 10:35:45 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), true, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true},
|
|
|
|
{sdk.NewInt64Coin("stake", 1), sdk.NewInt64Coin("stake", 10), false, false},
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2018-07-16 11:42:28 -07:00
|
|
|
for tcIndex, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2019-02-15 07:33:23 -08:00
|
|
|
if tc.panics {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.IsEqual(tc.inputTwo) })
|
2019-02-15 07:33:23 -08:00
|
|
|
} else {
|
|
|
|
res := tc.inputOne.IsEqual(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "coin equality relation is incorrect, tc #%d", tcIndex)
|
2019-02-15 07:33:23 -08:00
|
|
|
}
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinIsValid() {
|
2020-08-14 02:09:53 -07:00
|
|
|
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.`
|
|
|
|
|
|
|
|
loremIpsum = strings.ReplaceAll(loremIpsum, " ", "")
|
|
|
|
loremIpsum = strings.ReplaceAll(loremIpsum, ".", "")
|
|
|
|
loremIpsum = strings.ReplaceAll(loremIpsum, ",", "")
|
|
|
|
|
2019-06-18 09:02:31 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
coin sdk.Coin
|
2019-06-18 09:02:31 -07:00
|
|
|
expectPass bool
|
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.Coin{testDenom1, sdk.NewInt(-1)}, false},
|
|
|
|
{sdk.Coin{testDenom1, sdk.NewInt(0)}, true},
|
|
|
|
{sdk.Coin{testDenom1, sdk.OneInt()}, true},
|
|
|
|
{sdk.Coin{"Atom", sdk.OneInt()}, true},
|
|
|
|
{sdk.Coin{"ATOM", sdk.OneInt()}, true},
|
|
|
|
{sdk.Coin{"a", sdk.OneInt()}, false},
|
|
|
|
{sdk.Coin{loremIpsum, sdk.OneInt()}, false},
|
|
|
|
{sdk.Coin{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.OneInt()}, true},
|
|
|
|
{sdk.Coin{"atOm", sdk.OneInt()}, true},
|
2021-09-27 13:01:20 -07:00
|
|
|
{sdk.Coin{"x:y-z.1_2", sdk.OneInt()}, true},
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.Coin{" ", sdk.OneInt()}, false},
|
2019-06-18 09:02:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range cases {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expectPass, tc.coin.IsValid(), "unexpected result for IsValid, tc #%d", i)
|
2019-06-18 09:02:31 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-06 10:06:41 -07:00
|
|
|
func (s *coinTestSuite) TestCustomValidation() {
|
|
|
|
|
|
|
|
newDnmRegex := `[\x{1F600}-\x{1F6FF}]`
|
2020-11-20 11:37:45 -08:00
|
|
|
sdk.SetCoinDenomRegex(func() string {
|
2020-10-06 10:06:41 -07:00
|
|
|
return newDnmRegex
|
2020-11-20 11:37:45 -08:00
|
|
|
})
|
2020-10-06 10:06:41 -07:00
|
|
|
|
|
|
|
cases := []struct {
|
|
|
|
coin sdk.Coin
|
|
|
|
expectPass bool
|
|
|
|
}{
|
|
|
|
{sdk.Coin{"🙂", sdk.NewInt(1)}, true},
|
|
|
|
{sdk.Coin{"🙁", sdk.NewInt(1)}, true},
|
|
|
|
{sdk.Coin{"🌶", sdk.NewInt(1)}, false}, // outside the unicode range listed above
|
|
|
|
{sdk.Coin{"asdf", sdk.NewInt(1)}, false},
|
|
|
|
{sdk.Coin{"", sdk.NewInt(1)}, false},
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range cases {
|
|
|
|
s.Require().Equal(tc.expectPass, tc.coin.IsValid(), "unexpected result for IsValid, tc #%d", i)
|
|
|
|
}
|
2020-11-20 11:37:45 -08:00
|
|
|
sdk.SetCoinDenomRegex(sdk.DefaultCoinDenomRegex)
|
2020-10-06 10:06:41 -07:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestAddCoin() {
|
2018-09-19 08:25:52 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
|
|
|
expected sdk.Coin
|
2018-11-20 01:22:35 -08:00
|
|
|
shouldPanic bool
|
2018-09-19 08:25:52 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 2), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom1, 1), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), sdk.NewInt64Coin(testDenom1, 1), true},
|
2018-09-19 08:25:52 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for tcIndex, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2018-11-20 01:22:35 -08:00
|
|
|
if tc.shouldPanic {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.Add(tc.inputTwo) })
|
2018-11-20 01:22:35 -08:00
|
|
|
} else {
|
2019-02-21 09:35:55 -08:00
|
|
|
res := tc.inputOne.Add(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex)
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
2018-09-19 08:25:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-13 08:01:21 -07:00
|
|
|
func (s *coinTestSuite) TestAddCoinAmount() {
|
|
|
|
cases := []struct {
|
|
|
|
coin sdk.Coin
|
|
|
|
amount sdk.Int
|
|
|
|
expected sdk.Coin
|
|
|
|
}{
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 2)},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(0), sdk.NewInt64Coin(testDenom1, 1)},
|
|
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
|
|
res := tc.coin.AddAmount(tc.amount)
|
|
|
|
s.Require().Equal(tc.expected, res, "result of addition is incorrect, tc #%d", i)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestSubCoin() {
|
2018-03-25 10:35:45 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
|
|
|
expected sdk.Coin
|
2018-11-20 01:22:35 -08:00
|
|
|
shouldPanic bool
|
2018-03-25 10:35:45 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), sdk.NewInt64Coin(testDenom1, 1), true},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 10), sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 9), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt64Coin(testDenom1, 3), sdk.NewInt64Coin(testDenom1, 2), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom1, 5), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 5), sdk.Coin{}, true},
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2018-07-16 11:42:28 -07:00
|
|
|
for tcIndex, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2018-11-20 01:22:35 -08:00
|
|
|
if tc.shouldPanic {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.Sub(tc.inputTwo) })
|
2018-11-20 01:22:35 -08:00
|
|
|
} else {
|
2019-02-21 09:35:55 -08:00
|
|
|
res := tc.inputOne.Sub(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "difference of coins is incorrect, tc #%d", tcIndex)
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
2018-11-20 01:22:35 -08:00
|
|
|
|
|
|
|
tc := struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
2018-11-20 01:22:35 -08:00
|
|
|
expected int64
|
2020-09-27 14:51:14 -07:00
|
|
|
}{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), 0}
|
2019-02-21 09:35:55 -08:00
|
|
|
res := tc.inputOne.Sub(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res.Amount.Int64())
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2021-04-13 08:01:21 -07:00
|
|
|
func (s *coinTestSuite) TestSubCoinAmount() {
|
|
|
|
cases := []struct {
|
|
|
|
coin sdk.Coin
|
|
|
|
amount sdk.Int
|
|
|
|
expected sdk.Coin
|
|
|
|
shouldPanic bool
|
|
|
|
}{
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 1), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 10), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 9), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt(3), sdk.NewInt64Coin(testDenom1, 2), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt(0), sdk.NewInt64Coin(testDenom1, 5), false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(5), sdk.Coin{}, true},
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range cases {
|
|
|
|
if tc.shouldPanic {
|
|
|
|
s.Require().Panics(func() { tc.coin.SubAmount(tc.amount) })
|
|
|
|
} else {
|
|
|
|
res := tc.coin.SubAmount(tc.amount)
|
|
|
|
s.Require().Equal(tc.expected, res, "result of subtraction is incorrect, tc #%d", i)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestIsGTECoin() {
|
2018-03-25 10:35:45 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
2018-11-20 01:22:35 -08:00
|
|
|
expected bool
|
2019-02-15 07:33:23 -08:00
|
|
|
panics bool
|
2018-03-25 10:35:45 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), true, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt64Coin(testDenom1, 1), true, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true},
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2018-07-16 11:42:28 -07:00
|
|
|
for tcIndex, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2019-02-15 07:33:23 -08:00
|
|
|
if tc.panics {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.IsGTE(tc.inputTwo) })
|
2019-02-15 07:33:23 -08:00
|
|
|
} else {
|
|
|
|
res := tc.inputOne.IsGTE(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "coin GTE relation is incorrect, tc #%d", tcIndex)
|
2019-02-15 07:33:23 -08:00
|
|
|
}
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestIsLTCoin() {
|
2018-03-25 10:35:45 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coin
|
|
|
|
inputTwo sdk.Coin
|
2018-11-20 01:22:35 -08:00
|
|
|
expected bool
|
2019-02-15 07:33:23 -08:00
|
|
|
panics bool
|
2018-03-25 10:35:45 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), false, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt64Coin(testDenom1, 1), false, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1), false, true},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), false, false},
|
|
|
|
{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 2), true, false},
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2018-07-16 11:42:28 -07:00
|
|
|
for tcIndex, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2019-02-15 07:33:23 -08:00
|
|
|
if tc.panics {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.IsLT(tc.inputTwo) })
|
2019-02-15 07:33:23 -08:00
|
|
|
} else {
|
|
|
|
res := tc.inputOne.IsLT(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "coin LT relation is incorrect, tc #%d", tcIndex)
|
2019-02-15 07:33:23 -08:00
|
|
|
}
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
2018-06-15 14:16:45 -07:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinIsZero() {
|
2020-09-27 14:51:14 -07:00
|
|
|
coin := sdk.NewInt64Coin(testDenom1, 0)
|
2018-11-20 01:22:35 -08:00
|
|
|
res := coin.IsZero()
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().True(res)
|
2018-06-15 14:16:45 -07:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
coin = sdk.NewInt64Coin(testDenom1, 1)
|
2018-11-20 01:22:35 -08:00
|
|
|
res = coin.IsZero()
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().False(res)
|
2018-03-25 10:35:45 -07:00
|
|
|
}
|
|
|
|
|
2021-10-12 02:11:14 -07:00
|
|
|
func (s *coinTestSuite) TestCoinIsNil() {
|
|
|
|
coin := sdk.Coin{}
|
|
|
|
res := coin.IsNil()
|
|
|
|
s.Require().True(res)
|
|
|
|
|
|
|
|
coin = sdk.Coin{Denom: "uatom"}
|
|
|
|
res = coin.IsNil()
|
|
|
|
s.Require().True(res)
|
|
|
|
|
|
|
|
coin = sdk.NewInt64Coin(testDenom1, 1)
|
|
|
|
res = coin.IsNil()
|
|
|
|
s.Require().False(res)
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestFilteredZeroCoins() {
|
2020-07-28 03:17:58 -07:00
|
|
|
cases := []struct {
|
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
input sdk.Coins
|
2020-07-28 03:17:58 -07:00
|
|
|
original string
|
|
|
|
expected string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "all greater than zero",
|
2020-09-27 14:51:14 -07:00
|
|
|
input: sdk.Coins{
|
|
|
|
{"testa", sdk.OneInt()},
|
|
|
|
{"testb", sdk.NewInt(2)},
|
|
|
|
{"testc", sdk.NewInt(3)},
|
|
|
|
{"testd", sdk.NewInt(4)},
|
|
|
|
{"teste", sdk.NewInt(5)},
|
2020-07-28 03:17:58 -07:00
|
|
|
},
|
|
|
|
original: "1testa,2testb,3testc,4testd,5teste",
|
|
|
|
expected: "1testa,2testb,3testc,4testd,5teste",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "zero coin in middle",
|
2020-09-27 14:51:14 -07:00
|
|
|
input: sdk.Coins{
|
|
|
|
{"testa", sdk.OneInt()},
|
|
|
|
{"testb", sdk.NewInt(2)},
|
|
|
|
{"testc", sdk.NewInt(0)},
|
|
|
|
{"testd", sdk.NewInt(4)},
|
|
|
|
{"teste", sdk.NewInt(5)},
|
2020-07-28 03:17:58 -07:00
|
|
|
},
|
|
|
|
original: "1testa,2testb,0testc,4testd,5teste",
|
|
|
|
expected: "1testa,2testb,4testd,5teste",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "zero coin end (unordered)",
|
2020-09-27 14:51:14 -07:00
|
|
|
input: sdk.Coins{
|
|
|
|
{"teste", sdk.NewInt(5)},
|
|
|
|
{"testc", sdk.NewInt(3)},
|
|
|
|
{"testa", sdk.OneInt()},
|
|
|
|
{"testd", sdk.NewInt(4)},
|
|
|
|
{"testb", sdk.NewInt(0)},
|
2020-07-28 03:17:58 -07:00
|
|
|
},
|
|
|
|
original: "5teste,3testc,1testa,4testd,0testb",
|
|
|
|
expected: "1testa,3testc,4testd,5teste",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range cases {
|
2020-09-27 14:51:14 -07:00
|
|
|
undertest := sdk.NewCoins(tt.input...)
|
|
|
|
s.Require().Equal(tt.expected, undertest.String(), "NewCoins must return expected results")
|
|
|
|
s.Require().Equal(tt.original, tt.input.String(), "input must be unmodified and match original")
|
2020-07-28 03:17:58 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-20 01:22:35 -08:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Coins tests
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoins_String() {
|
2020-06-30 11:11:29 -07:00
|
|
|
cases := []struct {
|
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
input sdk.Coins
|
2020-06-30 11:11:29 -07:00
|
|
|
expected string
|
|
|
|
}{
|
|
|
|
{
|
2020-08-14 02:09:53 -07:00
|
|
|
"empty coins",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{},
|
2020-08-14 02:09:53 -07:00
|
|
|
"",
|
2020-06-30 11:11:29 -07:00
|
|
|
},
|
|
|
|
{
|
2020-08-14 02:09:53 -07:00
|
|
|
"single coin",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{{"tree", sdk.OneInt()}},
|
2020-08-14 02:09:53 -07:00
|
|
|
"1tree",
|
2020-06-30 11:11:29 -07:00
|
|
|
},
|
|
|
|
{
|
2020-08-14 02:09:53 -07:00
|
|
|
"multiple coins",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"tree", sdk.OneInt()},
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-06-30 11:11:29 -07:00
|
|
|
},
|
2020-08-14 02:09:53 -07:00
|
|
|
"1tree,1gas,1mineral",
|
2020-06-30 11:11:29 -07:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range cases {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tt.expected, tt.input.String())
|
2020-06-30 11:11:29 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestIsZeroCoins() {
|
2018-08-06 12:00:49 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coins
|
2018-08-06 12:00:49 -07:00
|
|
|
expected bool
|
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.Coins{}, true},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, true},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 0)}, true},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 1)}, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, false},
|
2018-08-06 12:00:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tc := range cases {
|
|
|
|
res := tc.inputOne.IsZero()
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res)
|
2018-08-06 12:00:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestEqualCoins() {
|
2018-08-06 12:00:49 -07:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coins
|
|
|
|
inputTwo sdk.Coins
|
2018-08-06 12:00:49 -07:00
|
|
|
expected bool
|
2019-02-15 07:33:23 -08:00
|
|
|
panics bool
|
2018-08-06 12:00:49 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{sdk.Coins{}, sdk.Coins{}, true, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, true, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, true, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom2, 0)}, false, true},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 1)}, false, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, false, false},
|
|
|
|
{sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, true, false},
|
2018-08-06 12:00:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for tcnum, tc := range cases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2019-02-15 07:33:23 -08:00
|
|
|
if tc.panics {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { tc.inputOne.IsEqual(tc.inputTwo) })
|
2019-02-15 07:33:23 -08:00
|
|
|
} else {
|
|
|
|
res := tc.inputOne.IsEqual(tc.inputTwo)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(tc.expected, res, "Equality is differed from exported. tc #%d, expected %b, actual %b.", tcnum, tc.expected, res)
|
2019-02-15 07:33:23 -08:00
|
|
|
}
|
2018-08-06 12:00:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestAddCoins() {
|
2018-11-20 01:22:35 -08:00
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coins
|
|
|
|
inputTwo sdk.Coins
|
|
|
|
expected sdk.Coins
|
2018-11-20 01:22:35 -08:00
|
|
|
}{
|
2021-05-05 08:55:28 -07:00
|
|
|
{sdk.Coins{s.ca1, s.cm1}, sdk.Coins{s.ca1, s.cm1}, sdk.Coins{s.ca2, s.cm2}},
|
|
|
|
{sdk.Coins{s.ca0, s.cm1}, sdk.Coins{s.ca0, s.cm0}, sdk.Coins{s.cm1}},
|
|
|
|
{sdk.Coins{s.ca2}, sdk.Coins{s.cm0}, sdk.Coins{s.ca2}},
|
|
|
|
{sdk.Coins{s.ca1}, sdk.Coins{s.ca1, s.cm2}, sdk.Coins{s.ca2, s.cm2}},
|
|
|
|
{sdk.Coins{s.ca0, s.cm0}, sdk.Coins{s.ca0, s.cm0}, sdk.Coins(nil)},
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
for tcIndex, tc := range cases {
|
2020-01-03 12:44:53 -08:00
|
|
|
res := tc.inputOne.Add(tc.inputTwo...)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().True(res.IsValid())
|
|
|
|
s.Require().Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex)
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestSubCoins() {
|
2018-11-20 01:22:35 -08:00
|
|
|
testCases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
inputOne sdk.Coins
|
|
|
|
inputTwo sdk.Coins
|
|
|
|
expected sdk.Coins
|
2018-11-20 01:22:35 -08:00
|
|
|
shouldPanic bool
|
|
|
|
}{
|
2021-05-05 08:55:28 -07:00
|
|
|
// denoms are not sorted - should panic
|
|
|
|
{sdk.Coins{s.ca2}, sdk.Coins{s.cm2, s.ca1}, sdk.Coins{}, true},
|
|
|
|
{sdk.Coins{s.cm2, s.ca2}, sdk.Coins{s.ca1}, sdk.Coins{}, true},
|
|
|
|
// test cases for sorted denoms
|
|
|
|
{sdk.Coins{s.ca2}, sdk.Coins{s.ca1, s.cm2}, sdk.Coins{s.ca1, s.cm2}, true},
|
|
|
|
{sdk.Coins{s.ca2}, sdk.Coins{s.cm0}, sdk.Coins{s.ca2}, false},
|
|
|
|
{sdk.Coins{s.ca1}, sdk.Coins{s.cm0}, sdk.Coins{s.ca1}, false},
|
|
|
|
{sdk.Coins{s.ca1, s.cm1}, sdk.Coins{s.ca1}, sdk.Coins{s.cm1}, false},
|
|
|
|
{sdk.Coins{s.ca1, s.cm1}, sdk.Coins{s.ca2}, sdk.Coins{}, true},
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
|
|
|
|
2021-05-05 08:55:28 -07:00
|
|
|
assert := s.Assert()
|
2018-11-20 01:22:35 -08:00
|
|
|
for i, tc := range testCases {
|
2019-10-17 06:47:35 -07:00
|
|
|
tc := tc
|
2018-11-20 01:22:35 -08:00
|
|
|
if tc.shouldPanic {
|
2021-05-05 08:55:28 -07:00
|
|
|
assert.Panics(func() { tc.inputOne.Sub(tc.inputTwo) })
|
2018-11-20 01:22:35 -08:00
|
|
|
} else {
|
2019-02-21 09:35:55 -08:00
|
|
|
res := tc.inputOne.Sub(tc.inputTwo)
|
2021-05-05 08:55:28 -07:00
|
|
|
assert.True(res.IsValid())
|
|
|
|
assert.Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", i)
|
2018-11-20 01:22:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-02-22 14:30:50 -08:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoins_Validate() {
|
2020-08-14 02:09:53 -07:00
|
|
|
testCases := []struct {
|
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
coins sdk.Coins
|
2020-08-14 02:09:53 -07:00
|
|
|
expPass bool
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
"valid lowercase coins",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
|
|
|
{"tree", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"valid uppercase coins",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"GAS", sdk.OneInt()},
|
|
|
|
{"MINERAL", sdk.OneInt()},
|
|
|
|
{"TREE", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"valid uppercase coin",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"ATOM", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"valid lower and uppercase coins (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"GAS", sdk.OneInt()},
|
|
|
|
{"gAs", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"valid lower and uppercase coins (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"ATOM", sdk.OneInt()},
|
|
|
|
{"Atom", sdk.OneInt()},
|
|
|
|
{"atom", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"mixed case (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"MineraL", sdk.OneInt()},
|
|
|
|
{"TREE", sdk.OneInt()},
|
|
|
|
{"gAs", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"mixed case (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gAs", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"mixed case (3)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gAs", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"unicode letters and numbers",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"𐀀𐀆𐀉Ⅲ", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"emojis",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"🤑😋🤔", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"IBC denominations (ADR 001)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.OneInt()},
|
|
|
|
{"ibc/876563AAAACF739EB061C67CDB5EDF2B7C9FD4AA9D876450CC21210807C2820A", sdk.NewInt(2)},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"empty (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.NewCoins(),
|
2020-08-14 02:09:53 -07:00
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"empty (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{},
|
2020-08-14 02:09:53 -07:00
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"invalid denomination (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"MineraL", sdk.OneInt()},
|
|
|
|
{"0TREE", sdk.OneInt()},
|
|
|
|
{"gAs", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"invalid denomination (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"-GAS", sdk.OneInt()},
|
|
|
|
{"gAs", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"bad sort (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"tree", sdk.OneInt()},
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"bad sort (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"tree", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"non-positive amount (1)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"tree", sdk.NewInt(0)},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"non-positive amount (2)",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gas", sdk.NewInt(-1)},
|
|
|
|
{"tree", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
}, {
|
|
|
|
"duplicate denomination",
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.Coins{
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"gas", sdk.OneInt()},
|
|
|
|
{"mineral", sdk.OneInt()},
|
2020-08-14 02:09:53 -07:00
|
|
|
},
|
|
|
|
false,
|
|
|
|
},
|
2016-04-01 15:19:07 -07:00
|
|
|
}
|
2018-11-20 01:22:35 -08:00
|
|
|
|
2020-08-14 02:09:53 -07:00
|
|
|
for _, tc := range testCases {
|
|
|
|
err := tc.coins.Validate()
|
|
|
|
if tc.expPass {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
} else {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Error(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
}
|
2016-04-01 15:19:07 -07:00
|
|
|
}
|
|
|
|
}
|
2017-03-28 13:32:55 -07:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsGT() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
2018-11-07 00:14:48 -08:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom2, two}}))
|
2018-11-07 00:14:48 -08:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsLT() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
|
|
|
|
s.Require().False(sdk.Coins{}.IsAllLT(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom1, one}, {testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom1, two}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{}.IsAllLT(sdk.Coins{{testDenom1, one}}))
|
2018-11-07 00:14:48 -08:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsLTE() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
|
|
|
|
s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{{testDenom1, one}}))
|
2018-11-07 00:14:48 -08:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestParseCoins() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
2017-05-22 02:22:41 -07:00
|
|
|
|
|
|
|
cases := []struct {
|
|
|
|
input string
|
2020-09-27 14:51:14 -07:00
|
|
|
valid bool // if false, we expect an error on parse
|
|
|
|
expected sdk.Coins // if valid is true, make sure this is returned
|
2017-05-22 02:22:41 -07:00
|
|
|
}{
|
|
|
|
{"", true, nil},
|
2020-09-27 14:51:14 -07:00
|
|
|
{"0stake", true, sdk.Coins{}}, // remove zero coins
|
|
|
|
{"0stake,1foo,99bar", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}}, // remove zero coins
|
|
|
|
{"1foo", true, sdk.Coins{{"foo", one}}},
|
2020-09-25 01:31:31 -07:00
|
|
|
{"10btc,1atom,20btc", false, nil},
|
2020-09-27 14:51:14 -07:00
|
|
|
{"10bar", true, sdk.Coins{{"bar", sdk.NewInt(10)}}},
|
|
|
|
{"99bar,1foo", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}},
|
|
|
|
{"98 bar , 1 foo ", true, sdk.Coins{{"bar", sdk.NewInt(98)}, {"foo", one}}},
|
|
|
|
{" 55\t \t bling\n", true, sdk.Coins{{"bling", sdk.NewInt(55)}}},
|
|
|
|
{"2foo, 97 bar", true, sdk.Coins{{"bar", sdk.NewInt(97)}, {"foo", sdk.NewInt(2)}}},
|
2020-11-16 03:34:54 -08:00
|
|
|
{"5 mycoin,", false, nil}, // no empty coins in a list
|
|
|
|
{"2 3foo, 97 bar", false, nil}, // 3foo is invalid coin name
|
|
|
|
{"11me coin, 12you coin", false, nil}, // no spaces in coin names
|
|
|
|
{"1.2btc", true, sdk.Coins{{"btc", sdk.NewInt(1)}}}, // amount can be decimal, will get truncated
|
2021-09-27 13:01:20 -07:00
|
|
|
{"5foo:bar", true, sdk.Coins{{"foo:bar", sdk.NewInt(5)}}},
|
2020-09-27 14:51:14 -07:00
|
|
|
{"10atom10", true, sdk.Coins{{"atom10", sdk.NewInt(10)}}},
|
|
|
|
{"200transfer/channelToA/uatom", true, sdk.Coins{{"transfer/channelToA/uatom", sdk.NewInt(200)}}},
|
|
|
|
{"50ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", true, sdk.Coins{{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.NewInt(50)}}},
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2017-03-28 13:32:55 -07:00
|
|
|
|
2018-07-16 11:42:28 -07:00
|
|
|
for tcIndex, tc := range cases {
|
2020-11-16 03:34:54 -08:00
|
|
|
res, err := sdk.ParseCoinsNormalized(tc.input)
|
2017-05-22 02:22:41 -07:00
|
|
|
if !tc.valid {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Error(err, "%s: %#v. tc #%d", tc.input, res, tcIndex)
|
|
|
|
} else if s.Assert().Nil(err, "%s: %+v", tc.input, err) {
|
|
|
|
s.Require().Equal(tc.expected, res, "coin parsing was incorrect, tc #%d", tcIndex)
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2017-03-28 13:32:55 -07:00
|
|
|
}
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestSortCoins() {
|
2020-09-27 14:51:14 -07:00
|
|
|
good := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
|
|
|
sdk.NewInt64Coin("tree", 1),
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
empty := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gold", 0),
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
badSort1 := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("tree", 1),
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
badSort2 := sdk.Coins{ // both are after the first one, but the second and third are in the wrong order
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("tree", 1),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
badAmt := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("tree", 0),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
dup := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
2017-03-28 13:32:55 -07:00
|
|
|
}
|
|
|
|
|
2017-05-22 02:22:41 -07:00
|
|
|
cases := []struct {
|
2020-08-14 02:09:53 -07:00
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
coins sdk.Coins
|
2020-08-14 02:09:53 -07:00
|
|
|
validBefore,
|
|
|
|
validAfter bool
|
2017-05-22 02:22:41 -07:00
|
|
|
}{
|
2020-08-14 02:09:53 -07:00
|
|
|
{"valid coins", good, true, true},
|
|
|
|
{"empty coins", empty, false, false},
|
|
|
|
{"bad sort (1)", badSort1, false, true},
|
|
|
|
{"bad sort (2)", badSort2, false, true},
|
|
|
|
{"zero value coin", badAmt, false, false},
|
|
|
|
{"duplicate coins", dup, false, false},
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2017-03-28 13:32:55 -07:00
|
|
|
|
2020-08-14 02:09:53 -07:00
|
|
|
for _, tc := range cases {
|
|
|
|
err := tc.coins.Validate()
|
|
|
|
if tc.validBefore {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
} else {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Error(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
}
|
|
|
|
|
2017-05-22 02:22:41 -07:00
|
|
|
tc.coins.Sort()
|
2020-08-14 02:09:53 -07:00
|
|
|
|
|
|
|
err = tc.coins.Validate()
|
|
|
|
if tc.validAfter {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
} else {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Error(err, tc.name)
|
2020-08-14 02:09:53 -07:00
|
|
|
}
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestAmountOf() {
|
2020-09-27 14:51:14 -07:00
|
|
|
case0 := sdk.Coins{}
|
|
|
|
case1 := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gold", 0),
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
case2 := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gas", 1),
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
|
|
|
sdk.NewInt64Coin("tree", 1),
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
case3 := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("mineral", 1),
|
|
|
|
sdk.NewInt64Coin("tree", 1),
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
2020-09-27 14:51:14 -07:00
|
|
|
case4 := sdk.Coins{
|
|
|
|
sdk.NewInt64Coin("gas", 8),
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
cases := []struct {
|
2020-09-27 14:51:14 -07:00
|
|
|
coins sdk.Coins
|
2018-01-25 16:30:49 -08:00
|
|
|
amountOf int64
|
2018-02-04 16:59:11 -08:00
|
|
|
amountOfSpace int64
|
2018-01-25 16:30:49 -08:00
|
|
|
amountOfGAS int64
|
|
|
|
amountOfMINERAL int64
|
|
|
|
amountOfTREE int64
|
|
|
|
}{
|
|
|
|
{case0, 0, 0, 0, 0, 0},
|
|
|
|
{case1, 0, 0, 0, 0, 0},
|
2019-02-15 07:33:23 -08:00
|
|
|
{case2, 0, 0, 1, 1, 1},
|
|
|
|
{case3, 0, 0, 0, 1, 1},
|
|
|
|
{case4, 0, 0, 8, 0, 0},
|
2018-01-25 16:30:49 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tc := range cases {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Equal(sdk.NewInt(tc.amountOfGAS), tc.coins.AmountOf("gas"))
|
|
|
|
s.Require().Equal(sdk.NewInt(tc.amountOfMINERAL), tc.coins.AmountOf("mineral"))
|
|
|
|
s.Require().Equal(sdk.NewInt(tc.amountOfTREE), tc.coins.AmountOf("tree"))
|
2017-05-22 02:22:41 -07:00
|
|
|
}
|
2018-12-18 11:14:11 -08:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().Panics(func() { cases[0].coins.AmountOf("10Invalid") })
|
2017-03-28 13:32:55 -07:00
|
|
|
}
|
2019-02-07 18:14:54 -08:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsIsAnyGTE() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
|
|
|
|
s.Require().False(sdk.Coins{}.IsAnyGTE(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{}.IsAnyGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, two}, {testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom2, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
|
2019-02-07 18:14:54 -08:00
|
|
|
}
|
2019-03-07 00:02:40 -08:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsIsAllGT() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
|
|
|
|
s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{}))
|
|
|
|
s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, two}, {testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, two}}.IsAllGT(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
|
2019-03-07 00:02:40 -08:00
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsIsAllGTE() {
|
2020-09-27 14:51:14 -07:00
|
|
|
one := sdk.OneInt()
|
|
|
|
two := sdk.NewInt(2)
|
|
|
|
|
|
|
|
s.Require().True(sdk.Coins{}.IsAllGTE(sdk.Coins{}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{}.IsAllGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, two}, {testDenom2, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}}))
|
|
|
|
s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}}))
|
|
|
|
s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
|
2019-03-07 00:02:40 -08:00
|
|
|
}
|
2019-03-07 16:58:24 -08:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestNewCoins() {
|
2020-09-27 14:51:14 -07:00
|
|
|
tenatom := sdk.NewInt64Coin("atom", 10)
|
|
|
|
tenbtc := sdk.NewInt64Coin("btc", 10)
|
|
|
|
zeroeth := sdk.NewInt64Coin("eth", 0)
|
|
|
|
invalidCoin := sdk.Coin{"0ETH", sdk.OneInt()}
|
2019-03-07 16:55:08 -08:00
|
|
|
tests := []struct {
|
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
coins sdk.Coins
|
|
|
|
want sdk.Coins
|
2019-03-07 16:55:08 -08:00
|
|
|
wantPanic bool
|
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{"empty args", []sdk.Coin{}, sdk.Coins{}, false},
|
|
|
|
{"one coin", []sdk.Coin{tenatom}, sdk.Coins{tenatom}, false},
|
|
|
|
{"sort after create", []sdk.Coin{tenbtc, tenatom}, sdk.Coins{tenatom, tenbtc}, false},
|
|
|
|
{"sort and remove zeroes", []sdk.Coin{zeroeth, tenbtc, tenatom}, sdk.Coins{tenatom, tenbtc}, false},
|
|
|
|
{"panic on dups", []sdk.Coin{tenatom, tenatom}, sdk.Coins{}, true},
|
|
|
|
{"panic on invalid coin", []sdk.Coin{invalidCoin, tenatom}, sdk.Coins{}, true},
|
2019-03-07 16:55:08 -08:00
|
|
|
}
|
|
|
|
for _, tt := range tests {
|
2020-09-27 14:51:14 -07:00
|
|
|
if tt.wantPanic {
|
|
|
|
s.Require().Panics(func() { sdk.NewCoins(tt.coins...) })
|
2020-09-29 04:29:10 -07:00
|
|
|
continue
|
2020-09-27 14:51:14 -07:00
|
|
|
}
|
|
|
|
got := sdk.NewCoins(tt.coins...)
|
|
|
|
s.Require().True(got.IsEqual(tt.want))
|
2019-03-07 16:55:08 -08:00
|
|
|
}
|
|
|
|
}
|
2019-05-07 10:10:35 -07:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsIsAnyGT() {
|
2020-09-27 14:51:14 -07:00
|
|
|
twoAtom := sdk.NewInt64Coin("atom", 2)
|
|
|
|
fiveAtom := sdk.NewInt64Coin("atom", 5)
|
|
|
|
threeEth := sdk.NewInt64Coin("eth", 3)
|
|
|
|
sixEth := sdk.NewInt64Coin("eth", 6)
|
|
|
|
twoBtc := sdk.NewInt64Coin("btc", 2)
|
2019-05-07 10:10:35 -07:00
|
|
|
|
2019-05-08 06:51:30 -07:00
|
|
|
tests := []struct {
|
2020-08-14 02:09:53 -07:00
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
coinsA sdk.Coins
|
|
|
|
coinsB sdk.Coins
|
2020-08-14 02:09:53 -07:00
|
|
|
expPass bool
|
2019-05-08 06:51:30 -07:00
|
|
|
}{
|
2020-09-27 14:51:14 -07:00
|
|
|
{"{} ≤ {}", sdk.Coins{}, sdk.Coins{}, false},
|
|
|
|
{"{} ≤ 5atom", sdk.Coins{}, sdk.Coins{fiveAtom}, false},
|
|
|
|
{"5atom > 2atom", sdk.Coins{fiveAtom}, sdk.Coins{twoAtom}, true},
|
|
|
|
{"2atom ≤ 5atom", sdk.Coins{twoAtom}, sdk.Coins{fiveAtom}, false},
|
|
|
|
{"2atom,6eth > 2btc,5atom,3eth", sdk.Coins{twoAtom, sixEth}, sdk.Coins{twoBtc, fiveAtom, threeEth}, true},
|
|
|
|
{"2btc,2atom,3eth ≤ 5atom,6eth", sdk.Coins{twoBtc, twoAtom, threeEth}, sdk.Coins{fiveAtom, sixEth}, false},
|
|
|
|
{"2atom,6eth ≤ 2btc,5atom", sdk.Coins{twoAtom, sixEth}, sdk.Coins{twoBtc, fiveAtom}, false},
|
2019-05-08 06:51:30 -07:00
|
|
|
}
|
2020-08-14 02:09:53 -07:00
|
|
|
|
|
|
|
for _, tc := range tests {
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().True(tc.expPass == tc.coinsA.IsAnyGT(tc.coinsB), tc.name)
|
2019-05-08 06:51:30 -07:00
|
|
|
}
|
|
|
|
}
|
2019-05-31 08:16:08 -07:00
|
|
|
|
2021-10-12 02:11:14 -07:00
|
|
|
func (s *coinTestSuite) TestCoinsIsAnyNil() {
|
|
|
|
twoAtom := sdk.NewInt64Coin("atom", 2)
|
|
|
|
fiveAtom := sdk.NewInt64Coin("atom", 5)
|
|
|
|
threeEth := sdk.NewInt64Coin("eth", 3)
|
|
|
|
nilAtom := sdk.Coin{Denom: "atom"}
|
|
|
|
|
|
|
|
s.Require().True(sdk.Coins{twoAtom, fiveAtom, threeEth, nilAtom}.IsAnyNil())
|
|
|
|
s.Require().True(sdk.Coins{twoAtom, nilAtom, fiveAtom, threeEth}.IsAnyNil())
|
|
|
|
s.Require().True(sdk.Coins{nilAtom, twoAtom, fiveAtom, threeEth}.IsAnyNil())
|
|
|
|
s.Require().False(sdk.Coins{twoAtom, fiveAtom, threeEth}.IsAnyNil())
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestMarshalJSONCoins() {
|
2020-09-07 07:47:12 -07:00
|
|
|
cdc := codec.NewLegacyAmino()
|
2020-09-27 14:51:14 -07:00
|
|
|
sdk.RegisterLegacyAminoCodec(cdc)
|
2019-05-31 08:16:08 -07:00
|
|
|
|
|
|
|
testCases := []struct {
|
|
|
|
name string
|
2020-09-27 14:51:14 -07:00
|
|
|
input sdk.Coins
|
2019-05-31 08:16:08 -07:00
|
|
|
strOutput string
|
|
|
|
}{
|
|
|
|
{"nil coins", nil, `[]`},
|
2020-09-27 14:51:14 -07:00
|
|
|
{"empty coins", sdk.Coins{}, `[]`},
|
|
|
|
{"non-empty coins", sdk.NewCoins(sdk.NewInt64Coin("foo", 50)), `[{"denom":"foo","amount":"50"}]`},
|
2019-05-31 08:16:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tc := range testCases {
|
2020-09-27 14:51:14 -07:00
|
|
|
bz, err := cdc.MarshalJSON(tc.input)
|
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(tc.strOutput, string(bz))
|
2019-05-31 08:16:08 -07:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
var newCoins sdk.Coins
|
|
|
|
s.Require().NoError(cdc.UnmarshalJSON(bz, &newCoins))
|
2019-05-31 08:16:08 -07:00
|
|
|
|
2020-09-27 14:51:14 -07:00
|
|
|
if tc.input.Empty() {
|
|
|
|
s.Require().Nil(newCoins)
|
|
|
|
} else {
|
|
|
|
s.Require().Equal(tc.input, newCoins)
|
|
|
|
}
|
2019-05-31 08:16:08 -07:00
|
|
|
}
|
|
|
|
}
|
2020-01-24 07:32:00 -08:00
|
|
|
|
2020-09-28 03:46:49 -07:00
|
|
|
func (s *coinTestSuite) TestCoinAminoEncoding() {
|
2020-09-27 14:51:14 -07:00
|
|
|
cdc := codec.NewLegacyAmino()
|
|
|
|
c := sdk.NewInt64Coin(testDenom1, 5)
|
2020-01-24 07:32:00 -08:00
|
|
|
|
2021-04-29 03:46:22 -07:00
|
|
|
bz1, err := cdc.Marshal(c)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err)
|
2020-01-24 07:32:00 -08:00
|
|
|
|
2021-04-29 03:46:22 -07:00
|
|
|
bz2, err := cdc.MarshalLengthPrefixed(c)
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err)
|
2020-01-24 07:32:00 -08:00
|
|
|
|
|
|
|
bz3, err := c.Marshal()
|
2020-09-27 14:51:14 -07:00
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(bz1, bz3)
|
|
|
|
s.Require().Equal(bz2[1:], bz3)
|
2020-01-24 07:32:00 -08:00
|
|
|
}
|