buffer/buffered_test.go

package buffer_test

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

func TestBuffered(t *testing.T) {
	t.Run("none buffered", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{Pool: buffer.NoPool(1 << 12)}
		r := buffer.ReaderFrom(g, o)
		b := r.Buffered()
		if len(b) != 0 {
			t.Fatal("invalid content")
		}
	})

	t.Run("buffered after error", 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")
		}

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

	t.Run("all buffered", 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(48)
		if err != nil {
			t.Fatal(err)
		}

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

		b = r.Buffered()
		if !bytes.Equal(b, generate(48)) {
			t.Fatal("invalid content 2", len(b))
		}
	})

	t.Run("buffered across 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(144)
		if err != nil {
			t.Fatal(err)
		}

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

		b = r.Buffered()
		if !bytes.Equal(b, generate(192)) {
			t.Fatal("invalid content 2", len(b))
		}
	})

	t.Run("buffered mid segment", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(128),
			ReadSize:    64,
		}

		r := buffer.ReaderFrom(g, o)
		b := make([]byte, 32)
		n, err := r.Read(b)
		if err != nil {
			t.Fatal(err)
		}

		if n != 32 {
			t.Fatal("invalid read length", n)
		}

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

		b = r.Buffered()
		if !bytes.Equal(b, generate(64)[32:]) {
			t.Fatal("invalid content")
		}
	})

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

		r := buffer.ReaderFrom(g, o)
		b := make([]byte, 288)
		n, err := r.Read(b)
		if err != nil {
			t.Fatal(err)
		}

		if n != 288 {
			t.Fatal("invalid read length", n)
		}

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

		b = r.Buffered()
		if !bytes.Equal(b, generate(384)[288:]) {
			t.Fatal("invalid content 2", len(b))
		}
	})

	t.Run("zero buffered mid segment", func(t *testing.T) {
		g := &gen{max: 1 << 15}
		o := buffer.Options{
			Pool:        buffer.NoPool(128),
			ReadSize:    64,
		}

		r := buffer.ReaderFrom(g, o)
		b := make([]byte, 64)
		n, err := r.Read(b)
		if err != nil {
			t.Fatal(err)
		}

		if n != 64 {
			t.Fatal("invalid read length", n)
		}

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

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