mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
391 lines
11 KiB
Go
391 lines
11 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 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
package utils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestYearsSort(t *testing.T) {
|
|
ys := &Years{}
|
|
ys.Sort()
|
|
if !reflect.DeepEqual(ys, &Years{}) {
|
|
t.Errorf("Expecting %+v received: %+v", &Years{}, ys)
|
|
}
|
|
ys = &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
ysSorted := &Years{2005, 2007, 2010, 2018, 2019, 2020}
|
|
ys.Sort()
|
|
if !reflect.DeepEqual(ys, ysSorted) {
|
|
t.Errorf("Expecting %+v received: %+v", ysSorted, ys)
|
|
}
|
|
}
|
|
|
|
func TestYearsLen(t *testing.T) {
|
|
ys := &Years{}
|
|
if rcv := ys.Len(); rcv != 0 {
|
|
t.Errorf("Expecting %+v received: %+v", 0, rcv)
|
|
}
|
|
ys = &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
if rcv := ys.Len(); rcv != 6 {
|
|
t.Errorf("Expecting %+v received: %+v", 6, rcv)
|
|
}
|
|
}
|
|
|
|
func TestYearsSwap(t *testing.T) {
|
|
ys := &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
ys.Swap(0, 1)
|
|
ysSwapped := &Years{2010, 2019, 2020, 2005, 2018, 2007}
|
|
if !reflect.DeepEqual(ys, ysSwapped) {
|
|
t.Errorf("Expecting %+v received: %+v", ysSwapped, ys)
|
|
}
|
|
}
|
|
|
|
func TestYearsLess(t *testing.T) {
|
|
ys := &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
if rcv := ys.Less(0, 1); rcv {
|
|
t.Errorf("Expecting false received: %+v", rcv)
|
|
}
|
|
if rcv := ys.Less(1, 2); !rcv {
|
|
t.Errorf("Expecting true received: %+v", rcv)
|
|
}
|
|
}
|
|
|
|
func TestYearsContains(t *testing.T) {
|
|
ys := &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
if rcv := ys.Contains(2019); !rcv {
|
|
t.Errorf("Expecting true received: %+v", rcv)
|
|
}
|
|
if rcv := ys.Contains(1989); rcv {
|
|
t.Errorf("Expecting false received: %+v", rcv)
|
|
}
|
|
}
|
|
|
|
func TestYearsParse(t *testing.T) {
|
|
ys := &Years{}
|
|
eOut := &Years{}
|
|
ys.Parse(META_ANY, EmptyString)
|
|
if !reflect.DeepEqual(eOut, ys) {
|
|
t.Errorf("Expecting %+v received: %+v", eOut, ys)
|
|
}
|
|
ys = &Years{2019, 2010, 2020, 2005, 2018, 2007}
|
|
eOut = &Years{2019, 2010, 2020, 2005, 2018, 2007, 2010, 2011, 2012, 2013}
|
|
ys.Parse("2010,2011,2012,2013", ",")
|
|
if !reflect.DeepEqual(eOut, ys) {
|
|
t.Errorf("Expecting %+v received: %+v", eOut, ys)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthStoreRestoreJson(t *testing.T) {
|
|
m := Months{5, 6, 7, 8}
|
|
r, _ := json.Marshal(m)
|
|
if string(r) != "[5,6,7,8]" {
|
|
t.Errorf("Error serializing months: %v", string(r))
|
|
}
|
|
o := Months{}
|
|
json.Unmarshal(r, &o)
|
|
if !reflect.DeepEqual(o, m) {
|
|
t.Errorf("Expected %v was %v", m, o)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthDayStoreRestoreJson(t *testing.T) {
|
|
md := MonthDays{24, 25, 26}
|
|
r, _ := json.Marshal(md)
|
|
if string(r) != "[24,25,26]" {
|
|
t.Errorf("Error serializing month days: %v", string(r))
|
|
}
|
|
o := MonthDays{}
|
|
json.Unmarshal(r, &o)
|
|
if !reflect.DeepEqual(o, md) {
|
|
t.Errorf("Expected %v was %v", md, o)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesWeekDayStoreRestoreJson(t *testing.T) {
|
|
wd := WeekDays{time.Saturday, time.Sunday}
|
|
r, _ := json.Marshal(wd)
|
|
if string(r) != "[6,0]" {
|
|
t.Errorf("Error serializing week days: %v", string(r))
|
|
}
|
|
o := WeekDays{}
|
|
json.Unmarshal(r, &o)
|
|
if !reflect.DeepEqual(o, wd) {
|
|
t.Errorf("Expected %v was %v", wd, o)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesYearsSerialize(t *testing.T) {
|
|
ys := &Years{}
|
|
yString := ys.Serialize(";")
|
|
expectString := "*any"
|
|
if expectString != yString {
|
|
t.Errorf("Expected: %s, got: %s", expectString, yString)
|
|
}
|
|
ys2 := &Years{2012}
|
|
yString2 := ys2.Serialize(";")
|
|
expectString2 := "2012"
|
|
if expectString2 != yString2 {
|
|
t.Errorf("Expected: %s, got: %s", expectString2, yString2)
|
|
}
|
|
ys3 := &Years{2013, 2014, 2015}
|
|
yString3 := ys3.Serialize(";")
|
|
expectString3 := "2013;2014;2015"
|
|
if expectString3 != yString3 {
|
|
t.Errorf("Expected: %s, got: %s", expectString3, yString3)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsSerialize(t *testing.T) {
|
|
mths := &Months{}
|
|
mString := mths.Serialize(";")
|
|
expectString := "*any"
|
|
if expectString != mString {
|
|
t.Errorf("Expected: %s, got: %s", expectString, mString)
|
|
}
|
|
mths2 := &Months{time.January}
|
|
mString2 := mths2.Serialize(";")
|
|
expectString2 := "1"
|
|
if expectString2 != mString2 {
|
|
t.Errorf("Expected: %s, got: %s", expectString2, mString2)
|
|
}
|
|
mths3 := &Months{time.January, time.December}
|
|
mString3 := mths3.Serialize(";")
|
|
expectString3 := "1;12"
|
|
if expectString3 != mString3 {
|
|
t.Errorf("Expected: %s, got: %s", expectString3, mString3)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthDaysSerialize(t *testing.T) {
|
|
mds := &MonthDays{}
|
|
mdsString := mds.Serialize(";")
|
|
expectString := "*any"
|
|
if expectString != mdsString {
|
|
t.Errorf("Expected: %s, got: %s", expectString, mdsString)
|
|
}
|
|
mds2 := &MonthDays{1}
|
|
mdsString2 := mds2.Serialize(";")
|
|
expectString2 := "1"
|
|
if expectString2 != mdsString2 {
|
|
t.Errorf("Expected: %s, got: %s", expectString2, mdsString2)
|
|
}
|
|
mds3 := &MonthDays{1, 2, 3, 4, 5}
|
|
mdsString3 := mds3.Serialize(";")
|
|
expectString3 := "1;2;3;4;5"
|
|
if expectString3 != mdsString3 {
|
|
t.Errorf("Expected: %s, got: %s", expectString3, mdsString3)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesWeekDaysSerialize(t *testing.T) {
|
|
wds := &WeekDays{}
|
|
wdsString := wds.Serialize(";")
|
|
expectString := "*any"
|
|
if expectString != wdsString {
|
|
t.Errorf("Expected: %s, got: %s", expectString, wdsString)
|
|
}
|
|
wds2 := &WeekDays{time.Monday}
|
|
wdsString2 := wds2.Serialize(";")
|
|
expectString2 := "1"
|
|
if expectString2 != wdsString2 {
|
|
t.Errorf("Expected: %s, got: %s", expectString2, wdsString2)
|
|
}
|
|
wds3 := &WeekDays{time.Monday, time.Saturday, time.Sunday}
|
|
wdsString3 := wds3.Serialize(";")
|
|
expectString3 := "1;6;0"
|
|
if expectString3 != wdsString3 {
|
|
t.Errorf("Expected: %s, got: %s", expectString3, wdsString3)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsIsCompleteNot(t *testing.T) {
|
|
months := Months{time.January, time.February, time.March, time.April, time.May, time.June, time.July, time.August, time.September, time.October, time.November}
|
|
if months.IsComplete() {
|
|
t.Error("Error months IsComplete: ", months)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsIsCompleteYes(t *testing.T) {
|
|
months := Months{time.January, time.February, time.March, time.April, time.May, time.June, time.July, time.August, time.September, time.October, time.November, time.December}
|
|
if !months.IsComplete() {
|
|
t.Error("Error months IsComplete: ", months)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesDaysInMonth(t *testing.T) {
|
|
if n := DaysInMonth(2016, 4); n != 30 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
if n := DaysInMonth(2016, 2); n != 29 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
if n := DaysInMonth(2016, 1); n != 31 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
if n := DaysInMonth(2016, 12); n != 31 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
if n := DaysInMonth(2015, 2); n != 28 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesDaysInYear(t *testing.T) {
|
|
if n := DaysInYear(2016); n != 366 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
if n := DaysInYear(2015); n != 365 {
|
|
t.Error("error calculating days: ", n)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesWeekDaysEquals(t *testing.T) {
|
|
wds1 := WeekDays{time.Monday, time.Saturday, time.Sunday}
|
|
wds2 := WeekDays{time.Monday, time.Saturday, time.Sunday}
|
|
wds3 := WeekDays{time.Monday}
|
|
if wds1.Equals(wds2) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if wds1.Equals(wds3) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsEquals(t *testing.T) {
|
|
m1 := Months{5, 6, 7, 8}
|
|
m2 := Months{5, 6, 7, 8}
|
|
m3 := Months{}
|
|
if m1.Equals(m2) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if m1.Equals(m3) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthDaysEquals(t *testing.T) {
|
|
md1 := MonthDays{24, 25, 26}
|
|
md2 := MonthDays{24, 25, 26}
|
|
md3 := MonthDays{}
|
|
if md1.Equals(md2) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if md1.Equals(md3) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesYearsEquals(t *testing.T) {
|
|
ys1 := Years{2013, 2014, 2015}
|
|
ys2 := Years{2013, 2014, 2015}
|
|
ys3 := Years{}
|
|
if ys1.Equals(ys2) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if ys1.Equals(ys3) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesWeekDaysParse(t *testing.T) {
|
|
wds1 := WeekDays{}
|
|
in := "1,2,3"
|
|
wds2 := WeekDays{time.Monday, time.Tuesday, time.Wednesday}
|
|
if reflect.DeepEqual(wds2, wds1) != false {
|
|
t.Errorf("Expected: %+v, received: %+v", WeekDays{}, wds1)
|
|
}
|
|
wds1.Parse(in, ",")
|
|
if !reflect.DeepEqual(wds2, wds1) {
|
|
t.Errorf("Expected: %+v, received: %+v", wds2, wds1)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsParse(t *testing.T) {
|
|
m1 := Months{}
|
|
m2 := Months{5, 6, 7, 8}
|
|
in := "5,6,7,8"
|
|
if reflect.DeepEqual(m2, m1) != false {
|
|
t.Errorf("Expected: %+v, received: %+v", Months{}, m1)
|
|
}
|
|
m1.Parse(in, ",")
|
|
if !reflect.DeepEqual(m2, m1) {
|
|
t.Errorf("Expected: %+v, received: %+v", m2, m1)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthDaysParse(t *testing.T) {
|
|
md1 := MonthDays{}
|
|
md2 := MonthDays{24, 25, 26}
|
|
in := "24,25,26"
|
|
if reflect.DeepEqual(md2, md1) != false {
|
|
t.Errorf("Expected: %+v, received: %+v", MonthDays{}, md1)
|
|
}
|
|
md1.Parse(in, ",")
|
|
if !reflect.DeepEqual(md2, md1) {
|
|
t.Errorf("Expected: %+v, received: %+v", md2, md1)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesYearsParse(t *testing.T) {
|
|
ys1 := Years{}
|
|
ys2 := Years{2013, 2014, 2015}
|
|
in := "2013,2014,2015"
|
|
if reflect.DeepEqual(ys2, ys1) != false {
|
|
t.Errorf("Expected: %+v, received: %+v", Years{}, ys1)
|
|
}
|
|
ys1.Parse(in, ",")
|
|
if !reflect.DeepEqual(ys2, ys1) {
|
|
t.Errorf("Expected: %+v, received: %+v", ys2, ys1)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesWeekDaysContains(t *testing.T) {
|
|
wds := WeekDays{time.Monday, time.Tuesday}
|
|
if wds.Contains(time.Monday) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if wds.Contains(time.Wednesday) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthsContains(t *testing.T) {
|
|
m := Months{5, 6, 7, 8}
|
|
if m.Contains(5) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if m.Contains(4) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesMonthDaysContains(t *testing.T) {
|
|
md := MonthDays{24, 25, 26}
|
|
if md.Contains(24) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if md.Contains(23) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|
|
|
|
func TestDateseriesYearsContains(t *testing.T) {
|
|
ys := Years{2013, 2014, 2015}
|
|
if ys.Contains(2013) != true {
|
|
t.Errorf("Expected: true, got: %v", !true)
|
|
} else if ys.Contains(2012) != false {
|
|
t.Errorf("Expected: false, got: %v", !false)
|
|
}
|
|
}
|