Standardized error messages across iso8583 prefixers (#343)

Stashchenko · web-flow · commit 8fc6f5d5658e · 2025-01-27T16:14:05.000+01:00
diff --git a/describe.go b/describe.go
@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
+	"strconv"
 	"strings"
 	"text/tabwriter"
 
@@ -36,7 +37,7 @@ func (m *MessageWrapper) GetSubfields() map[string]field.Field {
 	fields := m.Message.GetFields()
 	result := make(map[string]field.Field, len(fields))
 	for k, v := range fields {
-		result[fmt.Sprintf("%d", k)] = v
+		result[strconv.Itoa(k)] = v
 	}
 	return result
 }
diff --git a/field_filter.go b/field_filter.go
@@ -1,7 +1,7 @@
 package iso8583
 
 import (
-	"fmt"
+	"errors"
 	"unicode/utf8"
 
 	"github.com/moov-io/iso8583/field"
@@ -19,6 +19,8 @@ const (
 	panPattern    = "****"
 )
 
+var ErrCreatingNewTrackData = errors.New("creating new track data")
+
 type FilterFunc func(in string, data field.Field) string
 
 type FieldFilter func(fieldFilters map[string]FilterFunc)
@@ -109,7 +111,7 @@ func newTrackData(data, track field.Field) error {
 	if raw, err := data.Pack(); err == nil {
 		track.SetSpec(data.Spec())
 		if _, err := track.Unpack(raw); err != nil {
-			return fmt.Errorf("creating new track data")
+			return ErrCreatingNewTrackData
 		}
 	}
 
diff --git a/message.go b/message.go
@@ -318,7 +318,7 @@ func (m *Message) MarshalJSON() ([]byte, error) {
 	fieldMap := m.getFields()
 	strFieldMap := map[string]field.Field{}
 	for id, field := range fieldMap {
-		strFieldMap[fmt.Sprint(id)] = field
+		strFieldMap[strconv.Itoa(id)] = field
 	}
 
 	// get only fields that were set
diff --git a/message_spec_test.go b/message_spec_test.go
@@ -30,8 +30,8 @@ func TestMessageSpec_CreateMessageFields(t *testing.T) {
 	fields := spec.CreateMessageFields()
 
 	// test that derived fields have the same type as in the message spec
-	require.True(t, reflect.TypeOf(fields[0]).Elem() == reflect.TypeOf(field.String{}))
-	require.True(t, reflect.TypeOf(fields[1]).Elem() == reflect.TypeOf(field.Bitmap{}))
+	require.Equal(t, reflect.TypeOf(field.String{}), reflect.TypeOf(fields[0]).Elem())
+	require.Equal(t, reflect.TypeOf(field.Bitmap{}), reflect.TypeOf(fields[1]).Elem())
 
 	// test that derived field have the same spec
 	require.Equal(t, fields[0].Spec(), spec.Fields[0].Spec())
diff --git a/message_test.go b/message_test.go
@@ -903,7 +903,7 @@ func TestPackUnpack(t *testing.T) {
 		require.Error(t, err)
 		var unpackError *iso8583errors.UnpackError
 		require.ErrorAs(t, err, &unpackError)
-		assert.Equal(t, unpackError.FieldID, "120")
+		assert.Equal(t, "120", unpackError.FieldID)
 
 		s, err := message.GetString(2)
 		require.NoError(t, err)
diff --git a/prefix/ascii.go b/prefix/ascii.go
@@ -22,11 +22,11 @@ var ASCII = Prefixers{
 
 func (p *asciiVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	if dataLen > maxLen {
-		return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	if len(strconv.Itoa(dataLen)) > p.Digits {
-		return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)
+		return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)
 	}
 
 	res := fmt.Sprintf("%0*d", p.Digits, dataLen)
@@ -36,7 +36,7 @@ func (p *asciiVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 
 func (p *asciiVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {
 	if len(data) < p.Digits {
-		return 0, 0, fmt.Errorf("not enough data length: %d to read: %d byte digits", len(data), p.Digits)
+		return 0, 0, fmt.Errorf(notEnoughDataToRead, len(data), p.Digits)
 	}
 
 	dataLen, err := strconv.Atoi(string(data[:p.Digits]))
@@ -46,11 +46,11 @@ func (p *asciiVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, erro
 
 	// length should be positive
 	if dataLen < 0 {
-		return 0, 0, fmt.Errorf("invalid length: %d", dataLen)
+		return 0, 0, fmt.Errorf(invalidLength, dataLen)
 	}
 
 	if dataLen > maxLen {
-		return 0, 0, fmt.Errorf("data length: %d is larger than maximum %d", dataLen, maxLen)
+		return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, p.Digits, nil
@@ -65,7 +65,7 @@ type asciiFixedPrefixer struct {
 
 func (p *asciiFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {
 	if dataLen != fixLen {
-		return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)
+		return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)
 	}
 
 	return []byte{}, nil
diff --git a/prefix/bcd.go b/prefix/bcd.go
@@ -25,11 +25,11 @@ var BCD = Prefixers{
 
 func (p *bcdVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	if dataLen > maxLen {
-		return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	if len(strconv.Itoa(dataLen)) > p.Digits {
-		return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)
+		return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)
 	}
 
 	strLen := fmt.Sprintf("%0*d", p.Digits, dataLen)
@@ -44,7 +44,7 @@ func (p *bcdVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 func (p *bcdVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {
 	length := bcd.EncodedLen(p.Digits)
 	if len(data) < length {
-		return 0, 0, fmt.Errorf("length mismatch: want to read %d bytes, get only %d", length, len(data))
+		return 0, 0, fmt.Errorf(notEnoughDataToRead, length, len(data))
 	}
 
 	bDigits, _, err := encoding.BCD.Decode(data[:length], p.Digits)
@@ -58,7 +58,7 @@ func (p *bcdVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error)
 	}
 
 	if dataLen > maxLen {
-		return 0, 0, fmt.Errorf("data length %d is larger than maximum %d", dataLen, maxLen)
+		return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, length, nil
@@ -73,7 +73,7 @@ type bcdFixedPrefixer struct {
 
 func (p *bcdFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {
 	if dataLen != fixLen {
-		return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)
+		return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)
 	}
 
 	return []byte{}, nil
diff --git a/prefix/bcd_test.go b/prefix/bcd_test.go
@@ -21,7 +21,7 @@ func TestBCDVarPrefixer_EncodeLengthMaxLengthValidation(t *testing.T) {
 func TestBCDVarPrefixer_DecodeLengthMaxLengthValidation(t *testing.T) {
 	_, _, err := BCD.LLL.DecodeLength(20, []byte{0x22})
 
-	require.Contains(t, err.Error(), "length mismatch: want to read 2 bytes, get only 1")
+	require.Contains(t, err.Error(), "not enough data length: 2 to read: 1 byte digits")
 }
 
 func TestBCDVarPrefixer_LHelpers(t *testing.T) {
diff --git a/prefix/bertlv.go b/prefix/bertlv.go
@@ -36,7 +36,7 @@ func (p *berTLVPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	// checking maxLen for a 0 is a way to disable check and also support
 	// backwards compatibility with the old contract that didn't have maxLen
 	if maxLen != 0 && dataLen > maxLen {
-		return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	buf := big.NewInt(int64(dataLen)).Bytes()
@@ -67,7 +67,7 @@ func (p *berTLVPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error)
 		// checking maxLen for a 0 is a way to disable check and also support
 		// backwards compatibility with the old contract that didn't have maxLen
 		if maxLen != 0 && dataLen > maxLen {
-			return 0, read, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+			return 0, read, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 		}
 
 		return dataLen, read, nil
@@ -85,7 +85,7 @@ func (p *berTLVPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error)
 	// checking maxLen for a 0 is a way to disable check and also support
 	// backwards compatibility with the old contract that didn't have maxLen
 	if maxLen != 0 && dataLen > maxLen {
-		return 0, read, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return 0, read, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, read, nil
diff --git a/prefix/binary.go b/prefix/binary.go
@@ -22,7 +22,7 @@ type binaryFixedPrefixer struct {
 
 func (p *binaryFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {
 	if dataLen != fixLen {
-		return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)
+		return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)
 	}
 
 	return []byte{}, nil
@@ -64,7 +64,7 @@ func bytesToInt(b []byte) (int, error) {
 
 func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	if dataLen > maxLen {
-		return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	res, err := intToBytes(dataLen)
@@ -76,7 +76,7 @@ func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	res = bytes.TrimLeft(res, "\x00")
 
 	if len(res) > p.Digits {
-		return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)
+		return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)
 	}
 
 	// if len of res is less than p.Digits prepend with 0x00
@@ -92,7 +92,7 @@ func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 // and the number of bytes read.
 func (p *binaryVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {
 	if len(data) < p.Digits {
-		return 0, 0, fmt.Errorf("not enough data length: %d to read: %d bytes", len(data), p.Digits)
+		return 0, 0, fmt.Errorf(notEnoughDataToRead, len(data), p.Digits)
 	}
 
 	prefBytes := data[:p.Digits]
@@ -111,7 +111,7 @@ func (p *binaryVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, err
 	}
 
 	if dataLen > maxLen {
-		return 0, 0, fmt.Errorf("data length: %d is larger than maximum %d", dataLen, maxLen)
+		return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, p.Digits, nil
diff --git a/prefix/ebcdic.go b/prefix/ebcdic.go
@@ -24,11 +24,11 @@ var EBCDIC = Prefixers{
 
 func (p *ebcdicVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	if dataLen > maxLen {
-		return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	if len(strconv.Itoa(dataLen)) > p.Digits {
-		return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)
+		return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)
 	}
 
 	strLen := fmt.Sprintf("%0*d", p.Digits, dataLen)
@@ -43,7 +43,7 @@ func (p *ebcdicVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 func (p *ebcdicVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {
 	length := p.Digits
 	if len(data) < length {
-		return 0, 0, fmt.Errorf("length mismatch: want to read %d bytes, get only %d", length, len(data))
+		return 0, 0, fmt.Errorf(notEnoughDataToRead, length, len(data))
 	}
 
 	bDigits, _, err := encoding.EBCDIC.Decode(data[:length], p.Digits)
@@ -57,7 +57,7 @@ func (p *ebcdicVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, err
 	}
 
 	if dataLen > maxLen {
-		return 0, 0, fmt.Errorf("data length %d is larger than maximum %d", dataLen, maxLen)
+		return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, length, nil
@@ -72,7 +72,7 @@ type ebcdicFixedPrefixer struct {
 
 func (p *ebcdicFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {
 	if dataLen != fixLen {
-		return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)
+		return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)
 	}
 
 	return []byte{}, nil
diff --git a/prefix/ebcdic1047.go b/prefix/ebcdic1047.go
@@ -24,11 +24,11 @@ type ebcdic1047Prefixer struct {
 
 func (p *ebcdic1047Prefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 	if dataLen > maxLen {
-		return nil, fmt.Errorf("field length [%d] is larger than maximum [%d]", dataLen, maxLen)
+		return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	if len(strconv.Itoa(dataLen)) > p.digits {
-		return nil, fmt.Errorf("number of digits in data [%d] exceeds its maximum indicator [%d]", dataLen, p.digits)
+		return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.digits)
 	}
 
 	strLen := fmt.Sprintf("%0*d", p.digits, dataLen)
@@ -41,7 +41,7 @@ func (p *ebcdic1047Prefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {
 
 func (p *ebcdic1047Prefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {
 	if len(data) < p.digits {
-		return 0, 0, fmt.Errorf("not enough data length [%d] to read [%d] byte digits", len(data), p.digits)
+		return 0, 0, fmt.Errorf(notEnoughDataToRead, len(data), p.digits)
 	}
 
 	decodedData, _, err := encoding.EBCDIC1047.Decode(data[:p.digits], p.digits)
@@ -55,7 +55,7 @@ func (p *ebcdic1047Prefixer) DecodeLength(maxLen int, data []byte) (int, int, er
 	}
 
 	if dataLen > maxLen {
-		return 0, 0, fmt.Errorf("data length [%d] is larger than maximum [%d]", dataLen, maxLen)
+		return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)
 	}
 
 	return dataLen, p.digits, nil
@@ -69,7 +69,7 @@ type ebcdic1047FixedPrefixer struct{}
 
 func (p *ebcdic1047FixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {
 	if dataLen != fixLen {
-		return nil, fmt.Errorf("field length [%d] should be fixed [%d]", dataLen, fixLen)
+		return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)
 	}
 
 	return []byte{}, nil
diff --git a/prefix/ebcdic1047_test.go b/prefix/ebcdic1047_test.go
diff --git a/prefix/ebcdic_test.go b/prefix/ebcdic_test.go
diff --git a/prefix/error.go b/prefix/error.go
diff --git a/prefix/hex.go b/prefix/hex.go

Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ func (m *Message) MarshalJSON() ([]byte, error) {`
`318`	`318`	`fieldMap := m.getFields()`
`319`	`319`	`strFieldMap := map[string]field.Field{}`
`320`	`320`	`for id, field := range fieldMap {`
`321`		`- strFieldMap[fmt.Sprint(id)] = field`
	`321`	`+ strFieldMap[strconv.Itoa(id)] = field`
`322`	`322`	`}`
`323`	`323`
`324`	`324`	`// get only fields that were set`
Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,11 @@ var ASCII = Prefixers{`
`22`	`22`
`23`	`23`	`func (p *asciiVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`24`	`24`	`if dataLen > maxLen {`
`25`		`- return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)`
	`25`	`+ return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`if len(strconv.Itoa(dataLen)) > p.Digits {`
`29`		`- return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)`
	`29`	`+ return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`res := fmt.Sprintf("%0*d", p.Digits, dataLen)`
`@@ -36,7 +36,7 @@ func (p *asciiVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`36`	`36`
`37`	`37`	`func (p *asciiVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {`
`38`	`38`	`if len(data) < p.Digits {`
`39`		`- return 0, 0, fmt.Errorf("not enough data length: %d to read: %d byte digits", len(data), p.Digits)`
	`39`	`+ return 0, 0, fmt.Errorf(notEnoughDataToRead, len(data), p.Digits)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`dataLen, err := strconv.Atoi(string(data[:p.Digits]))`
`@@ -46,11 +46,11 @@ func (p *asciiVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, erro`
`46`	`46`
`47`	`47`	`// length should be positive`
`48`	`48`	`if dataLen < 0 {`
`49`		`- return 0, 0, fmt.Errorf("invalid length: %d", dataLen)`
	`49`	`+ return 0, 0, fmt.Errorf(invalidLength, dataLen)`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`if dataLen > maxLen {`
`53`		`- return 0, 0, fmt.Errorf("data length: %d is larger than maximum %d", dataLen, maxLen)`
	`53`	`+ return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`return dataLen, p.Digits, nil`
`@@ -65,7 +65,7 @@ type asciiFixedPrefixer struct {`
`65`	`65`
`66`	`66`	`func (p *asciiFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {`
`67`	`67`	`if dataLen != fixLen {`
`68`		`- return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)`
	`68`	`+ return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`return []byte{}, nil`
Original file line number	Diff line number	Diff line change
`@@ -25,11 +25,11 @@ var BCD = Prefixers{`
`25`	`25`
`26`	`26`	`func (p *bcdVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`27`	`27`	`if dataLen > maxLen {`
`28`		`- return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)`
	`28`	`+ return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`if len(strconv.Itoa(dataLen)) > p.Digits {`
`32`		`- return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)`
	`32`	`+ return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`strLen := fmt.Sprintf("%0*d", p.Digits, dataLen)`
`@@ -44,7 +44,7 @@ func (p *bcdVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`44`	`44`	`func (p *bcdVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {`
`45`	`45`	`length := bcd.EncodedLen(p.Digits)`
`46`	`46`	`if len(data) < length {`
`47`		`- return 0, 0, fmt.Errorf("length mismatch: want to read %d bytes, get only %d", length, len(data))`
	`47`	`+ return 0, 0, fmt.Errorf(notEnoughDataToRead, length, len(data))`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`bDigits, _, err := encoding.BCD.Decode(data[:length], p.Digits)`
`@@ -58,7 +58,7 @@ func (p *bcdVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`if dataLen > maxLen {`
`61`		`- return 0, 0, fmt.Errorf("data length %d is larger than maximum %d", dataLen, maxLen)`
	`61`	`+ return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`return dataLen, length, nil`
`@@ -73,7 +73,7 @@ type bcdFixedPrefixer struct {`
`73`	`73`
`74`	`74`	`func (p *bcdFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {`
`75`	`75`	`if dataLen != fixLen {`
`76`		`- return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)`
	`76`	`+ return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`return []byte{}, nil`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func TestBCDVarPrefixer_EncodeLengthMaxLengthValidation(t *testing.T) {`
`21`	`21`	`func TestBCDVarPrefixer_DecodeLengthMaxLengthValidation(t *testing.T) {`
`22`	`22`	`_, _, err := BCD.LLL.DecodeLength(20, []byte{0x22})`
`23`	`23`
`24`		`- require.Contains(t, err.Error(), "length mismatch: want to read 2 bytes, get only 1")`
	`24`	`+ require.Contains(t, err.Error(), "not enough data length: 2 to read: 1 byte digits")`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`func TestBCDVarPrefixer_LHelpers(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ type binaryFixedPrefixer struct {`
`22`	`22`
`23`	`23`	`func (p *binaryFixedPrefixer) EncodeLength(fixLen, dataLen int) ([]byte, error) {`
`24`	`24`	`if dataLen != fixLen {`
`25`		`- return nil, fmt.Errorf("field length: %d should be fixed: %d", dataLen, fixLen)`
	`25`	`+ return nil, fmt.Errorf(fieldLengthShouldBeFixed, dataLen, fixLen)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`return []byte{}, nil`
`@@ -64,7 +64,7 @@ func bytesToInt(b []byte) (int, error) {`
`64`	`64`
`65`	`65`	`func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`66`	`66`	`if dataLen > maxLen {`
`67`		`- return nil, fmt.Errorf("field length: %d is larger than maximum: %d", dataLen, maxLen)`
	`67`	`+ return nil, fmt.Errorf(fieldLengthIsLargerThanMax, dataLen, maxLen)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`res, err := intToBytes(dataLen)`
`@@ -76,7 +76,7 @@ func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`76`	`76`	`res = bytes.TrimLeft(res, "\x00")`
`77`	`77`
`78`	`78`	`if len(res) > p.Digits {`
`79`		`- return nil, fmt.Errorf("number of digits in length: %d exceeds: %d", dataLen, p.Digits)`
	`79`	`+ return nil, fmt.Errorf(numberOfDigitsInLengthExceeds, dataLen, p.Digits)`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`// if len of res is less than p.Digits prepend with 0x00`
`@@ -92,7 +92,7 @@ func (p *binaryVarPrefixer) EncodeLength(maxLen, dataLen int) ([]byte, error) {`
`92`	`92`	`// and the number of bytes read.`
`93`	`93`	`func (p *binaryVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, error) {`
`94`	`94`	`if len(data) < p.Digits {`
`95`		`- return 0, 0, fmt.Errorf("not enough data length: %d to read: %d bytes", len(data), p.Digits)`
	`95`	`+ return 0, 0, fmt.Errorf(notEnoughDataToRead, len(data), p.Digits)`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`prefBytes := data[:p.Digits]`
`@@ -111,7 +111,7 @@ func (p *binaryVarPrefixer) DecodeLength(maxLen int, data []byte) (int, int, err`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`if dataLen > maxLen {`
`114`		`- return 0, 0, fmt.Errorf("data length: %d is larger than maximum %d", dataLen, maxLen)`
	`114`	`+ return 0, 0, fmt.Errorf(dataLengthIsLargerThanMax, dataLen, maxLen)`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`return dataLen, p.Digits, nil`