Add tests for LineReaderAt implementation

This adds minimal new coverage, since the apply tests already exercise
this, but it's complicated enough that dedicated tests will be helpful.

Author: bluekeyes

gitdiff/io.go

@@ -35,6 +35,9 @@ func (r *lineReaderAt) ReadLinesAt(lines [][]byte, offset int64) (n int, err err
 	//  - it's generally not clear when something is bytes vs lines
 	//  - offset is a good example of this
 
+	if offset < 0 {
+		return 0, errors.New("ReadLinesAt: negative offset")
+	}
 	if len(lines) == 0 {
 		return 0, nil
 	}

gitdiff/io_test.go

@@ -0,0 +1,109 @@
+package gitdiff
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"testing"
+)
+
+func TestLineReaderAt(t *testing.T) {
+	tests := map[string]struct {
+		InputLines int
+		Offset     int64
+		Count      int
+		Err        bool
+		EOF        bool
+		EOFCount   int
+	}{
+		"readLines": {
+			InputLines: 32,
+			Offset:     0,
+			Count:      4,
+		},
+		"readLinesOffset": {
+			InputLines: 32,
+			Offset:     8,
+			Count:      4,
+		},
+		"readLinesLargeOffset": {
+			InputLines: 8192,
+			Offset:     4096,
+			Count:      64,
+		},
+		"readSingleLine": {
+			InputLines: 4,
+			Offset:     2,
+			Count:      1,
+		},
+		"readZeroLines": {
+			InputLines: 4,
+			Offset:     2,
+			Count:      0,
+		},
+		"readThroughEOF": {
+			InputLines: 16,
+			Offset:     12,
+			Count:      8,
+			EOF:        true,
+			EOFCount:   4,
+		},
+		"offsetAfterEOF": {
+			InputLines: 8,
+			Offset:     10,
+			Count:      2,
+			EOF:        true,
+			EOFCount:   0,
+		},
+		"offsetNegative": {
+			InputLines: 8,
+			Offset:     -1,
+			Count:      2,
+			Err:        true,
+		},
+	}
+
+	const lineTemplate = "generated test line %d\n"
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			var input bytes.Buffer
+			for i := 0; i < test.InputLines; i++ {
+				fmt.Fprintf(&input, lineTemplate, i)
+			}
+
+			output := make([][]byte, test.Count)
+			for i := 0; i < test.Count; i++ {
+				output[i] = []byte(fmt.Sprintf(lineTemplate, test.Offset+int64(i)))
+			}
+
+			r := &lineReaderAt{r: bytes.NewReader(input.Bytes())}
+			lines := make([][]byte, test.Count)
+
+			n, err := r.ReadLinesAt(lines, test.Offset)
+			if test.Err {
+				if err == nil {
+					t.Fatal("expected error reading lines, but got nil")
+				}
+				return
+			}
+			if err != nil && (!test.EOF || err != io.EOF) {
+				t.Fatalf("unexpected error reading lines: %v", err)
+			}
+
+			count := test.Count
+			if test.EOF {
+				count = test.EOFCount
+			}
+
+			if n != count {
+				t.Fatalf("incorrect number of lines read: expected %d, actual %d", count, n)
+			}
+			for i := 0; i < n; i++ {
+				if !bytes.Equal(output[i], lines[i]) {
+					t.Errorf("incorrect content in line %d:\nexpected: %q\nactual: %q", i, output[i], lines[i])
+				}
+			}
+		})
+	}
+}