go-zero/core/stringx/strings_test.go
Kevin Wan 69068cdaf0
feat: support env tag in config (#2577)
* feat: support env tag in config

* chore: add more tests

* chore: add more tests, add stringx.Join

* fix: test fail

* chore: remove print code

* chore: rename variable
2022-11-11 23:17:09 +08:00

428 lines
7.1 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package stringx
import (
"path"
"testing"
"github.com/stretchr/testify/assert"
)
func TestNotEmpty(t *testing.T) {
cases := []struct {
args []string
expect bool
}{
{
args: []string{"a", "b", "c"},
expect: true,
},
{
args: []string{"a", "", "c"},
expect: false,
},
{
args: []string{"a"},
expect: true,
},
{
args: []string{""},
expect: false,
},
{
args: []string{},
expect: true,
},
}
for _, each := range cases {
t.Run(path.Join(each.args...), func(t *testing.T) {
assert.Equal(t, each.expect, NotEmpty(each.args...))
})
}
}
func TestContainsString(t *testing.T) {
cases := []struct {
slice []string
value string
expect bool
}{
{[]string{"1"}, "1", true},
{[]string{"1"}, "2", false},
{[]string{"1", "2"}, "1", true},
{[]string{"1", "2"}, "3", false},
{nil, "3", false},
{nil, "", false},
}
for _, each := range cases {
t.Run(path.Join(each.slice...), func(t *testing.T) {
actual := Contains(each.slice, each.value)
assert.Equal(t, each.expect, actual)
})
}
}
func TestFilter(t *testing.T) {
cases := []struct {
input string
ignores []rune
expect string
}{
{``, nil, ``},
{`abcd`, nil, `abcd`},
{`ab,cd,ef`, []rune{','}, `abcdef`},
{`ab, cd,ef`, []rune{',', ' '}, `abcdef`},
{`ab, cd, ef`, []rune{',', ' '}, `abcdef`},
{`ab, cd, ef, `, []rune{',', ' '}, `abcdef`},
}
for _, each := range cases {
t.Run(each.input, func(t *testing.T) {
actual := Filter(each.input, func(r rune) bool {
for _, x := range each.ignores {
if x == r {
return true
}
}
return false
})
assert.Equal(t, each.expect, actual)
})
}
}
func TestFirstN(t *testing.T) {
tests := []struct {
name string
input string
n int
ellipsis string
expect string
}{
{
name: "english string",
input: "anything that we use",
n: 8,
expect: "anything",
},
{
name: "english string with ellipsis",
input: "anything that we use",
n: 8,
ellipsis: "...",
expect: "anything...",
},
{
name: "english string more",
input: "anything that we use",
n: 80,
expect: "anything that we use",
},
{
name: "chinese string",
input: "我是中国人",
n: 2,
expect: "我是",
},
{
name: "chinese string with ellipsis",
input: "我是中国人",
n: 2,
ellipsis: "...",
expect: "我是...",
},
{
name: "chinese string",
input: "我是中国人",
n: 10,
expect: "我是中国人",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
assert.Equal(t, test.expect, FirstN(test.input, test.n, test.ellipsis))
})
}
}
func TestJoin(t *testing.T) {
tests := []struct {
name string
input []string
expect string
}{
{
name: "all blanks",
input: []string{"", ""},
expect: "",
},
{
name: "two values",
input: []string{"012", "abc"},
expect: "012.abc",
},
{
name: "last blank",
input: []string{"abc", ""},
expect: "abc",
},
{
name: "first blank",
input: []string{"", "abc"},
expect: "abc",
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
assert.Equal(t, test.expect, Join('.', test.input...))
})
}
}
func TestRemove(t *testing.T) {
cases := []struct {
input []string
remove []string
expect []string
}{
{
input: []string{"a", "b", "a", "c"},
remove: []string{"a", "b"},
expect: []string{"c"},
},
{
input: []string{"b", "c"},
remove: []string{"a"},
expect: []string{"b", "c"},
},
{
input: []string{"b", "a", "c"},
remove: []string{"a"},
expect: []string{"b", "c"},
},
{
input: []string{},
remove: []string{"a"},
expect: []string{},
},
}
for _, each := range cases {
t.Run(path.Join(each.input...), func(t *testing.T) {
assert.ElementsMatch(t, each.expect, Remove(each.input, each.remove...))
})
}
}
func TestReverse(t *testing.T) {
cases := []struct {
input string
expect string
}{
{
input: "abcd",
expect: "dcba",
},
{
input: "",
expect: "",
},
{
input: "我爱中国",
expect: "国中爱我",
},
}
for _, each := range cases {
t.Run(each.input, func(t *testing.T) {
assert.Equal(t, each.expect, Reverse(each.input))
})
}
}
func TestSubstr(t *testing.T) {
cases := []struct {
input string
start int
stop int
err error
expect string
}{
{
input: "abcdefg",
start: 1,
stop: 4,
expect: "bcd",
},
{
input: "我爱中国3000遍even more",
start: 1,
stop: 9,
expect: "爱中国3000遍",
},
{
input: "abcdefg",
start: -1,
stop: 4,
err: ErrInvalidStartPosition,
expect: "",
},
{
input: "abcdefg",
start: 100,
stop: 4,
err: ErrInvalidStartPosition,
expect: "",
},
{
input: "abcdefg",
start: 1,
stop: -1,
err: ErrInvalidStopPosition,
expect: "",
},
{
input: "abcdefg",
start: 1,
stop: 100,
err: ErrInvalidStopPosition,
expect: "",
},
}
for _, each := range cases {
t.Run(each.input, func(t *testing.T) {
val, err := Substr(each.input, each.start, each.stop)
assert.Equal(t, each.err, err)
if err == nil {
assert.Equal(t, each.expect, val)
}
})
}
}
func TestTakeOne(t *testing.T) {
cases := []struct {
valid string
or string
expect string
}{
{"", "", ""},
{"", "1", "1"},
{"1", "", "1"},
{"1", "2", "1"},
}
for _, each := range cases {
t.Run(each.valid, func(t *testing.T) {
actual := TakeOne(each.valid, each.or)
assert.Equal(t, each.expect, actual)
})
}
}
func TestTakeWithPriority(t *testing.T) {
tests := []struct {
fns []func() string
expect string
}{
{
fns: []func() string{
func() string {
return "first"
},
func() string {
return "second"
},
func() string {
return "third"
},
},
expect: "first",
},
{
fns: []func() string{
func() string {
return ""
},
func() string {
return "second"
},
func() string {
return "third"
},
},
expect: "second",
},
{
fns: []func() string{
func() string {
return ""
},
func() string {
return ""
},
func() string {
return "third"
},
},
expect: "third",
},
{
fns: []func() string{
func() string {
return ""
},
func() string {
return ""
},
func() string {
return ""
},
},
expect: "",
},
}
for _, test := range tests {
t.Run(RandId(), func(t *testing.T) {
val := TakeWithPriority(test.fns...)
assert.Equal(t, test.expect, val)
})
}
}
func TestUnion(t *testing.T) {
first := []string{
"one",
"two",
"three",
}
second := []string{
"zero",
"two",
"three",
"four",
}
union := Union(first, second)
contains := func(v string) bool {
for _, each := range union {
if v == each {
return true
}
}
return false
}
assert.Equal(t, 5, len(union))
assert.True(t, contains("zero"))
assert.True(t, contains("one"))
assert.True(t, contains("two"))
assert.True(t, contains("three"))
assert.True(t, contains("four"))
}