[🤖] Add Unit-Tests

langext/sort_test.go

@@ -0,0 +1,118 @@
+package langext
+
+import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"testing"
+)
+
+func TestSortInPlace(t *testing.T) {
+	arr := []int{3, 1, 2}
+	Sort(arr)
+	tst.AssertArrayEqual(t, arr, []int{1, 2, 3})
+}
+
+func TestSortStrings(t *testing.T) {
+	arr := []string{"c", "a", "b"}
+	Sort(arr)
+	tst.AssertArrayEqual(t, arr, []string{"a", "b", "c"})
+}
+
+func TestAsSorted(t *testing.T) {
+	src := []int{3, 1, 2}
+	out := AsSorted(src)
+	tst.AssertArrayEqual(t, out, []int{1, 2, 3})
+	// original unchanged
+	tst.AssertArrayEqual(t, src, []int{3, 1, 2})
+}
+
+func TestSortStable(t *testing.T) {
+	arr := []int{3, 1, 2, 1}
+	SortStable(arr)
+	tst.AssertArrayEqual(t, arr, []int{1, 1, 2, 3})
+}
+
+func TestAsSortedStable(t *testing.T) {
+	src := []int{3, 1, 2, 1}
+	out := AsSortedStable(src)
+	tst.AssertArrayEqual(t, out, []int{1, 1, 2, 3})
+	tst.AssertArrayEqual(t, src, []int{3, 1, 2, 1})
+}
+
+func TestIsSorted(t *testing.T) {
+	tst.AssertEqual(t, IsSorted([]int{1, 2, 3}), true)
+	tst.AssertEqual(t, IsSorted([]int{3, 2, 1}), false)
+	tst.AssertEqual(t, IsSorted([]int{1, 1, 1}), true)
+	tst.AssertEqual(t, IsSorted([]int{}), true)
+}
+
+func TestSortSlice(t *testing.T) {
+	arr := []int{3, 1, 2}
+	SortSlice(arr, func(a, b int) bool { return a < b })
+	tst.AssertArrayEqual(t, arr, []int{1, 2, 3})
+}
+
+func TestAsSortedSlice(t *testing.T) {
+	src := []int{3, 1, 2}
+	out := AsSortedSlice(src, func(a, b int) bool { return a > b })
+	tst.AssertArrayEqual(t, out, []int{3, 2, 1})
+	tst.AssertArrayEqual(t, src, []int{3, 1, 2})
+}
+
+func TestSortSliceStable(t *testing.T) {
+	arr := []int{3, 1, 2, 1}
+	SortSliceStable(arr, func(a, b int) bool { return a < b })
+	tst.AssertArrayEqual(t, arr, []int{1, 1, 2, 3})
+}
+
+func TestAsSortedSliceStable(t *testing.T) {
+	src := []int{3, 1, 2, 1}
+	out := AsSortedSliceStable(src, func(a, b int) bool { return a < b })
+	tst.AssertArrayEqual(t, out, []int{1, 1, 2, 3})
+	tst.AssertArrayEqual(t, src, []int{3, 1, 2, 1})
+}
+
+func TestIsSliceSorted(t *testing.T) {
+	tst.AssertEqual(t, IsSliceSorted([]int{1, 2, 3}, func(a, b int) bool { return a < b }), true)
+	tst.AssertEqual(t, IsSliceSorted([]int{3, 2, 1}, func(a, b int) bool { return a < b }), false)
+}
+
+type byKey struct {
+	key int
+	v   string
+}
+
+func TestSortBy(t *testing.T) {
+	arr := []byKey{{3, "c"}, {1, "a"}, {2, "b"}}
+	SortBy(arr, func(v byKey) int { return v.key })
+	tst.AssertEqual(t, arr[0].v, "a")
+	tst.AssertEqual(t, arr[1].v, "b")
+	tst.AssertEqual(t, arr[2].v, "c")
+}
+
+func TestAsSortedBy(t *testing.T) {
+	src := []byKey{{3, "c"}, {1, "a"}, {2, "b"}}
+	out := AsSortedBy(src, func(v byKey) int { return v.key })
+	tst.AssertEqual(t, out[0].v, "a")
+	tst.AssertEqual(t, out[2].v, "c")
+	// source unchanged
+	tst.AssertEqual(t, src[0].v, "c")
+}
+
+func TestSortByStable(t *testing.T) {
+	arr := []byKey{{1, "a1"}, {1, "a2"}, {0, "b"}}
+	SortByStable(arr, func(v byKey) int { return v.key })
+	tst.AssertEqual(t, arr[0].v, "b")
+	// stable order for ties
+	tst.AssertEqual(t, arr[1].v, "a1")
+	tst.AssertEqual(t, arr[2].v, "a2")
+}
+
+func TestAsSortedByStable(t *testing.T) {
+	src := []byKey{{1, "a1"}, {1, "a2"}, {0, "b"}}
+	out := AsSortedByStable(src, func(v byKey) int { return v.key })
+	tst.AssertEqual(t, out[0].v, "b")
+	tst.AssertEqual(t, out[1].v, "a1")
+	tst.AssertEqual(t, out[2].v, "a2")
+	// source unchanged
+	tst.AssertEqual(t, src[0].v, "a1")
+}