reaper_test.go

package reaper

import (
	"reflect"
	"slices"
	"testing"
)

type IntHeap struct {
	s []int
}

func NewIntHeap(vals ...int) *IntHeap {
	h := &IntHeap{}
	h.s = append(h.s, vals...)
	slices.Sort(h.s)
	return h
}

func (h *IntHeap) Push(elem int) {
	h.s = append(h.s, elem)
	slices.Sort(h.s)
}

func (h *IntHeap) Pop() int {
	elem := h.s[0]
	h.s = h.s[1:]
	return elem
}

func (h *IntHeap) Empty() bool { return len(h.s) == 0 }
func (h *IntHeap) Lock()       {}
func (h *IntHeap) Unlock()     {}

func TestReaperEmpty(t *testing.T) {
	h := NewIntHeap()
	r := New[int](0)

	var visited bool
	visit := func(_ int, _ func(...int) error) (stop bool) {
		visited = true
		return false
	}

	if res := r.Reap(h, CallbackFunc[int](visit)); res != Exhausted {
		t.Errorf("expected Exhausted, got: %v", res)
	}

	if visited {
		t.Errorf("expected no visits on empty heap")
	}
}

func TestReaperBasic(t *testing.T) {
	h := NewIntHeap(1, 2, 3)

	degree := 2
	r := New[int](degree)

	var visited []int
	visit := func(front int, emit func(...int) error) (stop bool) {
		if front == 2 {
			return true
		}

		visited = append(visited, front)
		if err := emit(4, 5); err != nil {
			t.Errorf("unexpected emit error: %v", err)
		}
		return false
	}

	if res := r.Reap(h, CallbackFunc[int](visit)); res != Stopped {
		t.Errorf("expected Stopped, got: %v", res)
	}

	if !reflect.DeepEqual(visited, []int{1}) {
		t.Errorf("unexpected visits: %v", visited)
	}

	if !reflect.DeepEqual(h.s, []int{2, 3, 4, 5}) {
		t.Errorf("unexpected heap state: %v", h.s)
	}
}

func TestReaperExhaustion(t *testing.T) {
	h := NewIntHeap(1, 2, 3)

	r := New[int](2)
	var visited []int
	visit := func(front int, emit func(...int) error) (stop bool) {
		switch front {
		case 1:
			_ = emit(5, 4)
		case 5:
			_ = emit(6)
		case 6:
			_ = emit(7)
			_ = emit(8)
		}

		visited = append(visited, front)
		return // continue
	}

	if res := r.Reap(h, CallbackFunc[int](visit)); res != Exhausted {
		t.Errorf("expected Exhausted, got: %v", res)
	}

	if !reflect.DeepEqual(visited, []int{1, 2, 3, 4, 5, 6, 7, 8}) {
		t.Errorf("unexpected visits: %v", visited)
	}

	if !h.Empty() {
		t.Errorf("expected heap to be empty, got: %v", h.s)
	}
}

func TestReaperEmitOverflow(t *testing.T) {
	h := NewIntHeap(1, 2, 3)

	degree := 2
	r := New[int](degree)

	visit := func(_ int, emit func(...int) error) (stop bool) {
		if err := emit(4, 5, 6); err != ErrEmitBufferOverflow {
			t.Errorf("expected overflow error, got: %v", err)
		}

		return true
	}

	if res := r.Reap(h, CallbackFunc[int](visit)); res != Stopped {
		t.Errorf("expected Stopped, got: %v", res)
	}

	if !reflect.DeepEqual(h.s, []int{1, 2, 3}) {
		t.Errorf("unexpected heap state: %v", h.s)
	}
}

func TestReaperMultipleEmitCalls(t *testing.T) {
	h := NewIntHeap(1, 2, 3)

	degree := 3
	r := New[int](degree)

	visit := func(front int, emit func(...int) error) (stop bool) {
		if front == 2 {
			return true
		}

		if err := emit(4); err != nil {
			t.Errorf("unexpected emit error: %v", err)
		}
		if err := emit(5, 6); err != nil {
			t.Errorf("unexpected emit error: %v", err)
		}
		if err := emit(7); err != ErrEmitBufferOverflow {
			t.Errorf("expected overflow error, got: %v", err)
		}

		return false
	}

	_ = r.Reap(h, CallbackFunc[int](visit))

	if !reflect.DeepEqual(h.s, []int{2, 3, 4, 5, 6}) {
		t.Errorf("unexpected heap state: %v", h.s)
	}
}

func TestReaperZeroDegreeEmit(t *testing.T) {
	h := NewIntHeap(1, 2, 3)

	r := New[int](0)

	visit := func(_ int, emit func(...int) error) (stop bool) {
		if err := emit(4); err != ErrEmitBufferOverflow {
			t.Errorf("expected overflow error, got: %v", err)
		}

		return true
	}

	_ = r.Reap(h, CallbackFunc[int](visit))

	if !reflect.DeepEqual(h.s, []int{1, 2, 3}) {
		t.Errorf("unexpected heap state: %v", h.s)
	}
}