use runes

field/string.go

@@ -6,6 +6,7 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"unicode/utf8"
 
 	"github.com/moov-io/iso8583/utils"
 )
@@ -81,7 +82,9 @@ func (f *String) Pack() ([]byte, error) {
 		return nil, fmt.Errorf("failed to encode content: %w", err)
 	}
 
-	packedLength, err := f.spec.Pref.EncodeLength(f.spec.Length, len(data))
+	runeCount := utf8.RuneCount(data)
+
+	packedLength, err := f.spec.Pref.EncodeLength(f.spec.Length, runeCount)
 	if err != nil {
 		return nil, fmt.Errorf("failed to encode length: %w", err)
 	}

field/string_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/moov-io/iso8583/encoding"
 	"github.com/moov-io/iso8583/padding"
 	"github.com/moov-io/iso8583/prefix"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -59,6 +60,82 @@ func TestStringField(t *testing.T) {
 	require.Equal(t, "hello", str.Value())
 }
 
+func TestStringWithUTF8Encoding(t *testing.T) {
+	spec := &Spec{
+		Length:      10,
+		Description: "Field",
+		Enc:         encoding.EBCDIC1047,
+		Pref:        prefix.EBCDIC1047.Fixed,
+		Pad:         padding.Left(' '),
+	}
+	str := NewStringValue("hüllo")
+	str.SetSpec(spec)
+	packed, err := str.Pack()
+	require.NoError(t, err)
+
+	assert.Len(t, packed, 10)
+
+	str2 := NewString(spec)
+	_, err = str2.Unpack(packed)
+	require.NoError(t, err)
+
+	assert.Equal(t, "hüllo", str2.Value())
+}
+
+func TestStringWithNonUTF8Encoding(t *testing.T) {
+	spec := &Spec{
+		Length:      10,
+		Description: "Field",
+		Enc:         encoding.EBCDIC1047,
+		Pref:        prefix.EBCDIC1047.Fixed,
+		Pad:         padding.Left(' '),
+	}
+	str := NewString(spec)
+
+	hullo := []byte{0x88, 0xDC, 0x93, 0x93, 0x96}
+	olluh := []byte{0x96, 0x93, 0x93, 0xDC, 0x88}
+
+	// SetBytes takes UTF-8 encoded bytes
+	str.SetBytes([]byte("hüllo"))
+	require.Equal(t, "hüllo", str.Value())
+
+	packed, err := str.Pack()
+	require.NoError(t, err)
+	require.Equal(t, append([]byte{0x40, 0x40, 0x40, 0x40, 0x40}, hullo...), packed)
+
+	length, err := str.Unpack(append([]byte{0x40, 0x40, 0x40, 0x40, 0x40}, olluh...))
+	require.NoError(t, err)
+	require.Equal(t, 10, length)
+
+	// Bytes returns the UTF-8 encoding of the value
+	b, err := str.Bytes()
+	require.NoError(t, err)
+	require.Equal(t, []byte("ollüh"), b)
+
+	require.Equal(t, "ollüh", str.Value())
+
+	str = NewString(spec)
+	str.Marshal(NewStringValue("hüllo"))
+	packed, err = str.Pack()
+	require.NoError(t, err)
+	require.Equal(t, append([]byte{0x40, 0x40, 0x40, 0x40, 0x40}, hullo...), packed)
+
+	str = NewString(spec)
+	length, err = str.Unpack(append([]byte{0x40, 0x40, 0x40, 0x40, 0x40}, olluh...))
+	require.NoError(t, err)
+	require.Equal(t, 10, length)
+	require.Equal(t, "ollüh", str.Value())
+
+	str = NewString(spec)
+	err = str.SetBytes([]byte("hüllo"))
+	require.NoError(t, err)
+	require.Equal(t, "hüllo", str.Value())
+
+	str = NewString(spec)
+	str.SetValue("hüllo")
+	require.Equal(t, "hüllo", str.Value())
+}
+
 func TestStringNil(t *testing.T) {
 	var str *String = nil
 

padding/left.go

@@ -19,11 +19,12 @@ func NewLeftPadder(pad rune) Padder {
 }
 
 func (p *leftPadder) Pad(data []byte, length int) []byte {
-	if len(data) >= length {
+	runeCount := utf8.RuneCount(data)
+	if runeCount >= length {
 		return data
 	}
 
-	padding := bytes.Repeat(p.pad, length-len(data))
+	padding := bytes.Repeat(p.pad, length-runeCount)
 	return append(padding, data...)
 }