neoneo-go/pkg/util/fixed8_test.go
Roman Khimov 823798514a util: rename Int64Value to IntegralValue, add FractionalValue
Makes it's interface more clear and allows to easily access fractional part.
2020-03-04 19:23:23 +03:00

172 lines
4.1 KiB
Go

package util
import (
"encoding/json"
"math"
"strconv"
"testing"
"github.com/go-yaml/yaml"
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestFixed8FromInt64(t *testing.T) {
values := []int64{9000, 100000000, 5, 10945, -42}
for _, val := range values {
assert.Equal(t, Fixed8(val*decimals), Fixed8FromInt64(val))
assert.Equal(t, val, Fixed8FromInt64(val).IntegralValue())
assert.Equal(t, int32(0), Fixed8FromInt64(val).FractionalValue())
}
}
func TestFixed8Add(t *testing.T) {
a := Fixed8FromInt64(1)
b := Fixed8FromInt64(2)
c := a.Add(b)
expected := int64(3)
assert.Equal(t, strconv.FormatInt(expected, 10), c.String())
}
func TestFixed8Sub(t *testing.T) {
a := Fixed8FromInt64(42)
b := Fixed8FromInt64(34)
c := a.Sub(b)
assert.Equal(t, int64(8), c.IntegralValue())
assert.Equal(t, int32(0), c.FractionalValue())
}
func TestFixed8FromFloat(t *testing.T) {
inputs := []float64{12.98, 23.87654333, 100.654322, 456789.12345665, -3.14159265}
for _, val := range inputs {
assert.Equal(t, Fixed8(val*decimals), Fixed8FromFloat(val))
assert.Equal(t, val, Fixed8FromFloat(val).FloatValue())
trunc := math.Trunc(val)
rem := (val - trunc) * decimals
assert.Equal(t, int64(trunc), Fixed8FromFloat(val).IntegralValue())
assert.Equal(t, int32(math.Round(rem)), Fixed8FromFloat(val).FractionalValue())
}
}
func TestFixed8FromString(t *testing.T) {
// Fixed8FromString works correctly with integers
ivalues := []string{"9000", "100000000", "5", "10945", "20.45", "0.00000001", "-42"}
for _, val := range ivalues {
n, err := Fixed8FromString(val)
assert.Nil(t, err)
assert.Equal(t, val, n.String())
}
// Fixed8FromString parses number with maximal precision
val := "123456789.12345678"
n, err := Fixed8FromString(val)
assert.Nil(t, err)
assert.Equal(t, Fixed8(12345678912345678), n)
// Fixed8FromString parses number with non-maximal precision
val = "901.2341"
n, err = Fixed8FromString(val)
assert.Nil(t, err)
assert.Equal(t, Fixed8(90123410000), n)
// Fixed8FromString with errors
val = "90n1"
_, err = Fixed8FromString(val)
assert.Error(t, err)
val = "90.1s"
_, err = Fixed8FromString(val)
assert.Error(t, err)
}
func TestSatoshi(t *testing.T) {
satoshif8 := Satoshi()
assert.Equal(t, "0.00000001", satoshif8.String())
}
func TestFixed8UnmarshalJSON(t *testing.T) {
var testCases = []float64{
123.45,
-123.45,
}
for _, fl := range testCases {
str := strconv.FormatFloat(fl, 'g', -1, 64)
expected, _ := Fixed8FromString(str)
// UnmarshalJSON should decode floats
var u1 Fixed8
s, _ := json.Marshal(fl)
assert.Nil(t, json.Unmarshal(s, &u1))
assert.Equal(t, expected, u1)
// UnmarshalJSON should decode strings
var u2 Fixed8
s, _ = json.Marshal(str)
assert.Nil(t, json.Unmarshal(s, &u2))
assert.Equal(t, expected, u2)
}
errorCases := []string{
`"123.u"`,
"13.j",
}
for _, tc := range errorCases {
var u Fixed8
assert.Error(t, u.UnmarshalJSON([]byte(tc)))
}
}
func TestFixed8_MarshalJSON(t *testing.T) {
u, err := Fixed8FromString("123.4")
assert.NoError(t, err)
s, err := json.Marshal(u)
assert.NoError(t, err)
assert.Equal(t, []byte(`"123.4"`), s)
}
func TestFixed8_UnmarshalYAML(t *testing.T) {
u, err := Fixed8FromString("123.4")
assert.NoError(t, err)
s, err := yaml.Marshal(u)
assert.NoError(t, err)
assert.Equal(t, []byte("\"123.4\"\n"), s) // yaml marshaler inserts LF at the end
var f Fixed8
assert.NoError(t, yaml.Unmarshal([]byte(`"123.4"`), &f))
assert.Equal(t, u, f)
}
func TestFixed8_Arith(t *testing.T) {
u1 := Fixed8FromInt64(3)
u2 := Fixed8FromInt64(8)
assert.True(t, u1.LessThan(u2))
assert.True(t, u2.GreaterThan(u1))
assert.True(t, u1.Equal(u1))
assert.NotZero(t, u1.CompareTo(u2))
assert.Zero(t, u1.CompareTo(u1))
assert.EqualValues(t, Fixed8(2), u2.Div(3))
}
func TestFixed8_Serializable(t *testing.T) {
a := Fixed8(0x0102030405060708)
w := io.NewBufBinWriter()
a.EncodeBinary(w.BinWriter)
require.NoError(t, w.Err)
var b Fixed8
r := io.NewBinReaderFromBuf(w.Bytes())
b.DecodeBinary(r)
require.Equal(t, a, b)
}