220 lines
6.8 KiB
Go
220 lines
6.8 KiB
Go
package slicex
|
|
|
|
import (
|
|
"github.com/stretchr/testify/assert"
|
|
"testing"
|
|
)
|
|
|
|
func TestMap(t *testing.T) {
|
|
a := []int{0, 1}
|
|
b := Map(a, func(v int) int {
|
|
return v + 1
|
|
})
|
|
assert.Equal(t, []int{0, 1}, a, "map.int")
|
|
assert.Equal(t, []int{1, 2}, b, "map.int")
|
|
|
|
a1 := []string{"a", "b"}
|
|
b1 := Map(a1, func(v string) string {
|
|
return v + "1"
|
|
})
|
|
assert.Equal(t, []string{"a", "b"}, a1, "map.string")
|
|
assert.Equal(t, []string{"a1", "b1"}, b1, "map.string")
|
|
}
|
|
|
|
func TestFilter(t *testing.T) {
|
|
assert.Equal(t, []int{1, 2, 3}, Filter([]int{0, 1, 2, 3}, func(v int) bool {
|
|
return v > 0
|
|
}), "map.int")
|
|
assert.Equal(t, []string{"c"}, Filter([]string{"a", "b", "c", "a", "b"}, func(v string) bool {
|
|
return v == "c"
|
|
}), "map.string")
|
|
}
|
|
|
|
func TestStringToInterface(t *testing.T) {
|
|
tests := []struct {
|
|
tag string
|
|
input []string
|
|
expected []interface{}
|
|
}{
|
|
{"t0", []string{"a", "b", "c"}, []interface{}{"a", "b", "c"}},
|
|
{"t1", nil, []interface{}{}},
|
|
}
|
|
for _, test := range tests {
|
|
v := StringToInterface(test.input)
|
|
assert.Equal(t, test.expected, v, test.tag)
|
|
}
|
|
}
|
|
|
|
func BenchmarkStringToInterface(b *testing.B) {
|
|
for n := 0; n < b.N; n++ {
|
|
StringToInterface([]string{"a", "b", "c"})
|
|
}
|
|
}
|
|
|
|
func TestStringSliceEqual(t *testing.T) {
|
|
testCases := []struct {
|
|
A []string
|
|
B []string
|
|
CaseSensitive bool
|
|
IgnoreEmpty bool
|
|
Trim bool
|
|
Except bool
|
|
}{
|
|
{[]string{}, []string{}, false, true, true, true},
|
|
{[]string{"a", "b", "c"}, []string{"a", "b", "c"}, true, false, true, true},
|
|
{[]string{"a", "b", "c"}, []string{"a", "b ", " c"}, true, false, true, true},
|
|
{[]string{"a", "b", "c"}, []string{"a", "b ", " c"}, true, false, false, false},
|
|
{[]string{"a", "b", "c", ""}, []string{"a", "b ", " c"}, true, false, true, false},
|
|
{[]string{"a", "b", "c", ""}, []string{"a", "b ", " c"}, true, true, true, true},
|
|
{[]string{"a", "b", "c", ""}, []string{"a", "b ", " c", ""}, true, false, true, true},
|
|
{[]string{"A", "B", "C"}, []string{"a", "b", "c"}, true, true, true, false},
|
|
{[]string{"A", "B", "C"}, []string{"a", "b", "c"}, false, true, true, true},
|
|
{[]string{"A", "B", "C"}, []string{"b", "c", "a"}, false, true, true, true},
|
|
{[]string{" ", "", " "}, []string{""}, false, true, true, true},
|
|
{[]string{}, []string{" ", ""}, false, true, true, true},
|
|
{[]string{}, []string{"a", "b"}, false, true, true, false},
|
|
{nil, []string{}, false, true, true, false},
|
|
{[]string{}, nil, false, true, true, false},
|
|
{nil, nil, false, true, true, true},
|
|
}
|
|
for i, testCase := range testCases {
|
|
equal := StringSliceEqual(testCase.A, testCase.B, testCase.CaseSensitive, testCase.IgnoreEmpty, testCase.Trim)
|
|
if equal != testCase.Except {
|
|
t.Errorf("%d except %v actual %v", i, testCase.Except, equal)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIntSliceEqual(t *testing.T) {
|
|
testCases := []struct {
|
|
A []int
|
|
B []int
|
|
Except bool
|
|
}{
|
|
{[]int{}, []int{}, true},
|
|
{[]int{0, 1, 2}, []int{0, 1, 2}, true},
|
|
{[]int{0, 1, 2}, []int{2, 1, 0}, true},
|
|
{[]int{0, 1, 2}, []int{1, 2}, false},
|
|
{[]int{0, 1, 1, 2}, []int{0, 1, 2}, false},
|
|
{[]int{0, 1, 1, 2}, []int{0, 1, 2, 1}, true},
|
|
{nil, []int{}, false},
|
|
{nil, nil, true},
|
|
{[]int{}, nil, false},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
equal := IntSliceEqual(testCase.A, testCase.B)
|
|
if equal != testCase.Except {
|
|
t.Errorf("%d except %v actual %v", i, testCase.Except, equal)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStringSliceReverse(t *testing.T) {
|
|
testCases := []struct {
|
|
Before []string
|
|
After []string
|
|
}{
|
|
{[]string{"a"}, []string{"a"}},
|
|
{[]string{"a", "b"}, []string{"b", "a"}},
|
|
{[]string{"a", "b", "c"}, []string{"c", "b", "a"}},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
values := StringSliceReverse(testCase.Before)
|
|
if len(values) != len(testCase.After) {
|
|
t.Errorf("%#v reverse after value except: %#v, actual: %#v", testCase.Before, testCase.After, values)
|
|
} else {
|
|
for j, v := range values {
|
|
if testCase.After[j] != v {
|
|
t.Errorf("%#v reverse after value except: %#v, actual: %#v", testCase.Before, testCase.After, values)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStringSliceDiff(t *testing.T) {
|
|
testCases := []struct {
|
|
Number int
|
|
OriginalValues [][]string
|
|
DiffValue []string
|
|
}{
|
|
{1, [][]string{{"a", "b", "c"}, {"a", "b", "d"}}, []string{"c"}},
|
|
{1, [][]string{{"a", "b", "c"}, {"a"}}, []string{"b", "c"}},
|
|
{2, [][]string{{"a", "b", "d"}, {"a", "b", "c"}}, []string{"d"}},
|
|
{3, [][]string{{"a", "b", "c"}, {"a", "b", "c"}}, []string{}},
|
|
{4, [][]string{{"a", "b", ""}, {"a", "b", "c"}}, []string{""}},
|
|
{5, [][]string{{"a", "b", "c"}, {"a", "b"}, {"c"}}, []string{}},
|
|
{6, [][]string{{"a"}, {"b"}, {"c", "c1"}, {"d"}}, []string{"a"}},
|
|
{7, [][]string{nil, {"a"}, {"b"}, {"c", "c1"}, {"d"}}, []string{}},
|
|
{8, [][]string{nil}, []string{}},
|
|
{9, [][]string{nil, nil, nil}, []string{}},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
values := StringSliceDiff(testCase.OriginalValues...)
|
|
if !StringSliceEqual(values, testCase.DiffValue, true, false, true) {
|
|
t.Errorf("%d: diff values except: %#v, actual: %#v", testCase.Number, testCase.DiffValue, values)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIntSliceDiff(t *testing.T) {
|
|
testCases := []struct {
|
|
Number int
|
|
OriginalValues [][]int
|
|
DiffValue []int
|
|
}{
|
|
{1, [][]int{{1, 2, 3}, {1, 2, 4}}, []int{3}},
|
|
{2, [][]int{{1, 2, 3}, {1, 2, 2, 3}, {3, 4, 5}}, []int{}},
|
|
{3, [][]int{{1, 2, 3}, {1}, {2}, {3}}, []int{}},
|
|
{4, [][]int{{1, 2, 3}, {1, 2, 4, 0, 2, 1}}, []int{3}},
|
|
{5, [][]int{{1, 2, 2, 3}, {1}}, []int{2, 2, 3}},
|
|
{6, [][]int{}, []int{}},
|
|
{7, [][]int{nil, {1, 2, 3}}, []int{}},
|
|
{8, [][]int{nil, nil, {1, 2, 3}}, []int{}},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
values := IntSliceDiff(testCase.OriginalValues...)
|
|
if !IntSliceEqual(values, testCase.DiffValue) {
|
|
t.Errorf("%d: diff values except: %#v, actual: %#v", testCase.Number, testCase.DiffValue, values)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestToInterface(t *testing.T) {
|
|
type args struct {
|
|
values interface{}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want []interface{}
|
|
}{
|
|
{"t1", args{[]int{1, 2, 3}}, []interface{}{1, 2, 3}},
|
|
{"t2", args{[]string{"A", "B", "C"}}, []interface{}{"A", "B", "C"}},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var value interface{}
|
|
switch tt.args.values.(type) {
|
|
case []string:
|
|
value = ToInterface(tt.args.values.([]string))
|
|
case []int:
|
|
value = ToInterface(tt.args.values.([]int))
|
|
}
|
|
assert.Equalf(t, tt.want, value, "ToInterface(%v)", tt.args.values)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestChunk(t *testing.T) {
|
|
assert.ElementsMatch(t, Chunk([]int{1, 2, 3}, 0), [][]int{{1, 2, 3}}, "int0")
|
|
assert.ElementsMatch(t, Chunk([]int{1, 2, 3}, 1), [][]int{{1}, {2}, {3}}, "int1")
|
|
assert.ElementsMatch(t, Chunk([]int{1, 2, 3}, 2), [][]int{{1, 2}, {3}}, "int2")
|
|
assert.ElementsMatch(t, Chunk([]int{1, 2, 3}, 3), [][]int{{1, 2, 3}}, "int3")
|
|
}
|