119 lines
3.2 KiB
Go
119 lines
3.2 KiB
Go
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")
|
|
}
|