factor out, test & fix line folding from serialize

Author: Paul Fawkesley

property.go

@@ -63,18 +63,35 @@ func (property *BaseProperty) serialize(w io.Writer) {
 	}
 	fmt.Fprint(b, ":")
 	fmt.Fprint(b, property.Value)
-	r := b.String()
-	if len(r) > 75 {
-		fmt.Fprint(w, r[:75], "\r\n")
-		r = r[75:]
-		fmt.Fprint(w, " ")
-	}
-	for len(r) > 74 {
-		fmt.Fprint(w, r[:74], "\r\n")
-		r = r[74:]
-		fmt.Fprint(w, " ")
+	foldLine(b.String(), w)
+}
+
+// foldLine converts a line into multiple lines, where no line is longer than 75 octets (bytes)
+// as described in https://tools.ietf.org/html/rfc5545#section-3.1
+// Many runes are encoded with multiple bytes. foldLine ensures lines are not split mid-rune.
+func foldLine(longLine string, w io.Writer) {
+	octetsThisLine := 0
+
+	for _, thisRune := range []rune(longLine) {
+		octetsThisRune := len(string(thisRune))
+
+		if octetsThisLine+octetsThisRune > 75 {
+			_, err := fmt.Fprintf(w, "\r\n ")
+			if err != nil {
+				panic(err)
+			}
+
+			octetsThisLine = 1 // initial whitespace character after \r\n
+		}
+
+		octetsThisLine += octetsThisRune
+
+		_, err := fmt.Fprintf(w, string(thisRune))
+		if err != nil {
+			panic(err)
+		}
 	}
-	fmt.Fprint(w, r, "\r\n")
+	fmt.Fprint(w, "\r\n")
 }
 
 type IANAProperty struct {

property_test.go

@@ -1,6 +1,9 @@
 package ics
 
-import "testing"
+import (
+	"bytes"
+	"testing"
+)
 
 func TestPropertyParse(t *testing.T) {
 	tests := []struct {
@@ -24,3 +27,70 @@ func TestPropertyParse(t *testing.T) {
 		}
 	}
 }
+
+func TestFoldLine(t *testing.T) {
+	seventyFive := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	threeByte := `⌘`
+
+	tests := []struct {
+		name     string
+		line     string
+		expected string
+	}{
+		{
+			name:     "74 octet line",
+			line:     seventyFive[0:74],
+			expected: seventyFive[0:74] + "\r\n",
+		},
+		{
+			name:     "75 octet line",
+			line:     seventyFive,
+			expected: seventyFive + "\r\n",
+		},
+		{
+			name:     "76 octet line",
+			line:     seventyFive + "b",
+			expected: seventyFive + "\r\n b" + "\r\n",
+		},
+		{
+			name:     "77 octet line",
+			line:     seventyFive + "bb",
+			expected: seventyFive + "\r\n bb" + "\r\n",
+		},
+		{
+			name:     "75x2 octet line",
+			line:     seventyFive + seventyFive,
+			expected: seventyFive + "\r\n " + seventyFive[0:74] + "\r\n " + "a" + "\r\n",
+		},
+		{
+			name:     "72 bytes followed by 3-byte character",
+			line:     seventyFive[0:72] + threeByte,
+			expected: seventyFive[0:72] + threeByte + "\r\n", // 72+3 is ok, no need to fold
+		},
+		{
+			name:     "73 bytes followed by 3-byte character",
+			line:     seventyFive[0:73] + threeByte,
+			expected: seventyFive[0:73] + "\r\n " + threeByte + "\r\n",
+		},
+		{
+			name:     "74 bytes followed by 3-byte character",
+			line:     seventyFive[0:74] + threeByte,
+			expected: seventyFive[0:74] + "\r\n " + threeByte + "\r\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			buf := bytes.NewBuffer(nil)
+			foldLine(test.line, buf)
+			got := buf.String()
+			assertEqual(t, test.expected, got)
+		})
+	}
+}
+
+func assertEqual(t *testing.T, expected string, got string) {
+	if got != expected {
+		t.Errorf("\n--- expected ---\n%s\n--- got ---\n%s\n---\n", expected, got)
+	}
+}