all: sync with master; upd chlog

internal/aghalg/ringbuffer.go

@@ -0,0 +1,102 @@
+package aghalg
+
+import (
+	"github.com/AdguardTeam/golibs/errors"
+)
+
+// RingBuffer is the implementation of ring buffer data structure.
+type RingBuffer[T any] struct {
+	buf  []T
+	cur  int
+	full bool
+}
+
+// NewRingBuffer initializes the new instance of ring buffer.  size must be
+// greater or equal to zero.
+func NewRingBuffer[T any](size int) (rb *RingBuffer[T]) {
+	if size < 0 {
+		panic(errors.Error("ring buffer: size must be greater or equal to zero"))
+	}
+
+	return &RingBuffer[T]{
+		buf: make([]T, size),
+	}
+}
+
+// Append appends an element to the buffer.
+func (rb *RingBuffer[T]) Append(e T) {
+	if len(rb.buf) == 0 {
+		return
+	}
+
+	rb.buf[rb.cur] = e
+	rb.cur = (rb.cur + 1) % cap(rb.buf)
+	if rb.cur == 0 {
+		rb.full = true
+	}
+}
+
+// Range calls cb for each element of the buffer.  If cb returns false it stops.
+func (rb *RingBuffer[T]) Range(cb func(T) (cont bool)) {
+	before, after := rb.splitCur()
+
+	for _, e := range before {
+		if !cb(e) {
+			return
+		}
+	}
+
+	for _, e := range after {
+		if !cb(e) {
+			return
+		}
+	}
+}
+
+// ReverseRange calls cb for each element of the buffer in reverse order.  If
+// cb returns false it stops.
+func (rb *RingBuffer[T]) ReverseRange(cb func(T) (cont bool)) {
+	before, after := rb.splitCur()
+
+	for i := len(after) - 1; i >= 0; i-- {
+		if !cb(after[i]) {
+			return
+		}
+	}
+
+	for i := len(before) - 1; i >= 0; i-- {
+		if !cb(before[i]) {
+			return
+		}
+	}
+}
+
+// splitCur splits the buffer in two, before and after current position in
+// chronological order.  If buffer is not full, after is nil.
+func (rb *RingBuffer[T]) splitCur() (before, after []T) {
+	if len(rb.buf) == 0 {
+		return nil, nil
+	}
+
+	cur := rb.cur
+	if !rb.full {
+		return rb.buf[:cur], nil
+	}
+
+	return rb.buf[cur:], rb.buf[:cur]
+}
+
+// Len returns a length of the buffer.
+func (rb *RingBuffer[T]) Len() (l int) {
+	if !rb.full {
+		return rb.cur
+	}
+
+	return cap(rb.buf)
+}
+
+// Clear clears the buffer.
+func (rb *RingBuffer[T]) Clear() {
+	rb.full = false
+	rb.cur = 0
+}

internal/aghalg/ringbuffer_test.go

