LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Switch asserts to require (#1483)

Browse Source 
* meta: Switch the majority of asserts to require

Switch most assert statements to require, to ease debugging.
Closes #1418

* Fix imports
This commit is contained in:
Dev Ojha
2018-06-30 03:10:15 +02:00
committed by Christopher Goes
parent fc3dd56281
commit 955a0c9af7
65 changed files with 1156 additions and 1196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/coin_test.go
+16 -31
View File
@@ -4,11 +4,10 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestIsPositiveCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
expected bool
@@ -20,13 +19,11 @@ func TestIsPositiveCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.IsPositive()
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
func TestIsNotNegativeCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
expected bool
@@ -38,13 +35,11 @@ func TestIsNotNegativeCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.IsNotNegative()
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
func TestSameDenomAsCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
inputTwo Coin
@@ -59,13 +54,11 @@ func TestSameDenomAsCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.SameDenomAs(tc.inputTwo)
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
func TestIsGTECoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
inputTwo Coin
@@ -79,13 +72,11 @@ func TestIsGTECoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.IsGTE(tc.inputTwo)
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
func TestIsEqualCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
inputTwo Coin
@@ -100,13 +91,11 @@ func TestIsEqualCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.IsEqual(tc.inputTwo)
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
func TestPlusCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
inputTwo Coin
@@ -119,7 +108,7 @@ func TestPlusCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.Plus(tc.inputTwo)
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
tc := struct {
@@ -128,12 +117,10 @@ func TestPlusCoin(t *testing.T) {
expected int64
}{NewCoin("asdf", -1), NewCoin("asdf", 1), 0}
res := tc.inputOne.Plus(tc.inputTwo)
assert.Equal(tc.expected, res.Amount.Int64())
require.Equal(t, tc.expected, res.Amount.Int64())
}
func TestMinusCoin(t *testing.T) {
assert := assert.New(t)
cases := []struct {
inputOne Coin
inputTwo Coin
@@ -147,7 +134,7 @@ func TestMinusCoin(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.Minus(tc.inputTwo)
assert.Equal(tc.expected, res)
require.Equal(t, tc.expected, res)
}
tc := struct {
@@ -156,7 +143,7 @@ func TestMinusCoin(t *testing.T) {
expected int64
}{NewCoin("A", 1), NewCoin("A", 1), 0}
res := tc.inputOne.Minus(tc.inputTwo)
assert.Equal(tc.expected, res.Amount.Int64())
require.Equal(t, tc.expected, res.Amount.Int64())
}
@@ -208,8 +195,6 @@ func TestCoins(t *testing.T) {
}
func TestPlusCoins(t *testing.T) {
assert := assert.New(t)
one := NewInt(1)
zero := NewInt(0)
negone := NewInt(-1)
@@ -229,8 +214,8 @@ func TestPlusCoins(t *testing.T) {
for _, tc := range cases {
res := tc.inputOne.Plus(tc.inputTwo)
assert.True(res.IsValid())
assert.Equal(tc.expected, res)
assert.True(t, res.IsValid())
require.Equal(t, tc.expected, res)
}
}
@@ -260,9 +245,9 @@ func TestParse(t *testing.T) {
for _, tc := range cases {
res, err := ParseCoins(tc.input)
if !tc.valid {
assert.NotNil(t, err, "%s: %#v", tc.input, res)
require.NotNil(t, err, "%s: %#v", tc.input, res)
} else if assert.Nil(t, err, "%s: %+v", tc.input, err) {
assert.Equal(t, tc.expected, res)
require.Equal(t, tc.expected, res)
}
}
@@ -312,9 +297,9 @@ func TestSortCoins(t *testing.T) {
}
for _, tc := range cases {
assert.Equal(t, tc.before, tc.coins.IsValid())
require.Equal(t, tc.before, tc.coins.IsValid())
tc.coins.Sort()
assert.Equal(t, tc.after, tc.coins.IsValid())
require.Equal(t, tc.after, tc.coins.IsValid())
}
}
types/context_test.go
+7 -8
View File
@@ -3,7 +3,6 @@ package types_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
dbm "github.com/tendermint/tmlibs/db"
@@ -72,21 +71,21 @@ func TestCacheContext(t *testing.T) {
ctx := defaultContext(key)
store := ctx.KVStore(key)
store.Set(k1, v1)
assert.Equal(t, v1, store.Get(k1))
assert.Nil(t, store.Get(k2))
require.Equal(t, v1, store.Get(k1))
require.Nil(t, store.Get(k2))
cctx, write := ctx.CacheContext()
cstore := cctx.KVStore(key)
assert.Equal(t, v1, cstore.Get(k1))
assert.Nil(t, cstore.Get(k2))
require.Equal(t, v1, cstore.Get(k1))
require.Nil(t, cstore.Get(k2))
cstore.Set(k2, v2)
assert.Equal(t, v2, cstore.Get(k2))
assert.Nil(t, store.Get(k2))
require.Equal(t, v2, cstore.Get(k2))
require.Nil(t, store.Get(k2))
write()
assert.Equal(t, v2, store.Get(k2))
require.Equal(t, v2, store.Get(k2))
}
func TestLogContext(t *testing.T) {
types/errors_test.go
+5 -5
View File
@@ -4,7 +4,7 @@ import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var codeTypes = []CodeType{
@@ -32,11 +32,11 @@ var errFns = []errFn{
}
func TestCodeType(t *testing.T) {
assert.True(t, ABCICodeOK.IsOK())
require.True(t, ABCICodeOK.IsOK())
for _, c := range codeTypes {
msg := CodeToDefaultMsg(c)
assert.False(t, strings.HasPrefix(msg, "Unknown code"))
require.False(t, strings.HasPrefix(msg, "Unknown code"))
}
}
@@ -44,7 +44,7 @@ func TestErrFn(t *testing.T) {
for i, errFn := range errFns {
err := errFn("")
codeType := codeTypes[i]
assert.Equal(t, err.Code(), codeType)
assert.Equal(t, err.Result().Code, ToABCICode(CodespaceRoot, codeType))
require.Equal(t, err.Code(), codeType)
require.Equal(t, err.Result().Code, ToABCICode(CodespaceRoot, codeType))
}
}
types/int_test.go
+52 -52
View File
@@ -5,107 +5,107 @@ import (
"math/rand"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestFromInt64(t *testing.T) {
for n := 0; n < 20; n++ {
r := rand.Int63()
assert.Equal(t, r, NewInt(r).Int64())
require.Equal(t, r, NewInt(r).Int64())
}
}
func TestInt(t *testing.T) {
// Max Int = 2^255-1 = 5.789e+76
// Min Int = -(2^255-1) = -5.789e+76
assert.NotPanics(t, func() { NewIntWithDecimal(1, 76) })
require.NotPanics(t, func() { NewIntWithDecimal(1, 76) })
i1 := NewIntWithDecimal(1, 76)
assert.NotPanics(t, func() { NewIntWithDecimal(2, 76) })
require.NotPanics(t, func() { NewIntWithDecimal(2, 76) })
i2 := NewIntWithDecimal(2, 76)
assert.NotPanics(t, func() { NewIntWithDecimal(3, 76) })
require.NotPanics(t, func() { NewIntWithDecimal(3, 76) })
i3 := NewIntWithDecimal(3, 76)
assert.Panics(t, func() { NewIntWithDecimal(6, 76) })
assert.Panics(t, func() { NewIntWithDecimal(9, 80) })
require.Panics(t, func() { NewIntWithDecimal(6, 76) })
require.Panics(t, func() { NewIntWithDecimal(9, 80) })
// Overflow check
assert.NotPanics(t, func() { i1.Add(i1) })
assert.NotPanics(t, func() { i2.Add(i2) })
assert.Panics(t, func() { i3.Add(i3) })
require.NotPanics(t, func() { i1.Add(i1) })
require.NotPanics(t, func() { i2.Add(i2) })
require.Panics(t, func() { i3.Add(i3) })
assert.NotPanics(t, func() { i1.Sub(i1.Neg()) })
assert.NotPanics(t, func() { i2.Sub(i2.Neg()) })
assert.Panics(t, func() { i3.Sub(i3.Neg()) })
require.NotPanics(t, func() { i1.Sub(i1.Neg()) })
require.NotPanics(t, func() { i2.Sub(i2.Neg()) })
require.Panics(t, func() { i3.Sub(i3.Neg()) })
assert.Panics(t, func() { i1.Mul(i1) })
assert.Panics(t, func() { i2.Mul(i2) })
assert.Panics(t, func() { i3.Mul(i3) })
require.Panics(t, func() { i1.Mul(i1) })
require.Panics(t, func() { i2.Mul(i2) })
require.Panics(t, func() { i3.Mul(i3) })
assert.Panics(t, func() { i1.Neg().Mul(i1.Neg()) })
assert.Panics(t, func() { i2.Neg().Mul(i2.Neg()) })
assert.Panics(t, func() { i3.Neg().Mul(i3.Neg()) })
require.Panics(t, func() { i1.Neg().Mul(i1.Neg()) })
require.Panics(t, func() { i2.Neg().Mul(i2.Neg()) })
require.Panics(t, func() { i3.Neg().Mul(i3.Neg()) })
// Underflow check
i3n := i3.Neg()
assert.NotPanics(t, func() { i3n.Sub(i1) })
assert.NotPanics(t, func() { i3n.Sub(i2) })
assert.Panics(t, func() { i3n.Sub(i3) })
require.NotPanics(t, func() { i3n.Sub(i1) })
require.NotPanics(t, func() { i3n.Sub(i2) })
require.Panics(t, func() { i3n.Sub(i3) })
assert.NotPanics(t, func() { i3n.Add(i1.Neg()) })
assert.NotPanics(t, func() { i3n.Add(i2.Neg()) })
assert.Panics(t, func() { i3n.Add(i3.Neg()) })
require.NotPanics(t, func() { i3n.Add(i1.Neg()) })
require.NotPanics(t, func() { i3n.Add(i2.Neg()) })
require.Panics(t, func() { i3n.Add(i3.Neg()) })
assert.Panics(t, func() { i1.Mul(i1.Neg()) })
assert.Panics(t, func() { i2.Mul(i2.Neg()) })
assert.Panics(t, func() { i3.Mul(i3.Neg()) })
require.Panics(t, func() { i1.Mul(i1.Neg()) })
require.Panics(t, func() { i2.Mul(i2.Neg()) })
require.Panics(t, func() { i3.Mul(i3.Neg()) })
// Bound check
intmax := NewIntFromBigInt(new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(255), nil), big.NewInt(1)))
intmin := intmax.Neg()
assert.NotPanics(t, func() { intmax.Add(ZeroInt()) })
assert.NotPanics(t, func() { intmin.Sub(ZeroInt()) })
assert.Panics(t, func() { intmax.Add(OneInt()) })
assert.Panics(t, func() { intmin.Sub(OneInt()) })
require.NotPanics(t, func() { intmax.Add(ZeroInt()) })
require.NotPanics(t, func() { intmin.Sub(ZeroInt()) })
require.Panics(t, func() { intmax.Add(OneInt()) })
require.Panics(t, func() { intmin.Sub(OneInt()) })
// Division-by-zero check
assert.Panics(t, func() { i1.Div(NewInt(0)) })
require.Panics(t, func() { i1.Div(NewInt(0)) })
}
func TestUint(t *testing.T) {
// Max Uint = 1.15e+77
// Min Uint = 0
assert.NotPanics(t, func() { NewUintWithDecimal(5, 76) })
require.NotPanics(t, func() { NewUintWithDecimal(5, 76) })
i1 := NewUintWithDecimal(5, 76)
assert.NotPanics(t, func() { NewUintWithDecimal(10, 76) })
require.NotPanics(t, func() { NewUintWithDecimal(10, 76) })
i2 := NewUintWithDecimal(10, 76)
assert.NotPanics(t, func() { NewUintWithDecimal(11, 76) })
require.NotPanics(t, func() { NewUintWithDecimal(11, 76) })
i3 := NewUintWithDecimal(11, 76)
assert.Panics(t, func() { NewUintWithDecimal(12, 76) })
assert.Panics(t, func() { NewUintWithDecimal(1, 80) })
require.Panics(t, func() { NewUintWithDecimal(12, 76) })
require.Panics(t, func() { NewUintWithDecimal(1, 80) })
// Overflow check
assert.NotPanics(t, func() { i1.Add(i1) })
assert.Panics(t, func() { i2.Add(i2) })
assert.Panics(t, func() { i3.Add(i3) })
require.NotPanics(t, func() { i1.Add(i1) })
require.Panics(t, func() { i2.Add(i2) })
require.Panics(t, func() { i3.Add(i3) })
assert.Panics(t, func() { i1.Mul(i1) })
assert.Panics(t, func() { i2.Mul(i2) })
assert.Panics(t, func() { i3.Mul(i3) })
require.Panics(t, func() { i1.Mul(i1) })
require.Panics(t, func() { i2.Mul(i2) })
require.Panics(t, func() { i3.Mul(i3) })
// Underflow check
assert.NotPanics(t, func() { i2.Sub(i1) })
assert.NotPanics(t, func() { i2.Sub(i2) })
assert.Panics(t, func() { i2.Sub(i3) })
require.NotPanics(t, func() { i2.Sub(i1) })
require.NotPanics(t, func() { i2.Sub(i2) })
require.Panics(t, func() { i2.Sub(i3) })
// Bound check
uintmax := NewUintFromBigInt(new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil), big.NewInt(1)))
uintmin := NewUint(0)
assert.NotPanics(t, func() { uintmax.Add(ZeroUint()) })
assert.NotPanics(t, func() { uintmin.Sub(ZeroUint()) })
assert.Panics(t, func() { uintmax.Add(OneUint()) })
assert.Panics(t, func() { uintmin.Sub(OneUint()) })
require.NotPanics(t, func() { uintmax.Add(ZeroUint()) })
require.NotPanics(t, func() { uintmin.Sub(ZeroUint()) })
require.Panics(t, func() { uintmax.Add(OneUint()) })
require.Panics(t, func() { uintmin.Sub(OneUint()) })
// Division-by-zero check
assert.Panics(t, func() { i1.Div(uintmin) })
require.Panics(t, func() { i1.Div(uintmin) })
}
types/lib/linear_test.go
+21 -21
View File
@@ -4,7 +4,7 @@ import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
dbm "github.com/tendermint/tmlibs/db"
"github.com/tendermint/tmlibs/log"
@@ -41,30 +41,30 @@ func TestList(t *testing.T) {
var res S
lm.Push(val)
assert.Equal(t, uint64(1), lm.Len())
require.Equal(t, uint64(1), lm.Len())
lm.Get(uint64(0), &res)
assert.Equal(t, val, res)
require.Equal(t, val, res)
val = S{2, false}
lm.Set(uint64(0), val)
lm.Get(uint64(0), &res)
assert.Equal(t, val, res)
require.Equal(t, val, res)
val = S{100, false}
lm.Push(val)
assert.Equal(t, uint64(2), lm.Len())
require.Equal(t, uint64(2), lm.Len())
lm.Get(uint64(1), &res)
assert.Equal(t, val, res)
require.Equal(t, val, res)
lm.Delete(uint64(1))
assert.Equal(t, uint64(2), lm.Len())
require.Equal(t, uint64(2), lm.Len())
lm.Iterate(&res, func(index uint64) (brk bool) {
var temp S
lm.Get(index, &temp)
assert.Equal(t, temp, res)
require.Equal(t, temp, res)
assert.True(t, index != 1)
require.True(t, index != 1)
return
})
@@ -74,7 +74,7 @@ func TestList(t *testing.T) {
})
lm.Get(uint64(0), &res)
assert.Equal(t, S{3, true}, res)
require.Equal(t, S{3, true}, res)
}
func TestQueue(t *testing.T) {
@@ -89,13 +89,13 @@ func TestQueue(t *testing.T) {
qm.Push(val)
qm.Peek(&res)
assert.Equal(t, val, res)
require.Equal(t, val, res)
qm.Pop()
empty := qm.IsEmpty()
assert.True(t, empty)
assert.NotNil(t, qm.Peek(&res))
require.True(t, empty)
require.NotNil(t, qm.Peek(&res))
qm.Push(S{1, true})
qm.Push(S{2, true})
@@ -107,10 +107,10 @@ func TestQueue(t *testing.T) {
return
})
assert.False(t, qm.IsEmpty())
require.False(t, qm.IsEmpty())
qm.Pop()
assert.True(t, qm.IsEmpty())
require.True(t, qm.IsEmpty())
}
func TestOptions(t *testing.T) {
@@ -136,22 +136,22 @@ func TestOptions(t *testing.T) {
// Checking keys.LengthKey
err := cdc.UnmarshalBinary(store.Get(keys.LengthKey), &len)
assert.Nil(t, err)
assert.Equal(t, len, linear.Len())
require.Nil(t, err)
require.Equal(t, len, linear.Len())
// Checking keys.ElemKey
for i := 0; i < 10; i++ {
linear.Get(uint64(i), &expected)
bz := store.Get(append(keys.ElemKey, []byte(fmt.Sprintf("%020d", i))...))
err = cdc.UnmarshalBinary(bz, &actual)
assert.Nil(t, err)
assert.Equal(t, expected, actual)
require.Nil(t, err)
require.Equal(t, expected, actual)
}
linear.Pop()
err = cdc.UnmarshalBinary(store.Get(keys.TopKey), &top)
assert.Nil(t, err)
assert.Equal(t, top, linear.getTop())
require.Nil(t, err)
require.Equal(t, top, linear.getTop())
}
types/rational_test.go
+36 -37
View File
@@ -5,19 +5,18 @@ import (
"testing"
wire "github.com/cosmos/cosmos-sdk/wire"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNew(t *testing.T) {
assert.Equal(t, NewRat(1), NewRat(1, 1))
assert.Equal(t, NewRat(100), NewRat(100, 1))
assert.Equal(t, NewRat(-1), NewRat(-1, 1))
assert.Equal(t, NewRat(-100), NewRat(-100, 1))
assert.Equal(t, NewRat(0), NewRat(0, 1))
require.Equal(t, NewRat(1), NewRat(1, 1))
require.Equal(t, NewRat(100), NewRat(100, 1))
require.Equal(t, NewRat(-1), NewRat(-1, 1))
require.Equal(t, NewRat(-100), NewRat(-100, 1))
require.Equal(t, NewRat(0), NewRat(0, 1))
// do not allow for more than 2 variables
assert.Panics(t, func() { NewRat(1, 1, 1) })
require.Panics(t, func() { NewRat(1, 1, 1) })
}
func TestNewFromDecimal(t *testing.T) {
@@ -51,7 +50,7 @@ func TestNewFromDecimal(t *testing.T) {
for _, tc := range tests {
res, err := NewRatFromDecimal(tc.decimalStr, 4)
if tc.expErr {
assert.NotNil(t, err, tc.decimalStr)
require.NotNil(t, err, tc.decimalStr)
} else {
require.Nil(t, err, tc.decimalStr)
require.True(t, res.Equal(tc.exp), tc.decimalStr)
@@ -60,10 +59,10 @@ func TestNewFromDecimal(t *testing.T) {
// negative tc
res, err = NewRatFromDecimal("-"+tc.decimalStr, 4)
if tc.expErr {
assert.NotNil(t, err, tc.decimalStr)
require.NotNil(t, err, tc.decimalStr)
} else {
assert.Nil(t, err, tc.decimalStr)
assert.True(t, res.Equal(tc.exp.Mul(NewRat(-1))), tc.decimalStr)
require.Nil(t, err, tc.decimalStr)
require.True(t, res.Equal(tc.exp.Mul(NewRat(-1))), tc.decimalStr)
}
}
}
@@ -100,9 +99,9 @@ func TestEqualities(t *testing.T) {
}
for _, tc := range tests {
assert.Equal(t, tc.gt, tc.r1.GT(tc.r2))
assert.Equal(t, tc.lt, tc.r1.LT(tc.r2))
assert.Equal(t, tc.eq, tc.r1.Equal(tc.r2))
require.Equal(t, tc.gt, tc.r1.GT(tc.r2))
require.Equal(t, tc.lt, tc.r1.LT(tc.r2))
require.Equal(t, tc.eq, tc.r1.Equal(tc.r2))
}
}
@@ -136,14 +135,14 @@ func TestArithmetic(t *testing.T) {
}
for _, tc := range tests {
assert.True(t, tc.resMul.Equal(tc.r1.Mul(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
assert.True(t, tc.resAdd.Equal(tc.r1.Add(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
assert.True(t, tc.resSub.Equal(tc.r1.Sub(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
require.True(t, tc.resMul.Equal(tc.r1.Mul(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
require.True(t, tc.resAdd.Equal(tc.r1.Add(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
require.True(t, tc.resSub.Equal(tc.r1.Sub(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
if tc.r2.Num().IsZero() { // panic for divide by zero
assert.Panics(t, func() { tc.r1.Quo(tc.r2) })
require.Panics(t, func() { tc.r1.Quo(tc.r2) })
} else {
assert.True(t, tc.resDiv.Equal(tc.r1.Quo(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
require.True(t, tc.resDiv.Equal(tc.r1.Quo(tc.r2)), "r1 %v, r2 %v", tc.r1.Rat, tc.r2.Rat)
}
}
}
@@ -169,8 +168,8 @@ func TestEvaluate(t *testing.T) {
}
for _, tc := range tests {
assert.Equal(t, tc.res, tc.r1.Evaluate(), "%v", tc.r1)
assert.Equal(t, tc.res*-1, tc.r1.Mul(NewRat(-1)).Evaluate(), "%v", tc.r1.Mul(NewRat(-1)))
require.Equal(t, tc.res, tc.r1.Evaluate(), "%v", tc.r1)
require.Equal(t, tc.res*-1, tc.r1.Mul(NewRat(-1)).Evaluate(), "%v", tc.r1.Mul(NewRat(-1)))
}
}
@@ -193,9 +192,9 @@ func TestRound(t *testing.T) {
}
for _, tc := range tests {
assert.Equal(t, tc.res, tc.r.Round(tc.precFactor), "%v", tc.r)
require.Equal(t, tc.res, tc.r.Round(tc.precFactor), "%v", tc.r)
negR1, negRes := tc.r.Mul(NewRat(-1)), tc.res.Mul(NewRat(-1))
assert.Equal(t, negRes, negR1.Round(tc.precFactor), "%v", negR1)
require.Equal(t, negRes, negR1.Round(tc.precFactor), "%v", negR1)
}
}
@@ -212,7 +211,7 @@ func TestToLeftPadded(t *testing.T) {
{NewRat(1000, 3), 12, "000000000333"},
}
for _, tc := range tests {
assert.Equal(t, tc.res, tc.rat.ToLeftPadded(tc.digits))
require.Equal(t, tc.res, tc.rat.ToLeftPadded(tc.digits))
}
}
@@ -221,13 +220,13 @@ var cdc = wire.NewCodec() //var jsonCdc JSONCodec // TODO wire.Codec
func TestZeroSerializationJSON(t *testing.T) {
r := NewRat(0, 1)
err := cdc.UnmarshalJSON([]byte(`"0/1"`), &r)
assert.Nil(t, err)
require.Nil(t, err)
err = cdc.UnmarshalJSON([]byte(`"0/0"`), &r)
assert.NotNil(t, err)
require.NotNil(t, err)
err = cdc.UnmarshalJSON([]byte(`"1/0"`), &r)
assert.NotNil(t, err)
require.NotNil(t, err)
err = cdc.UnmarshalJSON([]byte(`"{}"`), &r)
assert.NotNil(t, err)
require.NotNil(t, err)
}
func TestSerializationText(t *testing.T) {
@@ -239,7 +238,7 @@ func TestSerializationText(t *testing.T) {
var r2 = Rat{new(big.Rat)}
err = r2.UnmarshalText(bz)
require.NoError(t, err)
assert.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
require.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
}
func TestSerializationGoWireJSON(t *testing.T) {
@@ -250,7 +249,7 @@ func TestSerializationGoWireJSON(t *testing.T) {
var r2 Rat
err = cdc.UnmarshalJSON(bz, &r2)
require.NoError(t, err)
assert.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
require.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
}
func TestSerializationGoWireBinary(t *testing.T) {
@@ -261,7 +260,7 @@ func TestSerializationGoWireBinary(t *testing.T) {
var r2 Rat
err = cdc.UnmarshalBinary(bz, &r2)
require.NoError(t, err)
assert.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
require.True(t, r.Equal(r2), "original: %v, unmarshalled: %v", r, r2)
}
type testEmbedStruct struct {
@@ -279,9 +278,9 @@ func TestEmbeddedStructSerializationGoWire(t *testing.T) {
err = cdc.UnmarshalJSON(bz, &obj2)
require.Nil(t, err)
assert.Equal(t, obj.Field1, obj2.Field1)
assert.Equal(t, obj.Field2, obj2.Field2)
assert.True(t, obj.Field3.Equal(obj2.Field3), "original: %v, unmarshalled: %v", obj, obj2)
require.Equal(t, obj.Field1, obj2.Field1)
require.Equal(t, obj.Field2, obj2.Field2)
require.True(t, obj.Field3.Equal(obj2.Field3), "original: %v, unmarshalled: %v", obj, obj2)
}
func TestRatsEqual(t *testing.T) {
@@ -299,8 +298,8 @@ func TestRatsEqual(t *testing.T) {
}
for _, tc := range tests {
assert.Equal(t, tc.eq, RatsEqual(tc.r1s, tc.r2s))
assert.Equal(t, tc.eq, RatsEqual(tc.r2s, tc.r1s))
require.Equal(t, tc.eq, RatsEqual(tc.r1s, tc.r2s))
require.Equal(t, tc.eq, RatsEqual(tc.r2s, tc.r1s))
}
}
@@ -310,7 +309,7 @@ func TestStringOverflow(t *testing.T) {
rat1 := NewRat(5164315003622678713, 4389711697696177267)
rat2 := NewRat(-3179849666053572961, 8459429845579852627)
rat3 := rat1.Add(rat2)
assert.Equal(t,
require.Equal(t,
"29728537197630860939575850336935951464/37134458148982045574552091851127630409",
rat3.String(),
)
types/store_test.go
+2 -4
View File
@@ -3,12 +3,10 @@ package types
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestPrefixEndBytes(t *testing.T) {
assert := assert.New(t)
var testCases = []struct {
prefix []byte
expected []byte
@@ -24,6 +22,6 @@ func TestPrefixEndBytes(t *testing.T) {
for _, test := range testCases {
end := PrefixEndBytes(test.prefix)
assert.Equal(test.expected, end)
require.Equal(t, test.expected, end)
}
}