use buffers as interface to storage

1 files changed, 88 insertions, 0 deletions

diff --git a/internal/buffer/buffer_test.go b/internal/buffer/buffer_test.go
new file mode 100644
index 0000000..9cddeca
--- /dev/null
+++ b/internal/buffer/buffer_test.go
@@ -0,0 +1,88 @@
+package buffer
+
+import (
+	"io"
+	"testing"
+)
+
+func TestWrite(t *testing.T) {
+	b := Buffer{}
+	data := []byte("test")
+
+	n, err := b.Write(data)
+	if n != len(data) || err != nil {
+		t.Errorf("Write failed: expected %d bytes, got %d, error: %v", len(data), n, err)
+	}
+
+	if b.Len() != len(data) {
+		t.Errorf("Len is incorrect after write: expected %d, got %d", len(data), b.Len())
+	}
+
+	if string(b.Bytes()) != "test" {
+		t.Error("Bytes returned after write do not match written data")
+	}
+}
+
+func TestRead(t *testing.T) {
+	b := NewBuffer([]byte("testdata"))
+	p := make([]byte, 3)
+	n, err := b.Read(p)
+
+	if n != 3 || string(p[:n]) != "tes" {
+		t.Errorf("Read returned incorrect data: expected 'tes', got '%s'", p[:n])
+	}
+
+	b.Reset()
+	b.Write([]byte("abc"))
+	p = make([]byte, 2)
+	n, err = b.Read(p)
+
+	if n != 2 || string(p) != "ab" {
+		t.Errorf("Read after reset failed: expected 'ab', got '%s'", p)
+	}
+
+	b.pos = b.len
+	n, err = b.Read(p)
+	if n != 0 || err != io.EOF {
+		t.Errorf("Reading beyond buffer did not return EOF: n=%d, err=%v", n, err)
+	}
+}
+
+func TestReset(t *testing.T) {
+	b := NewBuffer([]byte("test"))
+	b.Write([]byte("data"))
+
+	if b.Len() != 8 || b.pos != 0 {
+		t.Errorf("Initial buffer state incorrect: len=%d, pos=%d", b.Len(), b.pos)
+	}
+
+	b.Reset()
+	if b.Len() != 0 || b.pos != 0 {
+		t.Errorf("Reset did not clear buffer correctly: len=%d, pos=%d", b.Len(), b.pos)
+	}
+}
+
+func TestSeek(t *testing.T) {
+	b := NewBuffer([]byte("test"))
+	tests := []struct {
+		offset int64
+		whence int
+		expect int64
+		err    error
+	}{
+		{2, io.SeekStart, 2, nil},
+		{-1, io.SeekCurrent, 1, nil},
+		{-2, io.SeekEnd, int64(len("test") - 2), nil},
+		{5, io.SeekStart, int64(len("test")), nil},
+		{-10, io.SeekEnd, 0, nil},
+		{0, 999, 0, io.EOF}, // Invalid whence test
+	}
+
+	for _, tt := range tests {
+		pos, err := b.Seek(tt.offset, tt.whence)
+		if pos != tt.expect || (err != tt.err && !((err == nil) && (tt.err == nil))) {
+			t.Errorf("Seek(%d, %d): expected %d with error %v, got %d and %v",
+				tt.offset, tt.whence, tt.expect, tt.err, pos, err)
+		}
+	}
+}