@@ -0,0 +1,173 @@
+package aghalg_test
+
+import (
+	"testing"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghalg"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/exp/slices"
+)
+
+// elements is a helper function that returns n elements of the buffer.
+func elements(b *aghalg.RingBuffer[int], n int, reverse bool) (es []int) {
+	fn := b.Range
+	if reverse {
+		fn = b.ReverseRange
+	}
+
+	i := 0
+	fn(func(e int) (cont bool) {
+		if i >= n {
+			return false
+		}
+
+		es = append(es, e)
+		i++
+
+		return true
+	})
+
+	return es
+}
+
+func TestNewRingBuffer(t *testing.T) {
+	t.Run("success_and_clear", func(t *testing.T) {
+		b := aghalg.NewRingBuffer[int](5)
+		for i := 0; i < 10; i++ {
+			b.Append(i)
+		}
+		assert.Equal(t, []int{5, 6, 7, 8, 9}, elements(b, b.Len(), false))
+
+		b.Clear()
+		assert.Zero(t, b.Len())
+	})
+
+	t.Run("negative_size", func(t *testing.T) {
+		assert.PanicsWithError(t, "ring buffer: size must be greater or equal to zero", func() {
+			aghalg.NewRingBuffer[int](-5)
+		})
+	})
+
+	t.Run("zero", func(t *testing.T) {
+		b := aghalg.NewRingBuffer[int](0)
+		for i := 0; i < 10; i++ {
+			b.Append(i)
+			assert.Equal(t, 0, b.Len())
+			assert.Empty(t, elements(b, b.Len(), false))
+			assert.Empty(t, elements(b, b.Len(), true))
+		}
+	})
+
+	t.Run("single", func(t *testing.T) {
+		b := aghalg.NewRingBuffer[int](1)
+		for i := 0; i < 10; i++ {
+			b.Append(i)
+			assert.Equal(t, 1, b.Len())
+			assert.Equal(t, []int{i}, elements(b, b.Len(), false))
+			assert.Equal(t, []int{i}, elements(b, b.Len(), true))
+		}
+	})
+}
+
+func TestRingBuffer_Range(t *testing.T) {
+	const size = 5
+
+	b := aghalg.NewRingBuffer[int](size)
+
+	testCases := []struct {
+		name   string
+		want   []int
+		count  int
+		length int
+	}{{
+		name:   "three",
+		count:  3,
+		length: 3,
+		want:   []int{0, 1, 2},
+	}, {
+		name:   "ten",
+		count:  10,
+		length: size,
+		want:   []int{5, 6, 7, 8, 9},
+	}, {
+		name:   "hundred",
+		count:  100,
+		length: size,
+		want:   []int{95, 96, 97, 98, 99},
+	}}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			for i := 0; i < tc.count; i++ {
+				b.Append(i)
+			}
+
+			bufLen := b.Len()
+			assert.Equal(t, tc.length, bufLen)
+
+			want := tc.want
+			assert.Equal(t, want, elements(b, bufLen, false))
+			assert.Equal(t, want[:len(want)-1], elements(b, bufLen-1, false))
+			assert.Equal(t, want[:len(want)/2], elements(b, bufLen/2, false))
+
+			want = want[:cap(want)]
+			slices.Reverse(want)
+
+			assert.Equal(t, want, elements(b, bufLen, true))
+			assert.Equal(t, want[:len(want)-1], elements(b, bufLen-1, true))
+			assert.Equal(t, want[:len(want)/2], elements(b, bufLen/2, true))
+		})
+	}
+}
+
+func TestRingBuffer_Range_increment(t *testing.T) {
+	const size = 5
+
+	b := aghalg.NewRingBuffer[int](size)
+
+	testCases := []struct {
+		name string
+		want []int
+	}{{
+		name: "one",
+		want: []int{0},
+	}, {
+		name: "two",
+		want: []int{0, 1},
+	}, {
+		name: "three",
+		want: []int{0, 1, 2},
+	}, {
+		name: "four",
+		want: []int{0, 1, 2, 3},
+	}, {
+		name: "five",
+		want: []int{0, 1, 2, 3, 4},
+	}, {
+		name: "six",
+		want: []int{1, 2, 3, 4, 5},
+	}, {
+		name: "seven",
+		want: []int{2, 3, 4, 5, 6},
+	}, {
+		name: "eight",
+		want: []int{3, 4, 5, 6, 7},
+	}, {
+		name: "nine",
+		want: []int{4, 5, 6, 7, 8},
+	}, {
+		name: "ten",
+		want: []int{5, 6, 7, 8, 9},
+	}}
+
+	for i, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			b.Append(i)
+
+			assert.Equal(t, tc.want, elements(b, b.Len(), false))
+
+			slices.Reverse(tc.want)
+			assert.Equal(t, tc.want, elements(b, b.Len(), true))
+		})
+	}
+}