buffer/peek_test.go

package buffer_test

import (
	"testing"
	"code.squareroundforest.org/arpio/buffer"
	"bytes"
	"io"
	"errors"
)

func TestPeek(t *testing.T) {
	t.Run("peek across segments", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(128),
			ReadSize:    8,
		}

		r := buffer.ReaderFrom(g, o)
		p, err := r.Peek(2*128 + 30)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(p, generate(2*128+30)) {
			t.Fatal("failed to peek", len(p))
		}
	})

	t.Run("err before and after consumed", func(t *testing.T) {
		g := &gen{
			max:     12,
			fastErr: true,
		}

		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(18)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(12)) {
			t.Fatal("invalid content", len(b))
		}

		b, err = r.Peek(18)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(12)) {
			t.Fatal("invalid content", len(b))
		}

		b, err = io.ReadAll(r)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(12)) {
			t.Fatal("invalid content", len(b))
		}

		b, err = r.Peek(18)
		if !errors.Is(err, io.EOF) {
			t.Fatal("failed EOF")
		}

		if len(b) != 0 {
			t.Fatal("invalid content", len(b))
		}
	})

	t.Run("err immediately on first try to fill", func(t *testing.T) {
		g := &gen{}
		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(18)
		if !errors.Is(err, io.EOF) {
			t.Fatal("failed EOF")
		}

		if len(b) != 0 {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek on empty", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(18)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(18)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek multiple segments", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(64),
			ReadSize:    16,
		}

		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(160)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(160)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek on partially filled", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(64),
			ReadSize:    16,
		}

		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(16)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(16)) {
			t.Fatal("invalid content")
		}

		b, err = r.Peek(48)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(48)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek on partially filled multiple segments", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(64),
			ReadSize:    16,
		}

		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(160)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(160)) {
			t.Fatal("invalid content")
		}

		b, err = r.Peek(144)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(144)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek not enough available", func(t *testing.T) {
		g := &gen{
			max:     12,
			fastErr: true,
		}

		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(18)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(12)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek not enough available multiple segments", func(t *testing.T) {
		g := &gen{
			max:     144,
			fastErr: true,
		}

		o := buffer.Options{
			Pool:        buffer.NoPool(64),
			ReadSize:    16,
		}

		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(214)
		if err != nil {
			t.Fatal(err)
		}

		if !bytes.Equal(b, generate(144)) {
			t.Fatal("invalid content")
		}
	})

	t.Run("peek zero", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b, err := r.Peek(0)
		if err != nil {
			t.Fatal(err)
		}

		if len(b) != 0 {
			t.Fatal("ivnalid content")
		}
	})
}