lower case

Rangababu-R · Rangababu-R · commit e06a79e0b86e · 2021-12-02T14:43:52.000+05:30
diff --git a/openapiart/common.go b/openapiart/common.go
@@ -164,13 +164,13 @@ func validationResult() error {
 func validateMac(mac string) error {
 	macSlice := strings.Split(mac, ":")
 	if len(macSlice) != 6 {
-		return fmt.Errorf(fmt.Sprintf("Invalid Mac address %s", mac))
+		return fmt.Errorf(fmt.Sprintf("invalid mac address %s", mac))
 	}
 	octInd := []string{"0th", "1st", "2nd", "3rd", "4th", "5th"}
 	for ind, val := range macSlice {
 		num, err := strconv.ParseUint(val, 16, 32)
 		if err != nil || num > 255 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Mac address at %s octet in %s mac", octInd[ind], mac))
+			return fmt.Errorf(fmt.Sprintf("invalid mac address at %s octet in %s mac", octInd[ind], mac))
 		}
 	}
 	return nil
@@ -179,13 +179,13 @@ func validateMac(mac string) error {
 func validateIpv4(ip string) error {
 	ipSlice := strings.Split(ip, ".")
 	if len(ipSlice) != 4 {
-		return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv4 address %s", ip))
 	}
 	octInd := []string{"1st", "2nd", "3rd", "4th"}
 	for ind, val := range ipSlice {
 		num, err := strconv.ParseUint(val, 10, 32)
 		if err != nil || num > 255 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address at %s octet in %s ipv4", octInd[ind], ip))
+			return fmt.Errorf(fmt.Sprintf("invalid ipv4 address at %s octet in %s ipv4", octInd[ind], ip))
 		}
 	}
 	return nil
@@ -196,13 +196,13 @@ func validateIpv6(ip string) error {
 	if strings.Count(ip, " ") > 0 || strings.Count(ip, ":") > 7 ||
 		strings.Count(ip, "::") > 1 || strings.Count(ip, ":::") > 0 ||
 		strings.Count(ip, ":") == 0 {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if (string(ip[0]) == ":" && string(ip[:2]) != "::") || (string(ip[len(ip)-1]) == ":" && string(ip[len(ip)-2:]) != "::") {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if strings.Count(ip, "::") == 0 && strings.Count(ip, ":") != 7 {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if ip == "::" {
 		return nil
@@ -224,7 +224,7 @@ func validateIpv6(ip string) error {
 	for ind, val := range ipSlice {
 		num, err := strconv.ParseUint(val, 16, 64)
 		if err != nil || num > 65535 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Ipv6 address at %s octet in %s ipv6", octInd[ind], ip))
+			return fmt.Errorf(fmt.Sprintf("invalid ipv6 address at %s octet in %s ipv6", octInd[ind], ip))
 		}
 	}
 
@@ -234,7 +234,7 @@ func validateIpv6(ip string) error {
 func validateHex(hex string) error {
 	matched, err := regexp.MatchString(`^[0-9a-fA-F]+$|^0[x|X][0-9a-fA-F]+$`, hex)
 	if err != nil || !matched {
-		return fmt.Errorf(fmt.Sprintf("Invalid hex value %s", hex))
+		return fmt.Errorf(fmt.Sprintf("invalid hex value %s", hex))
 	}
 	return nil
 }
@@ -253,7 +253,7 @@ func validateSlice(valSlice []string, sliceType string) error {
 		} else if sliceType == "hex" {
 			err = validateHex(val)
 		} else {
-			return fmt.Errorf(fmt.Sprintf("Invalid slice type received <%s>", sliceType))
+			return fmt.Errorf(fmt.Sprintf("invalid slice type received <%s>", sliceType))
 		}
 
 		if err != nil {
@@ -262,7 +262,7 @@ func validateSlice(valSlice []string, sliceType string) error {
 	}
 	if len(indices) > 0 {
 		return fmt.Errorf(
-			fmt.Sprintf("Invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),
+			fmt.Sprintf("invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),
 		)
 	}
 	return nil
diff --git a/pkg/common.go b/pkg/common.go
@@ -166,13 +166,13 @@ func validationResult() error {
 func validateMac(mac string) error {
 	macSlice := strings.Split(mac, ":")
 	if len(macSlice) != 6 {
-		return fmt.Errorf(fmt.Sprintf("Invalid Mac address %s", mac))
+		return fmt.Errorf(fmt.Sprintf("invalid mac address %s", mac))
 	}
 	octInd := []string{"0th", "1st", "2nd", "3rd", "4th", "5th"}
 	for ind, val := range macSlice {
 		num, err := strconv.ParseUint(val, 16, 32)
 		if err != nil || num > 255 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Mac address at %s octet in %s mac", octInd[ind], mac))
+			return fmt.Errorf(fmt.Sprintf("invalid mac address at %s octet in %s mac", octInd[ind], mac))
 		}
 	}
 	return nil
@@ -181,13 +181,13 @@ func validateMac(mac string) error {
 func validateIpv4(ip string) error {
 	ipSlice := strings.Split(ip, ".")
 	if len(ipSlice) != 4 {
-		return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv4 address %s", ip))
 	}
 	octInd := []string{"1st", "2nd", "3rd", "4th"}
 	for ind, val := range ipSlice {
 		num, err := strconv.ParseUint(val, 10, 32)
 		if err != nil || num > 255 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address at %s octet in %s ipv4", octInd[ind], ip))
+			return fmt.Errorf(fmt.Sprintf("invalid ipv4 address at %s octet in %s ipv4", octInd[ind], ip))
 		}
 	}
 	return nil
@@ -198,13 +198,13 @@ func validateIpv6(ip string) error {
 	if strings.Count(ip, " ") > 0 || strings.Count(ip, ":") > 7 ||
 		strings.Count(ip, "::") > 1 || strings.Count(ip, ":::") > 0 ||
 		strings.Count(ip, ":") == 0 {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if (string(ip[0]) == ":" && string(ip[:2]) != "::") || (string(ip[len(ip)-1]) == ":" && string(ip[len(ip)-2:]) != "::") {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if strings.Count(ip, "::") == 0 && strings.Count(ip, ":") != 7 {
-		return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))
+		return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))
 	}
 	if ip == "::" {
 		return nil
@@ -226,7 +226,7 @@ func validateIpv6(ip string) error {
 	for ind, val := range ipSlice {
 		num, err := strconv.ParseUint(val, 16, 64)
 		if err != nil || num > 65535 {
-			return fmt.Errorf(fmt.Sprintf("Invalid Ipv6 address at %s octet in %s ipv6", octInd[ind], ip))
+			return fmt.Errorf(fmt.Sprintf("invalid ipv6 address at %s octet in %s ipv6", octInd[ind], ip))
 		}
 	}
 
@@ -236,7 +236,7 @@ func validateIpv6(ip string) error {
 func validateHex(hex string) error {
 	matched, err := regexp.MatchString(`^[0-9a-fA-F]+$|^0[x|X][0-9a-fA-F]+$`, hex)
 	if err != nil || !matched {
-		return fmt.Errorf(fmt.Sprintf("Invalid hex value %s", hex))
+		return fmt.Errorf(fmt.Sprintf("invalid hex value %s", hex))
 	}
 	return nil
 }
@@ -255,7 +255,7 @@ func validateSlice(valSlice []string, sliceType string) error {
 		} else if sliceType == "hex" {
 			err = validateHex(val)
 		} else {
-			return fmt.Errorf(fmt.Sprintf("Invalid slice type received <%s>", sliceType))
+			return fmt.Errorf(fmt.Sprintf("invalid slice type received <%s>", sliceType))
 		}
 
 		if err != nil {
@@ -264,7 +264,7 @@ func validateSlice(valSlice []string, sliceType string) error {
 	}
 	if len(indices) > 0 {
 		return fmt.Errorf(
-			fmt.Sprintf("Invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),
+			fmt.Sprintf("invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),
 		)
 	}
 	return nil
diff --git a/pkg/unit_test.go b/pkg/unit_test.go
@@ -350,7 +350,7 @@ func TestBadMacValidation(t *testing.T) {
 		macObj := config.MacPattern().Mac().SetValue(mac)
 		err := macObj.Validate()
 		if assert.Error(t, err) {
-			assert.Contains(t, err.Error(), "Invalid Mac")
+			assert.Contains(t, err.Error(), "invalid mac")
 		}
 	}
 }
@@ -418,7 +418,7 @@ func TestBadIpv4Validation(t *testing.T) {
 		ipv4 := config.Ipv4Pattern().Ipv4().SetValue(ip)
 		err := ipv4.Validate()
 		if assert.Error(t, err) {
-			assert.Contains(t, err.Error(), "Invalid Ipv4")
+			assert.Contains(t, err.Error(), "invalid ipv4")
 		}
 	}
 }
@@ -429,7 +429,7 @@ func TestBadIpv4Values(t *testing.T) {
 	ipv4 := config.Ipv4Pattern().Ipv4().SetValues(BadIpv4)
 	err := ipv4.Validate()
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "Invalid ipv4 addresses")
+		assert.Contains(t, err.Error(), "invalid ipv4 addresses")
 	}
 }
 
@@ -441,7 +441,7 @@ func TestBadIpv4Increment(t *testing.T) {
 	ipv4.SetCount(10)
 	err := ipv4.Validate()
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "Invalid Ipv4")
+		assert.Contains(t, err.Error(), "invalid ipv4")
 	}
 }
 
@@ -453,7 +453,7 @@ func TestBadIpv4Decrement(t *testing.T) {
 	ipv4.SetCount(10)
 	err := ipv4.Validate()
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "Invalid Ipv4")
+		assert.Contains(t, err.Error(), "invalid ipv4")
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -164,13 +164,13 @@ func validationResult() error {`
`164`	`164`	`func validateMac(mac string) error {`
`165`	`165`	`macSlice := strings.Split(mac, ":")`
`166`	`166`	`if len(macSlice) != 6 {`
`167`		`- return fmt.Errorf(fmt.Sprintf("Invalid Mac address %s", mac))`
	`167`	`+ return fmt.Errorf(fmt.Sprintf("invalid mac address %s", mac))`
`168`	`168`	`}`
`169`	`169`	`octInd := []string{"0th", "1st", "2nd", "3rd", "4th", "5th"}`
`170`	`170`	`for ind, val := range macSlice {`
`171`	`171`	`num, err := strconv.ParseUint(val, 16, 32)`
`172`	`172`	`if err != nil \|\| num > 255 {`
`173`		`- return fmt.Errorf(fmt.Sprintf("Invalid Mac address at %s octet in %s mac", octInd[ind], mac))`
	`173`	`+ return fmt.Errorf(fmt.Sprintf("invalid mac address at %s octet in %s mac", octInd[ind], mac))`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`	`return nil`
`@@ -179,13 +179,13 @@ func validateMac(mac string) error {`
`179`	`179`	`func validateIpv4(ip string) error {`
`180`	`180`	`ipSlice := strings.Split(ip, ".")`
`181`	`181`	`if len(ipSlice) != 4 {`
`182`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address %s", ip))`
	`182`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv4 address %s", ip))`
`183`	`183`	`}`
`184`	`184`	`octInd := []string{"1st", "2nd", "3rd", "4th"}`
`185`	`185`	`for ind, val := range ipSlice {`
`186`	`186`	`num, err := strconv.ParseUint(val, 10, 32)`
`187`	`187`	`if err != nil \|\| num > 255 {`
`188`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address at %s octet in %s ipv4", octInd[ind], ip))`
	`188`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv4 address at %s octet in %s ipv4", octInd[ind], ip))`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`	`return nil`
`@@ -196,13 +196,13 @@ func validateIpv6(ip string) error {`
`196`	`196`	`if strings.Count(ip, " ") > 0 \|\| strings.Count(ip, ":") > 7 \|\|`
`197`	`197`	`strings.Count(ip, "::") > 1 \|\| strings.Count(ip, ":::") > 0 \|\|`
`198`	`198`	`strings.Count(ip, ":") == 0 {`
`199`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`199`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`200`	`200`	`}`
`201`	`201`	`if (string(ip[0]) == ":" && string(ip[:2]) != "::") \|\| (string(ip[len(ip)-1]) == ":" && string(ip[len(ip)-2:]) != "::") {`
`202`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`202`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`203`	`203`	`}`
`204`	`204`	`if strings.Count(ip, "::") == 0 && strings.Count(ip, ":") != 7 {`
`205`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`205`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`206`	`206`	`}`
`207`	`207`	`if ip == "::" {`
`208`	`208`	`return nil`
`@@ -224,7 +224,7 @@ func validateIpv6(ip string) error {`
`224`	`224`	`for ind, val := range ipSlice {`
`225`	`225`	`num, err := strconv.ParseUint(val, 16, 64)`
`226`	`226`	`if err != nil \|\| num > 65535 {`
`227`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv6 address at %s octet in %s ipv6", octInd[ind], ip))`
	`227`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address at %s octet in %s ipv6", octInd[ind], ip))`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`
`@@ -234,7 +234,7 @@ func validateIpv6(ip string) error {`
`234`	`234`	`func validateHex(hex string) error {`
`235`	`235`	matched, err := regexp.MatchString(`^[0-9a-fA-F]+$\|^0[x\|X][0-9a-fA-F]+$`, hex)
`236`	`236`	`if err != nil \|\| !matched {`
`237`		`- return fmt.Errorf(fmt.Sprintf("Invalid hex value %s", hex))`
	`237`	`+ return fmt.Errorf(fmt.Sprintf("invalid hex value %s", hex))`
`238`	`238`	`}`
`239`	`239`	`return nil`
`240`	`240`	`}`
`@@ -253,7 +253,7 @@ func validateSlice(valSlice []string, sliceType string) error {`
`253`	`253`	`} else if sliceType == "hex" {`
`254`	`254`	`err = validateHex(val)`
`255`	`255`	`} else {`
`256`		`- return fmt.Errorf(fmt.Sprintf("Invalid slice type received <%s>", sliceType))`
	`256`	`+ return fmt.Errorf(fmt.Sprintf("invalid slice type received <%s>", sliceType))`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`if err != nil {`
`@@ -262,7 +262,7 @@ func validateSlice(valSlice []string, sliceType string) error {`
`262`	`262`	`}`
`263`	`263`	`if len(indices) > 0 {`
`264`	`264`	`return fmt.Errorf(`
`265`		`- fmt.Sprintf("Invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),`
	`265`	`+ fmt.Sprintf("invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),`
`266`	`266`	`)`
`267`	`267`	`}`
`268`	`268`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -166,13 +166,13 @@ func validationResult() error {`
`166`	`166`	`func validateMac(mac string) error {`
`167`	`167`	`macSlice := strings.Split(mac, ":")`
`168`	`168`	`if len(macSlice) != 6 {`
`169`		`- return fmt.Errorf(fmt.Sprintf("Invalid Mac address %s", mac))`
	`169`	`+ return fmt.Errorf(fmt.Sprintf("invalid mac address %s", mac))`
`170`	`170`	`}`
`171`	`171`	`octInd := []string{"0th", "1st", "2nd", "3rd", "4th", "5th"}`
`172`	`172`	`for ind, val := range macSlice {`
`173`	`173`	`num, err := strconv.ParseUint(val, 16, 32)`
`174`	`174`	`if err != nil \|\| num > 255 {`
`175`		`- return fmt.Errorf(fmt.Sprintf("Invalid Mac address at %s octet in %s mac", octInd[ind], mac))`
	`175`	`+ return fmt.Errorf(fmt.Sprintf("invalid mac address at %s octet in %s mac", octInd[ind], mac))`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`	`return nil`
`@@ -181,13 +181,13 @@ func validateMac(mac string) error {`
`181`	`181`	`func validateIpv4(ip string) error {`
`182`	`182`	`ipSlice := strings.Split(ip, ".")`
`183`	`183`	`if len(ipSlice) != 4 {`
`184`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address %s", ip))`
	`184`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv4 address %s", ip))`
`185`	`185`	`}`
`186`	`186`	`octInd := []string{"1st", "2nd", "3rd", "4th"}`
`187`	`187`	`for ind, val := range ipSlice {`
`188`	`188`	`num, err := strconv.ParseUint(val, 10, 32)`
`189`	`189`	`if err != nil \|\| num > 255 {`
`190`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv4 address at %s octet in %s ipv4", octInd[ind], ip))`
	`190`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv4 address at %s octet in %s ipv4", octInd[ind], ip))`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`	`return nil`
`@@ -198,13 +198,13 @@ func validateIpv6(ip string) error {`
`198`	`198`	`if strings.Count(ip, " ") > 0 \|\| strings.Count(ip, ":") > 7 \|\|`
`199`	`199`	`strings.Count(ip, "::") > 1 \|\| strings.Count(ip, ":::") > 0 \|\|`
`200`	`200`	`strings.Count(ip, ":") == 0 {`
`201`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`201`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`202`	`202`	`}`
`203`	`203`	`if (string(ip[0]) == ":" && string(ip[:2]) != "::") \|\| (string(ip[len(ip)-1]) == ":" && string(ip[len(ip)-2:]) != "::") {`
`204`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`204`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`205`	`205`	`}`
`206`	`206`	`if strings.Count(ip, "::") == 0 && strings.Count(ip, ":") != 7 {`
`207`		`- return fmt.Errorf(fmt.Sprintf("Invalid ipv6 address %s", ip))`
	`207`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address %s", ip))`
`208`	`208`	`}`
`209`	`209`	`if ip == "::" {`
`210`	`210`	`return nil`
`@@ -226,7 +226,7 @@ func validateIpv6(ip string) error {`
`226`	`226`	`for ind, val := range ipSlice {`
`227`	`227`	`num, err := strconv.ParseUint(val, 16, 64)`
`228`	`228`	`if err != nil \|\| num > 65535 {`
`229`		`- return fmt.Errorf(fmt.Sprintf("Invalid Ipv6 address at %s octet in %s ipv6", octInd[ind], ip))`
	`229`	`+ return fmt.Errorf(fmt.Sprintf("invalid ipv6 address at %s octet in %s ipv6", octInd[ind], ip))`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`@@ -236,7 +236,7 @@ func validateIpv6(ip string) error {`
`236`	`236`	`func validateHex(hex string) error {`
`237`	`237`	matched, err := regexp.MatchString(`^[0-9a-fA-F]+$\|^0[x\|X][0-9a-fA-F]+$`, hex)
`238`	`238`	`if err != nil \|\| !matched {`
`239`		`- return fmt.Errorf(fmt.Sprintf("Invalid hex value %s", hex))`
	`239`	`+ return fmt.Errorf(fmt.Sprintf("invalid hex value %s", hex))`
`240`	`240`	`}`
`241`	`241`	`return nil`
`242`	`242`	`}`
`@@ -255,7 +255,7 @@ func validateSlice(valSlice []string, sliceType string) error {`
`255`	`255`	`} else if sliceType == "hex" {`
`256`	`256`	`err = validateHex(val)`
`257`	`257`	`} else {`
`258`		`- return fmt.Errorf(fmt.Sprintf("Invalid slice type received <%s>", sliceType))`
	`258`	`+ return fmt.Errorf(fmt.Sprintf("invalid slice type received <%s>", sliceType))`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`if err != nil {`
`@@ -264,7 +264,7 @@ func validateSlice(valSlice []string, sliceType string) error {`
`264`	`264`	`}`
`265`	`265`	`if len(indices) > 0 {`
`266`	`266`	`return fmt.Errorf(`
`267`		`- fmt.Sprintf("Invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),`
	`267`	`+ fmt.Sprintf("invalid %s addresses at indices %s", sliceType, strings.Join(indices, ",")),`
`268`	`268`	`)`
`269`	`269`	`}`
`270`	`270`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ func TestBadMacValidation(t *testing.T) {`
`350`	`350`	`macObj := config.MacPattern().Mac().SetValue(mac)`
`351`	`351`	`err := macObj.Validate()`
`352`	`352`	`if assert.Error(t, err) {`
`353`		`- assert.Contains(t, err.Error(), "Invalid Mac")`
	`353`	`+ assert.Contains(t, err.Error(), "invalid mac")`
`354`	`354`	`}`
`355`	`355`	`}`
`356`	`356`	`}`
`@@ -418,7 +418,7 @@ func TestBadIpv4Validation(t *testing.T) {`
`418`	`418`	`ipv4 := config.Ipv4Pattern().Ipv4().SetValue(ip)`
`419`	`419`	`err := ipv4.Validate()`
`420`	`420`	`if assert.Error(t, err) {`
`421`		`- assert.Contains(t, err.Error(), "Invalid Ipv4")`
	`421`	`+ assert.Contains(t, err.Error(), "invalid ipv4")`
`422`	`422`	`}`
`423`	`423`	`}`
`424`	`424`	`}`
`@@ -429,7 +429,7 @@ func TestBadIpv4Values(t *testing.T) {`
`429`	`429`	`ipv4 := config.Ipv4Pattern().Ipv4().SetValues(BadIpv4)`
`430`	`430`	`err := ipv4.Validate()`
`431`	`431`	`if assert.Error(t, err) {`
`432`		`- assert.Contains(t, err.Error(), "Invalid ipv4 addresses")`
	`432`	`+ assert.Contains(t, err.Error(), "invalid ipv4 addresses")`
`433`	`433`	`}`
`434`	`434`	`}`
`435`	`435`
`@@ -441,7 +441,7 @@ func TestBadIpv4Increment(t *testing.T) {`
`441`	`441`	`ipv4.SetCount(10)`
`442`	`442`	`err := ipv4.Validate()`
`443`	`443`	`if assert.Error(t, err) {`
`444`		`- assert.Contains(t, err.Error(), "Invalid Ipv4")`
	`444`	`+ assert.Contains(t, err.Error(), "invalid ipv4")`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
`@@ -453,7 +453,7 @@ func TestBadIpv4Decrement(t *testing.T) {`
`453`	`453`	`ipv4.SetCount(10)`
`454`	`454`	`err := ipv4.Validate()`
`455`	`455`	`if assert.Error(t, err) {`
`456`		`- assert.Contains(t, err.Error(), "Invalid Ipv4")`
	`456`	`+ assert.Contains(t, err.Error(), "invalid ipv4")`
`457`	`457`	`}`
`458`	`458`	`}`
`459`	`459`