Just deque

1 files changed, 299 insertions, 0 deletions

diff --git a/deque_test.go b/deque_test.go
new file mode 100644
index 0000000..27ae232
--- /dev/null
+++ b/deque_test.go
@@ -0,0 +1,299 @@
+package deque
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestWithCapacity(t *testing.T) {
+	t.Parallel()
+
+	const cap = 10
+	q := WithCapacity[int](cap)
+	for i := range cap {
+		q.PushBack(i)
+	}
+	if got := q.Cap(); got != cap {
+		t.Errorf("Cap() = %d, want %d", got, cap)
+	}
+}
+
+func TestAt(t *testing.T) {
+	t.Parallel()
+
+	q := new(Deque[int])
+	for i := range 10 {
+		q.PushBack(i)
+	}
+	for i := range 3 {
+		if got := q.At(i); got != i {
+			t.Errorf("At(%d) = %d, want %d", i, got, i)
+		}
+	}
+}
+
+func TestPopFront(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		desc         string
+		in           []int
+		wantOk       bool
+		wantVal      int
+		wantContents []int
+	}{{
+		desc:         "PopVal",
+		in:           []int{1, 2, 3},
+		wantOk:       true,
+		wantVal:      1,
+		wantContents: []int{2, 3},
+	}, {
+		desc:   "PopNone",
+		in:     nil,
+		wantOk: false,
+	}} {
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			q := From(tc.in)
+			got, ok := q.PopFront()
+			if ok != tc.wantOk {
+				t.Errorf("%d: PopFront() returned ok = %t, want %t", tc.in, ok, tc.wantOk)
+			}
+			if got != tc.wantVal {
+				t.Errorf("%d: PopFront() = %d, want %d", tc.in, got, tc.wantVal)
+			}
+			gotContents := make([]int, q.Len())
+			for i, x := range q.All() {
+				gotContents[i] = x
+			}
+			if !slices.Equal(gotContents, tc.wantContents) {
+				t.Errorf("%d: Contents after PopFront are %d, want %d", tc.in, gotContents, tc.wantContents)
+			}
+		})
+	}
+}
+
+func TestPopBack(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		desc         string
+		in           []int
+		wantOk       bool
+		wantVal      int
+		wantContents []int
+	}{{
+		desc:         "PopVal",
+		in:           []int{1, 2, 3},
+		wantOk:       true,
+		wantVal:      3,
+		wantContents: []int{1, 2},
+	}, {
+		desc:   "PopNone",
+		in:     nil,
+		wantOk: false,
+	}} {
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			q := From(tc.in)
+			got, ok := q.PopBack()
+			if ok != tc.wantOk {
+				t.Errorf("%d: PopBack() returned ok = %t, want %t", tc.in, ok, tc.wantOk)
+			}
+			if got != tc.wantVal {
+				t.Errorf("%d: PopBack() = %d, want %d", tc.in, got, tc.wantVal)
+			}
+			gotContents := make([]int, q.Len())
+			for i, x := range q.All() {
+				gotContents[i] = x
+			}
+			if !slices.Equal(gotContents, tc.wantContents) {
+				t.Errorf("%d: Contents after PopBack are %d, want %d", tc.in, gotContents, tc.wantContents)
+			}
+		})
+	}
+}
+
+func TestPushFront(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		desc        string
+		prevContent []int
+		push        []int
+		want        []int
+	}{{
+		desc:        "PushNil",
+		prevContent: nil,
+		push:        []int{1},
+		want:        []int{1},
+	}, {
+		desc:        "PushExisting",
+		prevContent: []int{1, 2, 3},
+		push:        []int{4, 5, 6},
+		want:        []int{4, 5, 6, 1, 2, 3},
+	}} {
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			q := From(tc.prevContent)
+			q.PushFront(tc.push...)
+			got := make([]int, q.Len())
+			for i, x := range q.All() {
+				got[i] = x
+			}
+			if !slices.Equal(got, tc.want) {
+				t.Errorf("%d: PushFront(%d) = %d, want %d", tc.prevContent, tc.push, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestPushBack(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		desc        string
+		prevContent []int
+		push        []int
+		want        []int
+	}{{
+		desc:        "PushNil",
+		prevContent: nil,
+		push:        []int{1},
+		want:        []int{1},
+	}, {
+		desc:        "PushExisting",
+		prevContent: []int{1, 2, 3},
+		push:        []int{4, 5, 6},
+		want:        []int{1, 2, 3, 4, 5, 6},
+	}} {
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			q := From(tc.prevContent)
+			q.PushBack(tc.push...)
+			got := make([]int, q.Len())
+			for i, x := range q.All() {
+				got[i] = x
+			}
+			if !slices.Equal(got, tc.want) {
+				t.Errorf("%d: PushBack(%d) = %d, want %d", tc.prevContent, tc.push, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestPopFrontPushBackB(t *testing.T) {
+	t.Parallel()
+
+	q := From([]int{1, 2, 3})
+	q.PopFront()
+	q.PushBack(4)
+	q.PushBack(5)
+	got := make([]int, q.Len())
+	for i, x := range q.All() {
+		got[i] = x
+	}
+	want := []int{2, 3, 4, 5}
+	if !slices.Equal(got, want) {
+		t.Errorf("Contents = %d, want %d", got, want)
+	}
+}
+
+func TestPopFrontPushBackC(t *testing.T) {
+	t.Parallel()
+
+	q := From([]int{1, 2, 3})
+	q.PopFront()
+	q.PopFront()
+	q.PushBack(4)
+	q.PushBack(5)
+	q.PushBack(6)
+	got := make([]int, q.Len())
+	for i, x := range q.All() {
+		got[i] = x
+	}
+	want := []int{3, 4, 5, 6}
+	if !slices.Equal(got, want) {
+		t.Errorf("Contents = %d, want %d", got, want)
+	}
+}
+
+func TestPopFrontPushFront(t *testing.T) {
+	t.Parallel()
+
+	q := From([]int{1, 2, 3})
+	q.PopFront()
+	q.PopFront()
+	q.PushFront(4, 5)
+	if got, want := q.Cap(), 3; got != want {
+		t.Errorf("Cap() = %d, want %d", got, want)
+	}
+	got := make([]int, q.Len())
+	for i, x := range q.All() {
+		got[i] = x
+	}
+	want := []int{4, 5, 3}
+	if !slices.Equal(got, want) {
+		t.Errorf("Contents = %d, want %d", got, want)
+	}
+}
+
+func TestReset(t *testing.T) {
+	t.Parallel()
+
+	q := From([]int{1, 2, 3, 4, 5})
+	q.Reset()
+	if got, want := q.Len(), 0; got != want {
+		t.Errorf("After Reset() Len() = %d, want %d", got, want)
+	}
+	if got, want := q.Cap(), 5; got != want {
+		t.Errorf("After Reset() Cap() = %d, want %d", got, want)
+	}
+}
+
+func TestPopAll(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		desc    string
+		content []int
+	}{{
+		desc:    "PopAll",
+		content: []int{1, 2, 3},
+	}, {
+		desc:    "PopAllEmpty",
+		content: make([]int, 0, 3),
+	}} {
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			q := From(tc.content)
+			got := make([]int, 0, q.Len())
+			for x := range q.PopAll() {
+				got = append(got, x)
+			}
+			if got, want := q.Len(), 0; got != want {
+				t.Errorf("Len() = %d, want %d", got, want)
+			}
+			if !slices.Equal(got, tc.content) {
+				t.Errorf("PopAll() returned values %d, want %d", got, tc.content)
+			}
+		})
+	}
+}
+
+func TestString(t *testing.T) {
+	t.Parallel()
+
+	in := []int{1, 2, 3, 4, 5}
+	q := From(in)
+	const want = "[1 2 3 4 5]"
+	got := q.String()
+	if got != want {
+		t.Errorf("%d: String() = %q, want %q", in, got, want)
+	}
+}