You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
129 lines
3.4 KiB
Go
129 lines
3.4 KiB
Go
package narr_test
|
|
|
|
import (
|
|
"fmt"
|
|
"git.noahlan.cn/noahlan/ntool/narr"
|
|
"git.noahlan.cn/noahlan/ntool/ntest/assert"
|
|
"testing"
|
|
)
|
|
|
|
func TestReverse(t *testing.T) {
|
|
ss := []string{"a", "b", "c"}
|
|
|
|
narr.Reverse(ss)
|
|
assert.Eq(t, []string{"c", "b", "a"}, ss)
|
|
}
|
|
|
|
func TestStringsRemove(t *testing.T) {
|
|
ss := []string{"a", "b", "c"}
|
|
ns := narr.StringsRemove(ss, "b")
|
|
|
|
assert.Contains(t, ns, "a")
|
|
assert.NotContains(t, ns, "b")
|
|
assert.Len(t, ns, 2)
|
|
}
|
|
|
|
func TestStringsFilter(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
ss := narr.StringsFilter([]string{"a", "", "b", ""})
|
|
is.Eq([]string{"a", "b"}, ss)
|
|
}
|
|
|
|
func TestTrimStrings(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
// TrimStrings
|
|
ss := narr.TrimStrings([]string{" a", "b ", " c "})
|
|
is.Eq("[a b c]", fmt.Sprint(ss))
|
|
ss = narr.TrimStrings([]string{",a", "b.", ",.c,"}, ",.")
|
|
is.Eq("[a b c]", fmt.Sprint(ss))
|
|
ss = narr.TrimStrings([]string{",a", "b.", ",.c,"}, ",", ".")
|
|
is.Eq("[a b c]", fmt.Sprint(ss))
|
|
}
|
|
|
|
func TestGetRandomOne(t *testing.T) {
|
|
is := assert.New(t)
|
|
// int slice
|
|
intSlice := []int{1, 2, 3, 4, 5, 6}
|
|
intVal := narr.GetRandomOne(intSlice)
|
|
intVal1 := narr.GetRandomOne(intSlice)
|
|
for intVal == intVal1 {
|
|
intVal1 = narr.GetRandomOne(intSlice)
|
|
}
|
|
|
|
assert.IsType(t, 0, intVal)
|
|
is.True(narr.HasValue(intSlice, intVal))
|
|
assert.IsType(t, 0, intVal1)
|
|
is.True(narr.HasValue(intSlice, intVal1))
|
|
assert.NotEq(t, intVal, intVal1)
|
|
|
|
// int array
|
|
intArray := []int{1, 2, 3, 4, 5, 6}
|
|
intReturned := narr.GetRandomOne(intArray)
|
|
intReturned1 := narr.GetRandomOne(intArray)
|
|
for intReturned == intReturned1 {
|
|
intReturned1 = narr.GetRandomOne(intArray)
|
|
}
|
|
assert.IsType(t, 0, intReturned)
|
|
is.True(narr.Contains(intArray, intReturned))
|
|
assert.IsType(t, 0, intReturned1)
|
|
is.True(narr.Contains(intArray, intReturned1))
|
|
assert.NotEq(t, intReturned, intReturned1)
|
|
|
|
// string slice
|
|
strSlice := []string{"aa", "bb", "cc", "dd"}
|
|
strVal := narr.GetRandomOne(strSlice)
|
|
strVal1 := narr.GetRandomOne(strSlice)
|
|
for strVal == strVal1 {
|
|
strVal1 = narr.GetRandomOne(strSlice)
|
|
}
|
|
|
|
assert.IsType(t, "", strVal)
|
|
is.True(narr.Contains(strSlice, strVal))
|
|
assert.IsType(t, "", strVal1)
|
|
is.True(narr.Contains(strSlice, strVal1))
|
|
assert.NotEq(t, strVal, strVal1)
|
|
|
|
// string array
|
|
strArray := []string{"aa", "bb", "cc", "dd"}
|
|
strReturned := narr.GetRandomOne(strArray)
|
|
strReturned1 := narr.GetRandomOne(strArray)
|
|
for strReturned == strReturned1 {
|
|
strReturned1 = narr.GetRandomOne(strArray)
|
|
}
|
|
|
|
assert.IsType(t, "", strReturned)
|
|
is.True(narr.Contains(strArray, strReturned))
|
|
assert.IsType(t, "", strReturned1)
|
|
is.True(narr.Contains(strArray, strReturned1))
|
|
assert.NotEq(t, strReturned, strReturned1)
|
|
|
|
// byte slice
|
|
byteSlice := []byte("abcdefg")
|
|
byteVal := narr.GetRandomOne(byteSlice)
|
|
byteVal1 := narr.GetRandomOne(byteSlice)
|
|
for byteVal == byteVal1 {
|
|
byteVal1 = narr.GetRandomOne(byteSlice)
|
|
}
|
|
|
|
assert.IsType(t, byte('a'), byteVal)
|
|
is.True(narr.Contains(byteSlice, byteVal))
|
|
assert.IsType(t, byte('a'), byteVal1)
|
|
is.True(narr.Contains(byteSlice, byteVal1))
|
|
assert.NotEq(t, byteVal, byteVal1)
|
|
|
|
is.Panics(func() {
|
|
narr.RandomOne([]int{})
|
|
})
|
|
}
|
|
|
|
func TestUnique(t *testing.T) {
|
|
assert.Eq(t, []int{2, 3, 4}, narr.Unique[int]([]int{2, 3, 2, 4}))
|
|
assert.Eq(t, []uint{2, 3, 4}, narr.Unique([]uint{2, 3, 2, 4}))
|
|
assert.Eq(t, []string{"ab", "bc", "cd"}, narr.Unique([]string{"ab", "bc", "ab", "cd"}))
|
|
|
|
assert.Eq(t, 1, narr.IndexOf(3, []int{2, 3, 4}))
|
|
assert.Eq(t, -1, narr.IndexOf(5, []int{2, 3, 4}))
|
|
}
|