buffer/peek_test.go

package buffer_test

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

func TestPeek(t *testing.T) {
	for title, cr := range map[string]createReader{"reader": buffer.BufferedReader, "content": testContent} {
		t.Run(title, func(t *testing.T) {
			t.Run("peek across segments", func(t *testing.T) {
				g := &gen{max: 1 << 15}
				o := buffer.Options{Pool: buffer.NoPool(128)}
				r := cr(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 := cr(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 := cr(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 := cr(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)}
				r := cr(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)}
				r := cr(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)}
				r := cr(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 := cr(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)}
				r := cr(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 := cr(g, o)
				b, err := r.Peek(0)
				if err != nil {
					t.Fatal(err)
				}

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