diff --git a/utils/dataconverter.go b/utils/dataconverter.go
index 6e0f2cb77..5dcac41a3 100644
--- a/utils/dataconverter.go
+++ b/utils/dataconverter.go
@@ -89,8 +89,7 @@ func NewDataConverterMustCompile(params string) (conv DataConverter) {
 	return
 }
 
-func NewDurationSecondsConverter(params string) (
-	hdlr DataConverter, err error) {
+func NewDurationSecondsConverter(params string) (hdlr DataConverter, err error) {
 	return new(DurationSecondsConverter), nil
 }
 
@@ -128,21 +127,24 @@ func (mS *DurationNanosecondsConverter) Convert(in interface{}) (
 func NewRoundConverter(params string) (hdlr DataConverter, err error) {
 	rc := new(RoundConverter)
 	var paramsSplt []string
-	if params != "" {
+	if params != EmptyString {
 		paramsSplt = strings.Split(params, InInFieldSep)
 	}
 	switch len(paramsSplt) {
-	case 2:
-		rc.Method = paramsSplt[1]
-		fallthrough
+	case 0:
+		rc.Method = ROUNDING_MIDDLE
 	case 1:
 		if rc.Decimals, err = strconv.Atoi(paramsSplt[0]); err != nil {
 			return nil, fmt.Errorf("%s converter needs integer as decimals, have: <%s>",
 				MetaRound, paramsSplt[0])
 		}
-		fallthrough
-	case 0:
 		rc.Method = ROUNDING_MIDDLE
+	case 2:
+		rc.Method = paramsSplt[1]
+		if rc.Decimals, err = strconv.Atoi(paramsSplt[0]); err != nil {
+			return nil, fmt.Errorf("%s converter needs integer as decimals, have: <%s>",
+				MetaRound, paramsSplt[0])
+		}
 	default:
 		return nil, fmt.Errorf("unsupported %s converter parameters: <%s>",
 			MetaRound, params)
@@ -156,8 +158,7 @@ type RoundConverter struct {
 	Method   string
 }
 
-func (rnd *RoundConverter) Convert(in interface{}) (
-	out interface{}, err error) {
+func (rnd *RoundConverter) Convert(in interface{}) (out interface{}, err error) {
 	var inFloat float64
 	if inFloat, err = IfaceAsFloat64(in); err != nil {
 		return
@@ -167,7 +168,7 @@ func (rnd *RoundConverter) Convert(in interface{}) (
 }
 
 func NewMultiplyConverter(constructParams string) (hdlr DataConverter, err error) {
-	if constructParams == "" {
+	if constructParams == EmptyString {
 		return nil, ErrMandatoryIeMissingNoCaps
 	}
 	var val float64
@@ -183,8 +184,7 @@ type MultiplyConverter struct {
 	Value float64
 }
 
-func (m *MultiplyConverter) Convert(in interface{}) (
-	out interface{}, err error) {
+func (m *MultiplyConverter) Convert(in interface{}) (out interface{}, err error) {
 	var inFloat64 float64
 	if inFloat64, err = IfaceAsFloat64(in); err != nil {
 		return nil, err
@@ -193,8 +193,7 @@ func (m *MultiplyConverter) Convert(in interface{}) (
 	return
 }
 
-func NewDivideConverter(constructParams string) (
-	hdlr DataConverter, err error) {
+func NewDivideConverter(constructParams string) (hdlr DataConverter, err error) {
 	if constructParams == "" {
 		return nil, ErrMandatoryIeMissingNoCaps
 	}
@@ -211,8 +210,7 @@ type DivideConverter struct {
 	Value float64
 }
 
-func (m *DivideConverter) Convert(in interface{}) (
-	out interface{}, err error) {
+func (m *DivideConverter) Convert(in interface{}) (out interface{}, err error) {
 	var inFloat64 float64
 	if inFloat64, err = IfaceAsFloat64(in); err != nil {
 		return nil, err
@@ -221,8 +219,7 @@ func (m *DivideConverter) Convert(in interface{}) (
 	return
 }
 
-func NewDurationConverter(params string) (
-	hdlr DataConverter, err error) {
+func NewDurationConverter(params string) (hdlr DataConverter, err error) {
 	return new(DurationConverter), nil
 }
 
@@ -242,7 +239,7 @@ func NewPhoneNumberConverter(params string) (
 	pbDC DataConverter, err error) {
 	lc := new(PhoneNumberConverter)
 	var paramsSplt []string
-	if params != "" {
+	if params != EmptyString {
 		paramsSplt = strings.Split(params, InInFieldSep)
 	}
 	switch len(paramsSplt) {
@@ -269,8 +266,7 @@ type PhoneNumberConverter struct {
 	Format      phonenumbers.PhoneNumberFormat
 }
 
-func (lc *PhoneNumberConverter) Convert(in interface{}) (
-	out interface{}, err error) {
+func (lc *PhoneNumberConverter) Convert(in interface{}) (out interface{}, err error) {
 	num, err := phonenumbers.Parse(IfaceAsString(in), lc.CountryCode)
 	if err != nil {
 		return nil, err
diff --git a/utils/dataconverter_test.go b/utils/dataconverter_test.go
index 1e1a00108..7a47411c2 100644
--- a/utils/dataconverter_test.go
+++ b/utils/dataconverter_test.go
@@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package utils
 
 import (
+	"math"
 	"reflect"
 	"testing"
 	"time"
@@ -42,11 +43,11 @@ func TestDataConvertersConvertString(t *testing.T) {
 func TestNewDataConverter(t *testing.T) {
 	a, err := NewDataConverter(MetaDurationSeconds)
 	if err != nil {
-		t.Error(err.Error())
+		t.Error(err)
 	}
 	b, err := NewDurationSecondsConverter(EmptyString)
 	if err != nil {
-		t.Error(err.Error())
+		t.Error(err)
 	}
 	if !reflect.DeepEqual(a, b) {
 		t.Error("Error reflect")
@@ -149,6 +150,198 @@ func TestNewDataConverterMustCompile(t *testing.T) {
 	}
 }
 
+func TestNewDurationSecondsConverter(t *testing.T) {
+	eOut := DurationSecondsConverter{}
+	if rcv, err := NewDurationSecondsConverter("test"); err != nil {
+		t.Error(err)
+	} else if reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
+func TestDurationSecondsConverterConvert(t *testing.T) {
+	mS := &DurationSecondsConverter{}
+	if _, err := mS.Convert("string"); err.Error() != "time: invalid duration string" {
+		t.Error(err)
+	}
+}
+
+func TestDurationNanosecondsConverterConvert(t *testing.T) {
+	nS := &DurationNanosecondsConverter{}
+	if _, err := nS.Convert("string"); err.Error() != "time: invalid duration string" {
+		t.Error(err)
+	}
+}
+func TestNewRoundConverter(t *testing.T) {
+	if _, err := NewRoundConverter("test"); err == nil || err.Error() != "*round converter needs integer as decimals, have: <test>" {
+		t.Error(err)
+	}
+	if _, err := NewRoundConverter(":test"); err == nil || err.Error() != "*round converter needs integer as decimals, have: <>" {
+		t.Error(err)
+	}
+	if _, err := NewRoundConverter("test:"); err == nil || err.Error() != "*round converter needs integer as decimals, have: <test>" {
+		t.Error(err)
+	}
+	eOut := &RoundConverter{
+		Method: ROUNDING_MIDDLE,
+	}
+	if rcv, err := NewRoundConverter(EmptyString); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = &RoundConverter{
+		Decimals: 12,
+		Method:   ROUNDING_UP,
+	}
+	if rcv, err := NewRoundConverter("12:*up"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = &RoundConverter{
+		Decimals: 12,
+		Method:   ROUNDING_DOWN,
+	}
+	if rcv, err := NewRoundConverter("12:*down"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = &RoundConverter{
+		Decimals: 12,
+		Method:   ROUNDING_MIDDLE,
+	}
+	if rcv, err := NewRoundConverter("12:*middle"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = &RoundConverter{}
+	if rcv, err := NewRoundConverter("12:*middle:wrong_length"); err == nil || err.Error() != "unsupported *round converter parameters: <12:*middle:wrong_length>" {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+
+}
+
+func TestRoundConverterConvert(t *testing.T) {
+	rnd := &RoundConverter{}
+	if rcv, err := rnd.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	eOut := Round(18, rnd.Decimals, rnd.Method)
+	if rcv, err := rnd.Convert(18); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
+func TestNewMultiplyConverter(t *testing.T) {
+	if rcv, err := NewMultiplyConverter(EmptyString); err == nil || err != ErrMandatoryIeMissingNoCaps {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	if rcv, err := NewMultiplyConverter("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	eOut := &MultiplyConverter{Value: 0.7}
+	if rcv, err := NewMultiplyConverter("0.7"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, eOut) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
+func TestMultiplyConverterConvert(t *testing.T) {
+	m := &MultiplyConverter{}
+	if rcv, err := m.Convert(EmptyString); err == nil || err.Error() != `strconv.ParseFloat: parsing "": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	if rcv, err := m.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	if rcv, err := m.Convert(3); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, 0.0) {
+		t.Errorf("Expected %+v received: %+v", 0, rcv)
+	}
+}
+
+func TestNewDivideConverter(t *testing.T) {
+	if rcv, err := NewDivideConverter(EmptyString); err == nil || err != ErrMandatoryIeMissingNoCaps {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	if rcv, err := NewDivideConverter("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	eOut := &DivideConverter{Value: 0.7}
+	if rcv, err := NewDivideConverter("0.7"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
+func TestDivideConverterConvert(t *testing.T) {
+	m := DivideConverter{}
+	if rcv, err := m.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, nil) {
+		t.Errorf("Expected %+v received: %+v", nil, rcv)
+	}
+	eOut := math.Inf(1)
+	if rcv, err := m.Convert("96"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = math.Inf(-1)
+	if rcv, err := m.Convert("-96"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	m = DivideConverter{Value: 0.7}
+	eOut = 137.14285714285714
+	if rcv, err := m.Convert("96"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
+func TestNewDurationConverter(t *testing.T) {
+	nS := &DurationConverter{}
+	eOut := time.Duration(0 * time.Second)
+	if rcv, err := nS.Convert(EmptyString); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+	eOut = time.Duration(7 * time.Nanosecond)
+	if rcv, err := nS.Convert(7); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(eOut, rcv) {
+		t.Errorf("Expected %+v received: %+v", eOut, rcv)
+	}
+}
+
 func TestConvertFloatToSeconds(t *testing.T) {
 	b, err := NewDataConverter(MetaDurationSeconds)
 	if err != nil {
@@ -344,11 +537,18 @@ func TestDurationConverter(t *testing.T) {
 
 func TestPhoneNumberConverter(t *testing.T) {
 	// test for error
-	if _, err := NewDataConverter("*libphonenumber:US:1:2:error"); err == nil ||
-		err.Error() != "unsupported *libphonenumber converter parameters: <US:1:2:error>" {
+	if rcv, err := NewDataConverter("*libphonenumber:US:1:2:error"); err == nil || err.Error() != "unsupported *libphonenumber converter parameters: <US:1:2:error>" {
 		t.Error(err)
+	} else if !reflect.DeepEqual(nil, rcv) {
+		t.Errorf("Expecting: %+v, received: %+v", nil, rcv)
+	}
+	if rcv, err := NewDataConverter("*libphonenumber:US:X"); err == nil || err.Error() != `strconv.Atoi: parsing "X": invalid syntax` {
+		t.Error(err)
+	} else if !reflect.DeepEqual(nil, rcv) {
+		t.Errorf("Expecting: %+v, received: %+v", nil, rcv)
 	}
 
+	// US/National
 	eLc := &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.NATIONAL}
 	d, err := NewDataConverter("*libphonenumber:US")
 	if err != nil {
@@ -363,40 +563,36 @@ func TestPhoneNumberConverter(t *testing.T) {
 	} else if !reflect.DeepEqual(phoneNumberConverted, "(443) 123-4567") {
 		t.Errorf("expecting: %+v, received: %+v", "(443) 123-4567", phoneNumberConverted)
 	}
-}
-
-func TestPhoneNumberConverter2(t *testing.T) {
-	eLc := &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.INTERNATIONAL}
-	d, err := NewDataConverter("*libphonenumber:US:1")
+	//US/International
+	eLc = &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.INTERNATIONAL}
+	d, err = NewDataConverter("*libphonenumber:US:1")
 	if err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(eLc, d) {
 		t.Errorf("expecting: %+v, received: %+v", eLc, d)
 	}
 	// simulate an E164 number and Format it into a National number
-	phoneNumberConverted, err := d.Convert("+14431234567")
+	phoneNumberConverted, err = d.Convert("+14431234567")
 	if err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(phoneNumberConverted, "+1 443-123-4567") {
 		t.Errorf("expecting: %+v, received: %+v", "+1 443-123-4567", phoneNumberConverted)
 	}
-}
-
-func TestPhoneNumberConverter3(t *testing.T) {
-	eLc := &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.INTERNATIONAL}
-	d, err := NewDataConverter("*libphonenumber:DE:1")
+	// DE/International
+	eLc = &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.INTERNATIONAL}
+	d, err = NewDataConverter("*libphonenumber:DE:1")
 	if err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(eLc, d) {
 		t.Errorf("expecting: %+v, received: %+v", eLc, d)
 	}
-	phoneNumberConverted, err := d.Convert("6502530000")
+	phoneNumberConverted, err = d.Convert("6502530000")
 	if err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(phoneNumberConverted, "+49 6502 530000") {
 		t.Errorf("expecting: %+v, received: %+v", "+49 6502 530000", phoneNumberConverted)
 	}
-
+	// DE/E164
 	eLc = &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.E164}
 	d, err = NewDataConverter("*libphonenumber:DE:0")
 	if err != nil {
diff --git a/utils/dateseries_test.go b/utils/dateseries_test.go
index 6cfe92331..54d12ef03 100644
--- a/utils/dateseries_test.go
+++ b/utils/dateseries_test.go
@@ -24,6 +24,50 @@ import (
 	"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 TestDateseriesMonthStoreRestoreJson(t *testing.T) {
 	m := Months{5, 6, 7, 8}
 	r, _ := json.Marshal(m)