update configurable line terminators implementation

update configurable line terminators implementation to better align with
the rest of the code base.

encode.go

@@ -57,19 +57,25 @@ func (e *MarshalInvalidTypeError) Error() string {
 // An Encoder writes fixed-width formatted data to an output
 // stream.
 type Encoder struct {
-	w *bufio.Writer
-
-	LineEnd []byte
+	w              *bufio.Writer
+	lineTerminator []byte
 }
 
 // NewEncoder returns a new encoder that writes to w.
 func NewEncoder(w io.Writer) *Encoder {
 	return &Encoder{
-		w:       bufio.NewWriter(w),
-		LineEnd: []byte("\n"),
+		w:              bufio.NewWriter(w),
+		lineTerminator: []byte("\n"),
 	}
 }
 
+// SetLineTerminator sets the character(s) that will be used to terminate lines.
+//
+// The default value is "\n".
+func (e *Encoder) SetLineTerminator(lineTerminator []byte) {
+	e.lineTerminator = lineTerminator
+}
+
 // Encode writes the fixed-width encoding of v to the
 // stream.
 // See the documentation for Marshal for details about
@@ -98,18 +104,14 @@ func (e *Encoder) Encode(i interface{}) (err error) {
 }
 
 func (e *Encoder) writeLines(v reflect.Value) error {
-	lineEnd := e.LineEnd
-	if len(lineEnd) == 0 {
-		lineEnd = []byte("\n")
-	}
 	for i := 0; i < v.Len(); i++ {
 		err := e.writeLine(v.Index(i))
 		if err != nil {
 			return err
 		}
 
 		if i != v.Len()-1 {
-			_, err := e.w.Write(lineEnd)
+			_, err := e.w.Write(e.lineTerminator)
 			if err != nil {
 				return err
 			}

encode_test.go

@@ -3,7 +3,6 @@ package fixedwidth
 import (
 	"bytes"
 	"fmt"
-	"io"
 	"log"
 	"reflect"
 	"testing"
@@ -129,34 +128,23 @@ func TestNewValueEncoder(t *testing.T) {
 	}
 }
 
-func TestEncoderWithMultipleLines(t *testing.T) {
+func TestEncoder_SetLineTerminator(t *testing.T) {
+	buff := new(bytes.Buffer)
+	enc := NewEncoder(buff)
+	enc.SetLineTerminator([]byte{'\r', '\n'})
+
 	input := []interface{}{
 		EncodableString{"foo", nil},
 		EncodableString{"bar", nil},
 	}
 
-	for _, tt := range []struct {
-		name       string
-		expected   string
-		newEncoder func(io.Writer) *Encoder
-	}{
-		{"default", "foo\nbar", func(w io.Writer) *Encoder { return NewEncoder(w) }},
-		{"default", "foo\r\nbar", func(w io.Writer) *Encoder {
-			enc := NewEncoder(w)
-			enc.LineEnd = []byte("\r\n")
-			return enc
-		}},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			var buf bytes.Buffer
-			enc := tt.newEncoder(&buf)
-			err := enc.Encode(input)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if buf.String() != tt.expected {
-				t.Fatalf("unexpected output\nexpected: %q\nreceived: %q", tt.expected, buf.String())
-			}
-		})
+	err := enc.Encode(input)
+	if err != nil {
+		t.Fatal("Encode() unexpected error")
+	}
+
+	expected := []byte("foo\r\nbar")
+	if !bytes.Equal(expected, buff.Bytes()) {
+		t.Errorf("Encode() expected %q, have %q", expected, buff.Bytes())
 	}
 }