mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
527 lines
15 KiB
Go
527 lines
15 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package utils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ericlagergren/decimal"
|
|
)
|
|
|
|
func TestUnmarshalInvalidSyntax(t *testing.T) {
|
|
x := map[string]*Decimal{
|
|
"*asr": DecimalNaN,
|
|
"*abc": NewDecimal(2, 0),
|
|
"*acd": DecimalNaN,
|
|
}
|
|
var bts []byte
|
|
var err error
|
|
if bts, err = json.Marshal(x); err != nil {
|
|
|
|
t.Error(err)
|
|
}
|
|
|
|
var reply map[string]*Decimal
|
|
if err = json.Unmarshal(bts, &reply); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(reply, x) {
|
|
t.Errorf("Expected %v, received %v", x, reply)
|
|
}
|
|
}
|
|
|
|
func TestConvertDecimalToFloat(t *testing.T) {
|
|
decm := NewDecimal(9999000000000000, 13)
|
|
if conv, ok := decm.Float64(); ok {
|
|
t.Errorf("Can convert decimal: %v to float64: %v", decm, conv)
|
|
}
|
|
|
|
decm = NewDecimal(9999, 12)
|
|
if conv, ok := decm.Float64(); !ok {
|
|
t.Errorf("Cannot convert decimal: %v to float64: %v", decm, conv)
|
|
}
|
|
|
|
decm = NewDecimal(1000000000000000, 16)
|
|
if conv, ok := decm.Float64(); !ok {
|
|
t.Errorf("Cannot convert decimal: %v to float64: %v", decm, conv)
|
|
}
|
|
}
|
|
|
|
func TestDecimalSum(t *testing.T) {
|
|
dec1 := NewDecimal(495, 1)
|
|
dec2 := NewDecimal(5, 1)
|
|
x := SumBig(dec1.Big, dec2.Big)
|
|
|
|
// as decimals, 50 is different from 50.0 (decimal.Big)
|
|
exp := NewDecimal(500, 1)
|
|
if !reflect.DeepEqual(x, exp.Big) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(exp.Big), ToJSON(x))
|
|
}
|
|
|
|
// same for substract
|
|
diff := SubstractBig(dec1.Big, dec2.Big)
|
|
exp = NewDecimal(490, 1)
|
|
if !reflect.DeepEqual(diff, exp.Big) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(exp.Big), ToJSON(x))
|
|
}
|
|
|
|
// decimal
|
|
exp2 := NewDecimal(500, 1)
|
|
x2 := SumDecimal(dec1, dec2)
|
|
if !reflect.DeepEqual(x2, exp2) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(exp2), ToJSON(x2))
|
|
}
|
|
|
|
// same for substract
|
|
exp2 = NewDecimal(490, 1)
|
|
x2 = SubstractDecimal(dec1, dec2)
|
|
if !reflect.DeepEqual(x2, exp2) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(exp2), ToJSON(x2))
|
|
}
|
|
|
|
// to conclude, 50.0 is different from 50, same difference for 49.0 and 49
|
|
val1, val2 := NewDecimal(50, 0), NewDecimal(500, 1)
|
|
if reflect.DeepEqual(val1, val2) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(val1), ToJSON(val2))
|
|
}
|
|
if reflect.DeepEqual(val1.Big, val2.Big) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(val1.Big), ToJSON(val2.Big))
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalDivide(t *testing.T) {
|
|
x := decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y := decimal.WithContext(DecimalContext).SetUint64(5)
|
|
expected, _ := decimal.WithContext(DecimalContext).SetUint64(2).Float64()
|
|
received, _ := DivideBig(x, y).Float64()
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestDivideBigNil(t *testing.T) {
|
|
var x, y, expected *decimal.Big
|
|
x = nil
|
|
y = nil
|
|
expected = nil
|
|
received := DivideBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
|
|
x = decimal.WithContext(DecimalContext).SetUint64(2)
|
|
y = nil
|
|
expected = nil
|
|
received = DivideBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalMultiply(t *testing.T) {
|
|
x := decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y := decimal.WithContext(DecimalContext).SetUint64(5)
|
|
expected, _ := decimal.WithContext(DecimalContext).SetUint64(50).Float64()
|
|
received, _ := MultiplyBig(x, y).Float64()
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestMultiplyBigNil(t *testing.T) {
|
|
var x, y, expected *decimal.Big
|
|
x = nil
|
|
y = nil
|
|
expected = nil
|
|
received := MultiplyBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
|
|
x = decimal.WithContext(DecimalContext).SetUint64(2)
|
|
y = nil
|
|
expected = nil
|
|
received = MultiplyBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalAdd(t *testing.T) {
|
|
x := decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y := decimal.WithContext(DecimalContext).SetUint64(5)
|
|
expected, _ := decimal.WithContext(DecimalContext).SetUint64(15).Float64()
|
|
received, _ := SumBig(x, y).Float64()
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestSumBigNil(t *testing.T) {
|
|
var x, y, expected *decimal.Big
|
|
x = nil
|
|
y = decimal.WithContext(DecimalContext).SetUint64(2)
|
|
expected = decimal.WithContext(DecimalContext).SetUint64(2)
|
|
received := SumBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
|
|
x = decimal.WithContext(DecimalContext).SetUint64(3)
|
|
y = nil
|
|
expected = decimal.WithContext(DecimalContext).SetUint64(3)
|
|
received = SumBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestSubstractBigNil(t *testing.T) {
|
|
var x, y, expected *decimal.Big
|
|
x = decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y = nil
|
|
expected = decimal.WithContext(DecimalContext).SetUint64(10)
|
|
received := SubstractBig(x, y)
|
|
if !reflect.DeepEqual(expected, received) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalFromUnit(t *testing.T) {
|
|
if val, err := NewDecimalFromUsage("1ns"); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(val, NewDecimal(1, 0)) {
|
|
t.Errorf("Expected %+v, received %+v", NewDecimal(1, 0), val)
|
|
}
|
|
}
|
|
|
|
func TestUnmarshalMarshalBinary(t *testing.T) {
|
|
dec := &Decimal{}
|
|
expected := NewDecimal(10, 0)
|
|
if err := dec.UnmarshalBinary([]byte(`10`)); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected.Big, dec.Big) {
|
|
t.Errorf("Expected %T, received %T", expected, dec.Big)
|
|
}
|
|
|
|
dec = nil
|
|
if err := dec.UnmarshalBinary([]byte(`10`)); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
dec1 := new(Decimal)
|
|
expected2 := []byte(`0`)
|
|
if rcv, err := dec1.MarshalBinary(); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected2, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", string(expected2), string(rcv))
|
|
}
|
|
}
|
|
|
|
func TestDecimalCompareNaN(t *testing.T) {
|
|
dec1 := NewDecimal(2, 0)
|
|
if comp := dec1.Compare(DecimalNaN); comp <= 0 {
|
|
t.Errorf("%v is higher than %v, means comp is: %v", dec1, DecimalNaN, comp)
|
|
}
|
|
if comp := DecimalNaN.Compare(dec1); comp >= 0 {
|
|
t.Errorf("%v is lower than %v, means comp is: %v", DecimalNaN, dec1, comp)
|
|
}
|
|
|
|
dec1 = DecimalNaN
|
|
if comp := dec1.Compare(DecimalNaN); comp != 0 {
|
|
t.Errorf("%v is equal to %v, means comp is: %v", dec1, DecimalNaN, comp)
|
|
}
|
|
}
|
|
|
|
func TestUnmarshalJSON(t *testing.T) {
|
|
dec1 := new(Decimal)
|
|
expected := NewDecimal(0, 0)
|
|
if err := dec1.UnmarshalJSON([]byte(`0`)); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, dec1) {
|
|
t.Errorf("Expected %+v, received %+v", expected, dec1)
|
|
}
|
|
|
|
var dec2 Decimal
|
|
if err := dec2.UnmarshalJSON([]byte(`0`)); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
var decnil *Decimal
|
|
if err := decnil.UnmarshalJSON([]byte(`0`)); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestDecimalCalculus(t *testing.T) {
|
|
d1 := NewDecimal(10, 0)
|
|
d2 := NewDecimal(20, 0)
|
|
if d1.Compare(d2) != -1 {
|
|
t.Errorf("%+v should be lower that %+v", d1, d2)
|
|
}
|
|
|
|
if rcv := SubstractBig(d2.Big, d1.Big); !reflect.DeepEqual(rcv, d1.Big) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(d1.Big), ToJSON(rcv))
|
|
}
|
|
|
|
if rcv := MultiplyDecimal(d1, d2); !reflect.DeepEqual(NewDecimal(200, 0), rcv) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(NewDecimal(200, 0)), ToJSON(rcv))
|
|
}
|
|
|
|
if rcv := SubstractDecimal(d2, d1); !reflect.DeepEqual(d1, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", ToJSON(d1), ToJSON(rcv))
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalFromUsage(t *testing.T) {
|
|
dec := "12tts"
|
|
expectedErr := "time: unknown unit \"tts\" in duration \"12tts\""
|
|
if _, err := NewDecimalFromUsage(dec); err == nil || err.Error() != expectedErr {
|
|
t.Errorf("Expected %+v, received %+v", expectedErr, err)
|
|
}
|
|
|
|
dec = "2"
|
|
expected := NewDecimal(2, 0)
|
|
if rcv, err := NewDecimalFromUsage(dec); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", expected, rcv)
|
|
}
|
|
|
|
dec = "invalid_decimal_format"
|
|
expectedErr = "can't convert <invalid_decimal_format> to decimal"
|
|
if _, err := NewDecimalFromUsage(dec); err == nil || err.Error() != expectedErr {
|
|
t.Errorf("Expected %+v, received %+v", expectedErr, err)
|
|
}
|
|
|
|
dec = "1000"
|
|
expected = NewDecimal(1000, 0)
|
|
if rcv, err := NewDecimalFromUsage(dec); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", expected, rcv)
|
|
}
|
|
|
|
dec = "12m"
|
|
expected = NewDecimal(int64(12*time.Minute), 0)
|
|
if rcv, err := NewDecimalFromUsage(dec); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", expected, rcv)
|
|
}
|
|
|
|
dec = "12m10s"
|
|
expected = NewDecimal(int64(12*time.Minute+10*time.Second), 0)
|
|
if rcv, err := NewDecimalFromUsage(dec); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", expected, rcv)
|
|
}
|
|
|
|
dec = "12.44"
|
|
expected = NewDecimal(1244, 2)
|
|
if rcv, err := NewDecimalFromUsage(dec); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expected, rcv) {
|
|
t.Errorf("Expected %+v, received %+v", expected, rcv)
|
|
}
|
|
|
|
dec = "12.44.5"
|
|
expectedErr = "can't convert <12.44.5> to decimal"
|
|
if _, err := NewDecimalFromUsage(dec); err == nil || err.Error() != expectedErr {
|
|
t.Errorf("Expected %+v, received %+v", expectedErr, err)
|
|
}
|
|
}
|
|
|
|
func TestDecimalNewDecimalFromString(t *testing.T) {
|
|
str := "123.4"
|
|
received, err := NewDecimalFromString(str)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expected := &Decimal{decimal.New(1234, 1)}
|
|
if !reflect.DeepEqual(received, expected) {
|
|
t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, received)
|
|
}
|
|
}
|
|
|
|
func TestDecimalNewDecimalFromStringErr(t *testing.T) {
|
|
str := "testString"
|
|
_, err := NewDecimalFromString(str)
|
|
expected := "can't convert <" + str + "> to decimal"
|
|
|
|
if err == nil || err.Error() != expected {
|
|
t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, err)
|
|
}
|
|
}
|
|
|
|
func TestDivideBigWithReminder(t *testing.T) {
|
|
x := decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y := decimal.WithContext(DecimalContext).SetUint64(5)
|
|
qExpected := decimal.WithContext(DecimalContext).SetUint64(2)
|
|
rExpected := decimal.WithContext(DecimalContext).SetUint64(0)
|
|
qReceived, rReceived := DivideBigWithReminder(x, y)
|
|
if !reflect.DeepEqual(qExpected, qReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", qExpected, qReceived)
|
|
} else if !reflect.DeepEqual(rExpected, rReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", rExpected, rReceived)
|
|
}
|
|
|
|
x = nil
|
|
qReceived, rReceived = DivideBigWithReminder(x, y)
|
|
qExpected = nil
|
|
rExpected = nil
|
|
if !reflect.DeepEqual(qExpected, qReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", qExpected, qReceived)
|
|
} else if !reflect.DeepEqual(rExpected, rReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", rExpected, rReceived)
|
|
}
|
|
|
|
x = decimal.WithContext(DecimalContext).SetUint64(10)
|
|
y = nil
|
|
qReceived, rReceived = DivideBigWithReminder(x, y)
|
|
qExpected = nil
|
|
rExpected = nil
|
|
if !reflect.DeepEqual(qExpected, qReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", qExpected, qReceived)
|
|
} else if !reflect.DeepEqual(rExpected, rReceived) {
|
|
t.Errorf("Expected divident <+%v> but received <+%v>", rExpected, rReceived)
|
|
}
|
|
}
|
|
|
|
func TestDecimalNewDecimalFromUsageEmptyStringCase(t *testing.T) {
|
|
exp := NewDecimal(0, 0)
|
|
if rcv, err := NewDecimalFromUsage(EmptyString); err != nil {
|
|
t.Error(err)
|
|
} else if rcv.Compare(exp) != 0 {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestDecimalFloat64(t *testing.T) {
|
|
d := NewDecimal(123, 2)
|
|
exp := 1.23
|
|
if rcv, ok := d.Float64(); !ok {
|
|
t.Error("expected ok to be true")
|
|
} else if rcv != exp {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestDecimalDuration(t *testing.T) {
|
|
d := NewDecimal(int64(3), 0)
|
|
rcv, ok := d.Duration()
|
|
if !ok {
|
|
t.Error("Cannot convert")
|
|
} else if rcv != time.Nanosecond*3 {
|
|
t.Errorf("Expected 3ns")
|
|
}
|
|
|
|
d = NewDecimal(999999999999999999, 5555555555555555555)
|
|
rcv, ok = d.Duration()
|
|
if ok {
|
|
t.Errorf("Cannot convert %v", rcv)
|
|
}
|
|
}
|
|
|
|
func TestMarshalUnmarshalNA(t *testing.T) {
|
|
mrsh, err := DecimalNaN.MarshalJSON()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
var dec2 Decimal
|
|
if err := dec2.UnmarshalJSON(mrsh); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if dec2.Compare(DecimalNaN) != 0 {
|
|
t.Errorf("%v and %v are different", dec2, DecimalNaN)
|
|
}
|
|
}
|
|
|
|
func TestNewRoundingMode(t *testing.T) {
|
|
var tests = []struct {
|
|
rnd string
|
|
exp decimal.RoundingMode
|
|
}{
|
|
{"*toNearestEven", 0},
|
|
{"*toNearestAway", 1},
|
|
{"*toZero", 2},
|
|
{"*awayFromZero", 3},
|
|
{"*toNegativeInf", 4},
|
|
{"*toPositiveInf", 5},
|
|
{"*toNearestTowardZero", 6},
|
|
}
|
|
|
|
unsupp := "unsupported"
|
|
|
|
for _, e := range tests {
|
|
if rcv, err := NewRoundingMode(e.rnd); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv, e.exp) {
|
|
t.Errorf("expected: <%v>, received: <%v>", e.exp, rcv)
|
|
}
|
|
|
|
}
|
|
expErr := "usupoorted rounding: <\"unsupported\">"
|
|
if _, err := NewRoundingMode(unsupp); err == nil || err.Error() != expErr {
|
|
t.Errorf("expected: <%+v>, received: <%+v>", expErr, err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestNewRoundingModeToString(t *testing.T) {
|
|
var tests = []struct {
|
|
rnd decimal.RoundingMode
|
|
exp string
|
|
}{
|
|
{0, "*toNearestEven"},
|
|
{1, "*toNearestAway"},
|
|
{2, "*toZero"},
|
|
{3, "*awayFromZero"},
|
|
{4, "*toNegativeInf"},
|
|
{5, "*toPositiveInf"},
|
|
{6, "*toNearestTowardZero"},
|
|
{7, ""},
|
|
}
|
|
|
|
for _, e := range tests {
|
|
if rcv := RoundingModeToString(e.rnd); !reflect.DeepEqual(rcv, e.exp) {
|
|
t.Errorf("expected: <%v>, received: <%v>", e.exp, rcv)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestDivideDecimal(t *testing.T) {
|
|
var x *Decimal = NewDecimal(12, 0)
|
|
var y *Decimal = NewDecimal(2, 0)
|
|
exp := NewDecimal(6, 0)
|
|
if rcv := DivideDecimal(x, y); !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected: <%+v>, received: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestNewDecimalFromStringIgnoreError(t *testing.T) {
|
|
if rcv := NewDecimalFromStringIgnoreError("teststring"); rcv != nil {
|
|
t.Errorf("Expected <nil>, received <%+v>", rcv)
|
|
}
|
|
}
|