pool/event_test.go

package pool_test

import (
	"code.squareroundforest.org/arpio/pool"
	"errors"
	"testing"
)

func TestEvent(t *testing.T) {
	t.Run("get put allocate free", func(t *testing.T) {
		alloc := func() ([]byte, error) { return make([]byte, 1<<9), nil }
		e := make(chan pool.Event, 7)
		o := pool.Options{
			Algo:      pool.Max(2),
			Events:    e,
			EventMask: pool.AllEvents,
		}

		p := pool.Make(alloc, nil, o)

		var b [][]byte
		for i := 0; i < 3; i++ {
			bi, err := p.Get()
			if err != nil {
				t.Fatal(err)
			}

			b = append(b, bi)
		}

		for _, bi := range b {
			p.Put(bi)
		}

		for i := 0; i < 3; i++ {
			ev := <-e
			if ev.Type != pool.GetOperation|pool.AllocateOperation {
				t.Fatal(ev)
			}
		}

		for i := 0; i < 2; i++ {
			ev := <-e
			if ev.Type != pool.PutOperation {
				t.Fatal(ev)
			}
		}

		ev := <-e
		if ev.Type != pool.PutOperation|pool.FreeOperation {
			t.Fatal(ev)
		}
	})

	t.Run("allocate error", func(t *testing.T) {
		alloc := func() ([]byte, error) { return nil, errTest }
		e := make(chan pool.Event, 1)
		o := pool.Options{
			Algo:      pool.NoShrink(),
			Events:    e,
			EventMask: pool.AllEvents,
		}

		p := pool.Make(alloc, nil, o)
		_, err := p.Get()
		if !errors.Is(err, errTest) {
			t.Fatal(err)
		}

		ev := <-e
		if ev.Type != pool.GetOperation|pool.AllocateOperation|pool.AllocateError {
			t.Fatal(ev)
		}
	})

	t.Run("drop", func(t *testing.T) {
		alloc := func() ([]byte, error) { return make([]byte, 1<<9), nil }
		e := make(chan pool.Event)
		o := pool.Options{
			Algo:      pool.NoShrink(),
			Events:    e,
			EventMask: pool.AllEvents,
		}

		p := pool.Make(alloc, nil, o)
		_, err := p.Get()
		if err != nil {
			t.Fatal(err)
		}

		select {
		case <-e:
			t.Fatal("unexpected event")
		default:
		}
	})

	t.Run("mask", func(t *testing.T) {
		alloc := func() ([]byte, error) { return make([]byte, 1<<9), nil }
		e := make(chan pool.Event, 1)
		o := pool.Options{
			Algo:      pool.NoShrink(),
			Events:    e,
			EventMask: pool.GetOperation,
		}

		p := pool.Make(alloc, nil, o)
		b, err := p.Get()
		if err != nil {
			t.Fatal(err)
		}

		p.Put(b)
		ev := <-e
		if ev.Type != pool.AllocateOperation|pool.GetOperation {
			t.Fatal(ev)
		}

		select {
		case <-e:
			t.Fatal("unexpected event")
		default:
		}
	})
}