diff --git a/engine/dynamicdp_test.go b/engine/dynamicdp_test.go
index 3a8b8d0c1..fd159a45f 100644
--- a/engine/dynamicdp_test.go
+++ b/engine/dynamicdp_test.go
@@ -216,3 +216,249 @@ func TestLibphonenumberDPFieldAsInterfaceLen0(t *testing.T) {
 			exp2.cache, rcv2)
 	}
 }
+
+func TestNewLibPhoneNumberDPErr(t *testing.T) {
+
+	number := "badNum"
+
+	if _, err := newLibPhoneNumberDP(number); err != phonenumbers.ErrNotANumber {
+
+		t.Error(err)
+	}
+}
+
+func TestNewLibPhoneNumberDP(t *testing.T) {
+
+	number := "+355123456789"
+
+	num, err := phonenumbers.ParseAndKeepRawInput(number, utils.EmptyString)
+	if err != nil {
+		t.Error(err)
+	}
+	exp := utils.DataProvider(&libphonenumberDP{pNumber: num, cache: make(utils.MapStorage)})
+
+	if err != nil {
+		t.Error(err)
+	}
+	if rcv, err := newLibPhoneNumberDP(number); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("Expected \n<%+v>, Received \n<%+v>", exp, rcv)
+	}
+
+}
+
+func TestFieldAsInterfacelibphonenumberDP(t *testing.T) {
+
+	dDP := &libphonenumberDP{
+		pNumber: &phonenumbers.PhoneNumber{},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+	}
+
+	expErr := `invalid field path <[fld1 fld2 fld3]> for libphonenumberDP`
+	if _, err := dDP.FieldAsInterface([]string{"fld1", "fld2", "fld3"}); err.Error() != expErr {
+		t.Error(err)
+	}
+}
+
+// unfinished do with buffer
+func TestLibphonenumberDPfieldAsInterfaceGeoLocationErr(t *testing.T) {
+
+	dDP := &libphonenumberDP{
+		pNumber: &phonenumbers.PhoneNumber{},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+	}
+
+	if rcv, err := dDP.fieldAsInterface([]string{"GeoLocation"}); err != nil {
+		t.Error(rcv, err)
+	}
+}
+
+// unfinished do with buffer
+func TestLibphonenumberDPfieldAsInterfaceCarrierErr(t *testing.T) {
+	var pInt int32 = 49444444
+	var nNum uint64 = 49233333333333
+	dDP := &libphonenumberDP{
+		pNumber: &phonenumbers.PhoneNumber{
+			CountryCode:    &pInt,
+			NationalNumber: &nNum,
+		},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+	}
+
+	if rcv, err := dDP.fieldAsInterface([]string{"Carrier"}); err != nil {
+		t.Error(rcv, err)
+	}
+}
+
+func TestLibphonenumberDPfieldAsInterface(t *testing.T) {
+
+	var pInt int32 = 49
+	var nNum uint64 = 49
+	var leadingZeros int32 = 0
+
+	dDP := &libphonenumberDP{
+		pNumber: &phonenumbers.PhoneNumber{
+			CountryCode:                  &pInt,
+			NationalNumber:               &nNum,
+			Extension:                    utils.StringPointer("+"),
+			RawInput:                     utils.StringPointer("+4917642092123"),
+			ItalianLeadingZero:           utils.BoolPointer(true),
+			NumberOfLeadingZeros:         &leadingZeros,
+			CountryCodeSource:            phonenumbers.PhoneNumber_FROM_DEFAULT_COUNTRY.Enum(),
+			PreferredDomesticCarrierCode: utils.StringPointer("262 02"),
+		},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+	}
+
+	exp := interface{}(pInt)
+	if rcv, err := dDP.fieldAsInterface([]string{"CountryCode"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+
+	exp = interface{}(nNum)
+	if rcv, err := dDP.fieldAsInterface([]string{"NationalNumber"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+
+	exp = interface{}("DE")
+	if rcv, err := dDP.fieldAsInterface([]string{"Region"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}(phonenumbers.PhoneNumberType(11))
+	if rcv, err := dDP.fieldAsInterface([]string{"NumberType"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v><%t>", exp, rcv, rcv)
+	}
+
+	exp = interface{}("Deutschland")
+	if rcv, err := dDP.fieldAsInterface([]string{"GeoLocation"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	// exp = interface{}(nNum)
+	// if rcv, err := dDP.fieldAsInterface([]string{"Carrier"}); err != nil {
+	// 	t.Error(err)
+	// } else if rcv != exp {
+	// 	t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	// }
+	exp = interface{}(0)
+	if rcv, err := dDP.fieldAsInterface([]string{"LengthOfNationalDestinationCode"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}("+4917642092123")
+	if rcv, err := dDP.fieldAsInterface([]string{"RawInput"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}("+")
+	if rcv, err := dDP.fieldAsInterface([]string{"Extension"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}(leadingZeros)
+	if rcv, err := dDP.fieldAsInterface([]string{"NumberOfLeadingZeros"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}(true)
+	if rcv, err := dDP.fieldAsInterface([]string{"ItalianLeadingZero"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}("262 02")
+	if rcv, err := dDP.fieldAsInterface([]string{"PreferredDomesticCarrierCode"}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+	exp = interface{}(phonenumbers.PhoneNumber_FROM_DEFAULT_COUNTRY)
+	if rcv, err := dDP.fieldAsInterface([]string{"CountryCodeSource"}); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
+	}
+
+}
+
+func TestDynamicDPfieldAsInterfaceMetaLibPhoneNumber(t *testing.T) {
+
+	dDP := &dynamicDP{
+		resConns:  []string{"conn1"},
+		stsConns:  []string{"conn2"},
+		actsConns: []string{"conn3"},
+		tenant:    "cgrates.org",
+		initialDP: utils.StringSet{
+			"test": struct{}{},
+		},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+		ctx: context.Background(),
+	}
+
+	dp, _ := newLibPhoneNumberDP("+4917642092123")
+	expAsField, _ := dp.FieldAsInterface([]string{})
+	exp := interface{}(expAsField)
+	if rcv, err := dDP.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "+4917642092123"}); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("Expected \n<%v>, Received \n<%v>", exp, rcv)
+	}
+}
+
+func TestDynamicDPfieldAsInterfaceMetaLibPhoneNumberErr(t *testing.T) {
+
+	dDP := &dynamicDP{
+		resConns:  []string{"conn1"},
+		stsConns:  []string{"conn2"},
+		actsConns: []string{"conn3"},
+		tenant:    "cgrates.org",
+		initialDP: utils.StringSet{
+			"test": struct{}{},
+		},
+		cache: utils.MapStorage{
+			"testField": "testValue",
+		},
+		ctx: context.Background(),
+	}
+
+	if _, err := dDP.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "inexistentNum"}); err != phonenumbers.ErrNotANumber {
+		t.Error(err)
+	}
+}
+
+// func TestDynamicDPfieldAsInterfaceNotFound(t *testing.T) {
+// 	Cache.Clear(nil)
+
+// 	ms := utils.MapStorage{}
+// 	dDp := newDynamicDP(context.Background(), []string{}, []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}, []string{}, "cgrates.org", ms)
+// 	exp := ""
+// 	if rcv, err := dDp.fieldAsInterface([]string{utils.MetaStats, "val", "val3"}); err == nil || err != utils.ErrNotFound {
+// 		t.Error(err)
+// 	} else if !reflect.DeepEqual(rcv, exp) {
+// 		t.Errorf("Expected \n<%v>, Received \n<%v>", exp, rcv)
+// 	}
+// }
diff --git a/engine/filters_test.go b/engine/filters_test.go
index 82553f9bf..6e77f0ae7 100644
--- a/engine/filters_test.go
+++ b/engine/filters_test.go
@@ -2138,32 +2138,68 @@ func TestFilterRulePassRegexParseErrNotFound(t *testing.T) {
 			utils.MetaOriginID: "originIDUniq",
 		},
 	}
-	if ok, err := fltr.passRegex(dDP); ok != false && err != utils.ErrNotFound {
-		t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err)
+	if ok, err := fltr.passRegex(dDP); ok != false && err != nil {
+		t.Errorf("Expected error <%v>, Received error <%v>. Ok <%v>", nil, err, ok)
 	}
 }
 
-// unfinished
-// func TestFilterRulePassRegexParseErr2(t *testing.T) {
+func TestFilterRulePassRegexParseErr(t *testing.T) {
 
-// 	rsrBadParse, _ := config.NewRSRParser("~*opts.*originID<~*opts.Converter>")
+	rsrBadParse, _ := config.NewRSRParser("~*opts.*originID<~*opts.Converter>")
 
-// 	fltr := &FilterRule{
-// 		Type:       utils.EmptyString,
-// 		Element:    "~*req.Element",
-// 		Values:     []string{"value1", "value2"},
-// 		rsrElement: rsrBadParse,
-// 	}
-// 	fmt.Println(utils.ToJSON(fltr.rsrElement))
+	fltr := &FilterRule{
+		Type:       utils.EmptyString,
+		Element:    "~*req.Element",
+		Values:     []string{"value1", "value2"},
+		rsrElement: rsrBadParse,
+	}
 
-// 	dDP := utils.MapStorage{
-// 		utils.MetaReq: utils.MapStorage{},
-// 		utils.MetaOpts: utils.MapStorage{
-// 			"Converter":        "{*",
-// 			utils.MetaOriginID: "originIDUniq",
-// 		},
-// 	}
-// 	if ok, err := fltr.passRegex(dDP); ok != false && err != utils.ErrNotFound {
-// 		t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err)
-// 	}
-// }
+	dDP := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{},
+		utils.MetaOpts: utils.MapStorage{
+			"Converter":        "{*",
+			utils.MetaOriginID: "originIDUniq",
+		},
+	}
+	expErr := `invalid converter terminator in rule: <~*opts.*originID{*>`
+	if ok, err := fltr.passRegex(dDP); ok != false || err.Error() != expErr {
+		t.Errorf("Expected error <%v>, Received error <%v>. Ok <%v>", expErr, err, ok)
+	}
+}
+func TestCheckFilterErrValFuncElement(t *testing.T) {
+
+	fltr := &Filter{
+		Tenant: utils.CGRateSorg,
+		ID:     "FLTR_CP_1",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~missing path",
+				Values:  []string{"ChargerProfile1"},
+			},
+		},
+	}
+	expErr := `Path is missing  for filter <{"Tenant":"cgrates.org","ID":"FLTR_CP_1","Rules":[{"Type":"*string","Element":"~missing path","Values":["ChargerProfile1"]}]}>`
+	if err := CheckFilter(fltr); err.Error() != expErr {
+		t.Error(err)
+	}
+}
+
+func TestCheckFilterErrValFuncValues(t *testing.T) {
+
+	fltr := &Filter{
+		Tenant: utils.CGRateSorg,
+		ID:     "FLTR_CP_1",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Charger",
+				Values:  []string{"~missing path"},
+			},
+		},
+	}
+	expErr := `Path is missing  for filter <{"Tenant":"cgrates.org","ID":"FLTR_CP_1","Rules":[{"Type":"*string","Element":"~*req.Charger","Values":["~missing path"]}]}>`
+	if err := CheckFilter(fltr); err.Error() != expErr {
+		t.Error(err)
+	}
+}