buffer_test.go

package seekbuffer

import (
	"fmt"
	"io"
	"testing"
)

func TestSeekBuffer_grow(t *testing.T) {
	var bb SeekBuffer

	bb.grow(10)

	if cap(bb.buff) != 10 {
		t.Error("Invalid cap")
	}

	// with data

	bb.Write([]byte{'1', '2', '3'})

	bb.grow(10)

	if string(bb.Bytes()) != string([]byte{'1', '2', '3'}) {
		t.Error("buffer not copied properly")
	}
}

func TestSeekBuffer_Write(t *testing.T) {
	var bb SeekBuffer

	bytesToWrite := []byte("Hello")

	n, err := bb.Write(bytesToWrite)

	if err != nil {
		t.Error(fmt.Errorf("cant write to buffer: %w", err).Error())
	}

	if n != len(bytesToWrite) {
		t.Errorf("written less len len of content: n=%d, len_content=%d", n, len(bytesToWrite))
	}

	if bb.writePos != int64(len(bytesToWrite)) {
		t.Errorf("Invalid write pos. Should be %d, actual %d ", len(bytesToWrite), bb.writePos)
	}

	bb.Write(bytesToWrite)

	if string(bb.buff) != string(append(bytesToWrite, bytesToWrite...)) {
		t.Errorf("invalid buffer content")
	}

	if bb.Len() != len(bytesToWrite)*2 {
		t.Errorf("Invalid content len. Should be %d. Actual %d", len(bytesToWrite)*2, bb.Len())
	}
}

func TestSeekBuffer_Read(t *testing.T) {
	var bb SeekBuffer

	bb.Write([]byte("Hello"))
	bb.Write([]byte(" World!"))

	content, err := io.ReadAll(&bb)
	if err != nil {
		t.Errorf("Error read: %s", err.Error())
	}

	if string(content) != "Hello World!" {
		t.Errorf("Error read content. Readed content not equal to original content")
	}
}

func TestSeekBuffer_Seek(t *testing.T) {
	var bb SeekBuffer

	bb.Write([]byte("Hello World"))

	_, err := bb.Seek(3, io.SeekCurrent)
	if err != nil {
		t.Errorf("Seek error: %s", err.Error())
	}

	if bb.readPos != 3 {
		t.Errorf("Seek error: position should be 3, actual - %d", bb.readPos)
	}

	_, err = bb.Seek(3, io.SeekEnd)
	if err != nil {
		t.Errorf("Seek error: %s", err.Error())
	}

	if bb.readPos != 8 {
		t.Errorf("Seek error: position should be 8, actual - %d", bb.readPos)
	}

	_, err = bb.Seek(1, io.SeekCurrent)
	if err != nil {
		t.Errorf("Seek error: %s", err.Error())
	}

	if bb.readPos != 9 {
		t.Errorf("Seek error: position should be 9, actual - %d", bb.readPos)
	}

	_, err = bb.Seek(10, io.SeekCurrent)
	if err == nil {
		t.Errorf("Seek should cause error, becase its out of range. Error is nil")
	}

	bb.Seek(1, io.SeekStart)

	content, err := io.ReadAll(&bb)
	if err != nil {
		t.Errorf("Error read seeked buffer: %s", err.Error())
	}

	if string(content) != "ello World" {
		t.Errorf("Error read seeked buffer. Invalid readed content")
	}
}

func TestSeekBuffer_Reset(t *testing.T) {
	var bb SeekBuffer

	bb.Write([]byte("Hello"))

	if bb.Len() != 5 {
		t.Error("Invalid write to buffer")
	}

	bb.Reset()

	if len(bb.buff) != 0 {
		t.Error("Buffer not reset")
	}
}

func TestSeekBuffer_Close(t *testing.T) {
	var bb SeekBuffer

	bb.Write([]byte("Hello"))

	if bb.Len() != 5 {
		t.Error("Invalid write to buffer")
	}

	bb.Close()

	if bb.buff != nil || bb.readPos != 0 || bb.writePos != 0 {
		t.Error("Buffer not closed properly")
	}
}

func TestSeekBuffer_WithAutoRewind(t *testing.T) {
	var buf SeekBuffer

	buf.WithAutoRewind()

	buf.Write([]byte("Hello"))

	content, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content) != "Hello" {
		t.Errorf("Invalid content on first read: %s", err.Error())
	}

	content2, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content2) != "Hello" {
		t.Errorf("Invalid content on second read: %s", err.Error())
	}
}

func TestSeekBuffer_Replace(t *testing.T) {
	var buf SeekBuffer
	buf.WithAutoRewind()

	buf.Write([]byte("Hello"))

	content, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content) != "Hello" {
		t.Errorf("Invalid content after replace: %s", err.Error())
	}

	buf.Replace([]byte("World"))

	content2, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content2) != "World" {
		t.Errorf("Invalid content after replace: %s", err.Error())
	}

	repBuf := []byte("H")

	buf.Replace(repBuf)

	content3, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content3) != "H" {
		t.Errorf("Invalid content after replace: %s", err.Error())
	}
}

func TestSeekBuffer_ReplaceAndWrite(t *testing.T) {
	var buf SeekBuffer

	// Initial write
	buf.Write([]byte("Hello"))

	// Replace existing content
	buf.Replace([]byte("World"))

	// Validate replacement
	content, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(content) != "World" {
		t.Errorf("Invalid content after replace: %s", err.Error())
	}

	// Write additional data
	n, err := buf.Write([]byte(" Again"))
	if err != nil {
		t.Errorf("Cant write to buffer: %s", err.Error())
	}

	if n != 6 {
		t.Errorf("Invalid write length: expected 6, got %d", n)
	}

	// Validate final content
	buf.Seek(0, io.SeekStart)
	finalContent, err := io.ReadAll(&buf)
	if err != nil {
		t.Errorf("Cant read from buffer: %s", err.Error())
	}

	if string(finalContent) != "World Again" {
		t.Errorf("Invalid final content: %s", string(finalContent))
	}
}