548 lines
17 KiB
Go
548 lines
17 KiB
Go
|
package stringx
|
|||
|
|
|
|||
|
|
import (
|
|||
|
|
"strings"
|
|||
|
|
"testing"
|
|||
|
|
|
|||
|
|
"git.cloudyne.io/go/hiscaler-gox/slicex"
|
|||
|
|
"github.com/stretchr/testify/assert"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
func TestIsEmpty(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
String string
|
|||
|
|
IsEmpty bool
|
|||
|
|
}{
|
|||
|
|
{"A", false},
|
|||
|
|
{"", true},
|
|||
|
|
{" ", false},
|
|||
|
|
{" ", false},
|
|||
|
|
{" ", false},
|
|||
|
|
{`
|
|||
|
|
|
|||
|
|
|
|||
|
|
`, false},
|
|||
|
|
{`
|
|||
|
|
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
`, false},
|
|||
|
|
}
|
|||
|
|
for i, testCase := range testCases {
|
|||
|
|
b := IsEmpty(testCase.String)
|
|||
|
|
if b != testCase.IsEmpty {
|
|||
|
|
t.Errorf("%d: %s except %v, actual %v", i, testCase.String, testCase.IsEmpty, b)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestIsBlank(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
String string
|
|||
|
|
IsEmpty bool
|
|||
|
|
}{
|
|||
|
|
{"A", false},
|
|||
|
|
{"", true},
|
|||
|
|
{" ", true},
|
|||
|
|
{" ", true},
|
|||
|
|
{" ", true},
|
|||
|
|
{`
|
|||
|
|
|
|||
|
|
|
|||
|
|
`, true},
|
|||
|
|
{`
|
|||
|
|
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
`, false},
|
|||
|
|
}
|
|||
|
|
for i, testCase := range testCases {
|
|||
|
|
b := IsBlank(testCase.String)
|
|||
|
|
if b != testCase.IsEmpty {
|
|||
|
|
t.Errorf("%d: %s except %v, actual %v", i, testCase.String, testCase.IsEmpty, b)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestContainsChinese(t *testing.T) {
|
|||
|
|
type testCast struct {
|
|||
|
|
String string
|
|||
|
|
Has bool
|
|||
|
|
}
|
|||
|
|
testCasts := []testCast{
|
|||
|
|
{"", false},
|
|||
|
|
{"a", false},
|
|||
|
|
{"A_B", false},
|
|||
|
|
{"A_中B", true},
|
|||
|
|
}
|
|||
|
|
for _, tc := range testCasts {
|
|||
|
|
has := ContainsChinese(tc.String)
|
|||
|
|
if has != tc.Has {
|
|||
|
|
t.Errorf("%s except %v, actual：%v", tc.String, tc.Has, has)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestToNarrow(t *testing.T) {
|
|||
|
|
testCasts := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{"t-letter", "aｂｃ", "abc"},
|
|||
|
|
{"t-number", "０１２３４５６７８９", "0123456789"},
|
|||
|
|
{"t-letter-number", "a０", "a0"},
|
|||
|
|
{"t-other", "～！＠#＄％＾＆＊（）－＋？", "~!@#$%^&*()-+?"},
|
|||
|
|
}
|
|||
|
|
for _, tc := range testCasts {
|
|||
|
|
value := ToNarrow(tc.string)
|
|||
|
|
assert.Equal(t, tc.expected, value, tc.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestToWiden(t *testing.T) {
|
|||
|
|
testCasts := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{"t-letter", "abc", "ａｂｃ"},
|
|||
|
|
{"t-number", "0123456789", "０１２３４５６７８９"},
|
|||
|
|
{"t-letter-number", "a0", "ａ０"},
|
|||
|
|
{"t-other", "~!@#$%^&*()-+?", "～！＠＃＄％＾＆＊（）－＋？"},
|
|||
|
|
}
|
|||
|
|
for _, tc := range testCasts {
|
|||
|
|
value := ToWiden(tc.string)
|
|||
|
|
assert.Equal(t, tc.expected, value, tc.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestSplit(t *testing.T) {
|
|||
|
|
type testCast struct {
|
|||
|
|
Number int
|
|||
|
|
String string
|
|||
|
|
Seps []string
|
|||
|
|
Values []string
|
|||
|
|
}
|
|||
|
|
testCasts := []testCast{
|
|||
|
|
{1, "abc", []string{}, []string{"abc"}},
|
|||
|
|
{2, "a b c", []string{}, []string{"a b c"}},
|
|||
|
|
{3, "a b c,d", []string{}, []string{"a b c,d"}},
|
|||
|
|
{4, "a b c,d", []string{",", " "}, []string{"a", "b", "c", "d"}},
|
|||
|
|
{5, "a,b,c,d", []string{",", " "}, []string{"a", "b", "c", "d"}},
|
|||
|
|
{6, "a,b,c,d e", []string{",", " "}, []string{"a", "b", "c", "d", "e"}},
|
|||
|
|
{7, "a.,b,c,d e", []string{",", " "}, []string{"a.", "b", "c", "d", "e"}},
|
|||
|
|
{8, "a.,b,c,d e", []string{",", ".", " "}, []string{"a", "b", "c", "d", "e"}},
|
|||
|
|
{9, "a.,b,c,d e", []string{",", " "}, []string{"a.", "b", "c", "d", "e"}},
|
|||
|
|
{10, "a.,b,c,d e", []string{",", "", " "}, []string{"a", ".", "b", "c", "d", "e"}},
|
|||
|
|
{11, "hello, world!!!", []string{",", " ", "!"}, []string{"hello", "world"}},
|
|||
|
|
{12, "WaterWipes Original Baby Wipes, 99.9% Water, Unscented & Hypoallergenic for Sensitive Newborn Skin, 3 Packs (180 Count)", []string{",", " ", "!"}, []string{"WaterWipes", "Original", "Baby", "Wipes", "99.9%", "Water", "Unscented", "&", "Hypoallergenic", "for", "Sensitive", "Newborn", "Skin", "3", "Packs", "(180", "Count)"}},
|
|||
|
|
}
|
|||
|
|
for _, tc := range testCasts {
|
|||
|
|
values := Split(tc.String, tc.Seps...)
|
|||
|
|
if !slicex.StringSliceEqual(values, tc.Values, false, false, true) {
|
|||
|
|
t.Errorf("%d except %#v, actual：%#v", tc.Number, tc.Values, values)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestString(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
Number int
|
|||
|
|
Value interface{}
|
|||
|
|
Except string
|
|||
|
|
}{
|
|||
|
|
{1, false, "false"},
|
|||
|
|
{2, true, "true"},
|
|||
|
|
{3, 1, "1"},
|
|||
|
|
{4, 1.1, "1.1"},
|
|||
|
|
{5, "abc", "abc"},
|
|||
|
|
{6, [2]int{1, 2}, "[1,2]"},
|
|||
|
|
{7, []int{1, 2}, "[1,2]"},
|
|||
|
|
{8, []string{"a", "b"}, `["a","b"]`},
|
|||
|
|
{9, struct {
|
|||
|
|
ID int
|
|||
|
|
Name string
|
|||
|
|
}{ID: 1, Name: "John"}, `{"ID":1,"Name":"John"}`},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
s := String(testCase.Value)
|
|||
|
|
if !strings.EqualFold(s, testCase.Except) {
|
|||
|
|
t.Errorf("%d except: %s, actual: %s", testCase.Number, testCase.Except, s)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestRemoveEmoji(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
Number int
|
|||
|
|
BeforeString string
|
|||
|
|
AfterString string
|
|||
|
|
}{
|
|||
|
|
{1, "👶hi", "hi"},
|
|||
|
|
{2, "1👰", "1"},
|
|||
|
|
{3, "1👉2🤟👉👰3🤟👉👶你好🤟", "123你好"},
|
|||
|
|
{4, "1👉2🤟👉👰3🤟👉👶你 好🤟", "123你 好"},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
s := RemoveEmoji(testCase.BeforeString, true)
|
|||
|
|
if !strings.EqualFold(s, testCase.AfterString) {
|
|||
|
|
t.Errorf("%d except: %s, actual: %s", testCase.Number, testCase.AfterString, s)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestTrimAny(t *testing.T) {
|
|||
|
|
var testCases = []struct {
|
|||
|
|
string string
|
|||
|
|
replacePairs []string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{" a", []string{}, " a"},
|
|||
|
|
{" 10GGGGgggggg", []string{"", "G"}, "10"},
|
|||
|
|
{" A", []string{}, " A"},
|
|||
|
|
{" Abc", []string{""}, "Abc"},
|
|||
|
|
{" Abc", []string{"", "", " "}, "Abc"},
|
|||
|
|
{" Abcd Efg ", []string{"", "ab", "FG"}, "cd E"},
|
|||
|
|
{" Abcd中文 Efg ", []string{"", "abcd", "中", "FG"}, "文 E"},
|
|||
|
|
{" Abcd中文 Efg ", []string{"", "中", "abcd", "FG"}, "文 E"},
|
|||
|
|
{" a", []string{"b", "c"}, " a"},
|
|||
|
|
{" 10kg", []string{"g", "kg", ""}, "10"},
|
|||
|
|
{" 10kgg", []string{"g", "kg", ""}, "10"},
|
|||
|
|
{" 10kg g", []string{"g", "kg", ""}, "10"},
|
|||
|
|
{" 10kg agbg", []string{"g", "ag", "bg", "kg", ""}, "10"},
|
|||
|
|
{" 10kg abgcdg", []string{"bg", "abg", "cdg", "kg", ""}, "10"},
|
|||
|
|
{" 10kg abgcdg", []string{"a", "b", "c", "d", "g", ""}, "10k"},
|
|||
|
|
{" 10kg ggkgg", []string{"kg", "g", ""}, "10"},
|
|||
|
|
{" a", []string{"a", "c"}, " "},
|
|||
|
|
{" a ", []string{}, " a "},
|
|||
|
|
{`
|
|||
|
|
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
`, []string{}, `
|
|||
|
|
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
`},
|
|||
|
|
{" ab", []string{"b"}, " a"},
|
|||
|
|
{" a b ", []string{"b"}, " a b "},
|
|||
|
|
{" a b b", []string{"b"}, " a b "},
|
|||
|
|
{" a b a", []string{"b"}, " a b a"},
|
|||
|
|
{"5.0 out of 5 stars", []string{"5.0 out of", "stars"}, " 5 "},
|
|||
|
|
{"5.0 out of 5 stars", []string{"5.0 out of", "stars", ""}, "5"},
|
|||
|
|
{"5.0 out of 5 stars", []string{"5.0 out of", "5", "stars", " "}, ""},
|
|||
|
|
{"a b a b c d e f g g f e d", []string{"a", "b", "c", "d", "f g", " "}, "e f g g f e"},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
actual := TrimAny(testCase.string, testCase.replacePairs...)
|
|||
|
|
if actual != testCase.expected {
|
|||
|
|
t.Errorf("TrimAny(`%s`, %#v) = `%s`; expected `%s`", testCase.string, testCase.replacePairs, actual, testCase.expected)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func BenchmarkTrimAny(b *testing.B) {
|
|||
|
|
for i := 0; i < b.N; i++ {
|
|||
|
|
TrimAny("a b a b c d e f g g f e d", "a", "b", "c", "d", "f g", " ")
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestRemoveExtraSpace(t *testing.T) {
|
|||
|
|
var testCases = []struct {
|
|||
|
|
number int
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{1, " a", "a"},
|
|||
|
|
{2, " a", "a"},
|
|||
|
|
{3, " a", "a"},
|
|||
|
|
{4, " a ", "a"},
|
|||
|
|
{5, `
|
|||
|
|
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
`, "a"},
|
|||
|
|
{6, " ab", "ab"},
|
|||
|
|
{7, " a b ", "a b"},
|
|||
|
|
{8, " a b b", "a b b"},
|
|||
|
|
{9, " hello, world!", "hello, world!"},
|
|||
|
|
{10, `
|
|||
|
|
hello,
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
world!
|
|||
|
|
`, "hello, world!"},
|
|||
|
|
{11, `
|
|||
|
|
|
|||
|
|
<div a="1" b="2">
|
|||
|
|
|
|||
|
|
<span>
|
|||
|
|
|
|||
|
|
hello world
|
|||
|
|
|
|||
|
|
</span>
|
|||
|
|
|
|||
|
|
|
|||
|
|
</div>
|
|||
|
|
`, `<div a="1" b="2"> <span> hello world </span> </div>`},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
actual := RemoveExtraSpace(testCase.string)
|
|||
|
|
if actual != testCase.expected {
|
|||
|
|
t.Errorf("%d RemoveExtraSpace(%s) = '%s'; expected %s", testCase.number, testCase.string, actual, testCase.expected)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestToBytes(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
bytesValue []byte
|
|||
|
|
string string
|
|||
|
|
}{
|
|||
|
|
{"t1", []byte{'a'}, "a"},
|
|||
|
|
{"t2", []byte("abc"), "abc"},
|
|||
|
|
{"t3", []byte("a b c "), "a b c "},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := ToBytes(test.string)
|
|||
|
|
assert.Equal(t, test.bytesValue, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestWordMatched(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
words []string
|
|||
|
|
caseSensitive bool
|
|||
|
|
except bool
|
|||
|
|
}{
|
|||
|
|
{"t1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"Towels", "B"}, true, true},
|
|||
|
|
{"t2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"towels", "B"}, false, true},
|
|||
|
|
{"t3.1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"tow", "A", "B"}, false, true},
|
|||
|
|
{"t3.2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"tow", "A", "B"}, true, false},
|
|||
|
|
{"t4", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"tow"}, false, false},
|
|||
|
|
{"t5.1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"20"}, false, false},
|
|||
|
|
{"t5.2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"200"}, false, true},
|
|||
|
|
{"t6", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"Blue Shop"}, true, true},
|
|||
|
|
{"t7.1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"blue shop"}, false, true},
|
|||
|
|
{"t7.2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"blue shop"}, true, false},
|
|||
|
|
{"t8", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"Scott "}, false, true},
|
|||
|
|
{"t9", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"Sheets "}, false, true},
|
|||
|
|
{"t10.1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{`.`}, false, false},
|
|||
|
|
{"t10.2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{`...................`}, false, false},
|
|||
|
|
{"t11", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"*"}, false, false},
|
|||
|
|
{"t12", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"***"}, false, false},
|
|||
|
|
{"t13.1", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{`.*`}, false, false},
|
|||
|
|
{"t13.2", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{`B.*x`}, false, false},
|
|||
|
|
{"t14", "Scott Blue Shop Towels in a Box - 200 Sheets.", []string{"."}, false, false},
|
|||
|
|
{"t14.1", "Scott Blue Shop Towels in a Box - 200 Sheets.", []string{".*"}, false, false},
|
|||
|
|
{"t14.2", "Scott Blue Shop Towels in a Box - 200 Sheets.", []string{"Sheets."}, false, true},
|
|||
|
|
{"t15", "Scott Blue Shop Towels in a Box - 200 Sheets?", []string{"?"}, false, false},
|
|||
|
|
{"t16", "Scott Blue Shop Towels in a Box - 200 Sheets", []string{"[Sheets]"}, false, false},
|
|||
|
|
{"t17", "Scott Blue Shop Towels in a Box a-a 200 Sheets", []string{"a-a"}, false, true},
|
|||
|
|
{"t18", "Scott Blue Shop Towels in a Box--200 Sheets", []string{"-"}, false, false},
|
|||
|
|
{"t19", "Scott Blue Shop Towels in a Box--200 Sheets", []string{"--"}, false, false},
|
|||
|
|
{"t20", "Scott Blue Shop Towels in a Box--200 Sheets", []string{"Box--200"}, false, true},
|
|||
|
|
{"t20.1", "Scott Blue Shop Towels in a Box~200 Sheets", []string{"Box"}, false, false},
|
|||
|
|
{"t21", "Scott Blue Shop Towels in a Box--200 Sheets 中文", []string{"中文"}, false, true},
|
|||
|
|
{"t22", "中文汉字", []string{"汉字"}, false, true},
|
|||
|
|
{"t23", "中a文b汉c字", []string{"汉c字"}, false, true},
|
|||
|
|
{"t24", "中a文b汉c字", []string{"汉C字"}, false, true},
|
|||
|
|
{"t25", "中a文b汉c字", []string{"汉C字"}, true, false},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := WordMatched(test.string, test.words, test.caseSensitive)
|
|||
|
|
assert.Equal(t, test.except, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func BenchmarkWordMatched(b *testing.B) {
|
|||
|
|
for i := 0; i < b.N; i++ {
|
|||
|
|
WordMatched("Scott Blue Shop Towels in a Box--200 Sheets", []string{"Throw Pillow Covers", "Throw Pillows", "Patio Furniture Pillows", "Pillow Covers", "Pillowcases", "Pillow Case", "Pillow Cover", "scot", "scottt", "blu", "Shop Towels"}, true)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestStartsWith(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
words []string
|
|||
|
|
caseSensitive bool
|
|||
|
|
except bool
|
|||
|
|
}{
|
|||
|
|
{"t1", "Hello world!", []string{"he", "He"}, false, true},
|
|||
|
|
{"t2", "Hello world!", []string{"he", "He"}, true, true},
|
|||
|
|
{"t3", "Hello world!", []string{"he"}, true, false},
|
|||
|
|
{"t4", "", []string{""}, true, true},
|
|||
|
|
{"t5", "", nil, true, true},
|
|||
|
|
{"t6", "", []string{}, true, true},
|
|||
|
|
{"t7", "Hello world!", []string{""}, true, true},
|
|||
|
|
{"t8", "Hello!", []string{"Hello world"}, true, false},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := StartsWith(test.string, test.words, test.caseSensitive)
|
|||
|
|
assert.Equal(t, test.except, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func BenchmarkStartsWith(b *testing.B) {
|
|||
|
|
for i := 0; i < b.N; i++ {
|
|||
|
|
StartsWith("Hello world!", []string{"a", "b", "c", "d", "e", "f", "g", "h"}, false)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestEndsWith(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
words []string
|
|||
|
|
caseSensitive bool
|
|||
|
|
except bool
|
|||
|
|
}{
|
|||
|
|
{"t1", "Hello world!", []string{"he", "He"}, false, false},
|
|||
|
|
{"t2", "Hello world!", []string{"he", "He"}, true, false},
|
|||
|
|
{"t3", "Hello world!", []string{"d!", "!"}, true, true},
|
|||
|
|
{"t4", "Hello world!", []string{"WORLD!"}, false, true},
|
|||
|
|
{"t5", "", []string{""}, true, true},
|
|||
|
|
{"t6", "", nil, true, true},
|
|||
|
|
{"t7", "", []string{}, true, true},
|
|||
|
|
{"t8", "Hello world!", []string{""}, true, true},
|
|||
|
|
{"t9", "world!", []string{"hello world!", "world!", "!"}, true, true},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := EndsWith(test.string, test.words, test.caseSensitive)
|
|||
|
|
assert.Equal(t, test.except, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestContains(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
words []string
|
|||
|
|
caseSensitive bool
|
|||
|
|
except bool
|
|||
|
|
}{
|
|||
|
|
{"t1", "Hello world!", []string{"ol", "LL"}, false, true},
|
|||
|
|
{"t2", "Hello world!", []string{"ol", "LL"}, true, false},
|
|||
|
|
{"t3", "Hello world!", []string{"notfound", "world"}, false, true},
|
|||
|
|
{"t4", "Hello world!", []string{"notfound", "world"}, true, true},
|
|||
|
|
{"t5", "", []string{""}, true, true},
|
|||
|
|
{"t6", "Hello world!", []string{""}, true, true},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := Contains(test.string, test.words, test.caseSensitive)
|
|||
|
|
assert.Equal(t, test.except, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func BenchmarkContains(b *testing.B) {
|
|||
|
|
for i := 0; i < b.N; i++ {
|
|||
|
|
Contains("Customer satisfaction is important to us. We are confident with our fuzzy blanket, but if you are not satisfied with our blanket feel free to contact us. we will provide you with the most satisfactory solution", []string{"free"}, false)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestQuoteMeta(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{"t1", `.+\()[]$^*?`, `\.\+\\\(\)\[\]\$\^\*\?`},
|
|||
|
|
{"t1", `.+\()[]$^*?{}`, `\.\+\\\(\)\[\]\$\^\*\?{}`},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
b := QuoteMeta(test.string)
|
|||
|
|
assert.Equal(t, test.expected, b, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestSequentialWordFields(t *testing.T) {
|
|||
|
|
tests := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
n int
|
|||
|
|
separators []string
|
|||
|
|
expected []string
|
|||
|
|
}{
|
|||
|
|
{"t1", "hello world", 1, []string{}, []string{"hello", "world"}},
|
|||
|
|
{"t2", "hello world", 2, []string{}, []string{"hello", "world", "hello world"}},
|
|||
|
|
{"t3", "hello world", 2, []string{}, []string{"hello", "world", "hello world"}},
|
|||
|
|
{"t4", "this is a string", 1, []string{}, []string{"this", "is", "a", "string"}},
|
|||
|
|
{"t5", "this is a string", 2, []string{}, []string{"this", "is", "a", "string", "this is", "is a", "a string"}},
|
|||
|
|
{"t6", "this is a string", 3, []string{}, []string{"this", "is", "a", "string", "this is", "this is a", "is a", "is a string", "a string"}},
|
|||
|
|
{"t7", "What's you name? My name is XiaoMing.", 3, []string{"?"}, []string{"What's", "you", "name", "My", "is", "XiaoMing", "What's you", "What's you name", "you name", "My name", "My name is", "name is", "name is XiaoMing", "is XiaoMing"}},
|
|||
|
|
{"t8", "a1, a2? b1 2b?", 3, []string{","}, []string{"a1", "a2", "b1", "2b", "a2 b1", "a2 b1 2b", "b1 2b"}},
|
|||
|
|
{"t9", "a1, a?2? b1 2b?~", 3, []string{","}, []string{"a1", "a?2", "b1", "2b", "a?2 b1", "a?2 b1 2b", "b1 2b"}},
|
|||
|
|
}
|
|||
|
|
for _, test := range tests {
|
|||
|
|
v := SequentialWordFields(test.string, test.n, test.separators...)
|
|||
|
|
assert.ElementsMatch(t, test.expected, v, test.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func BenchmarkSequentialWordFields(b *testing.B) {
|
|||
|
|
for i := 0; i < b.N; i++ {
|
|||
|
|
SequentialWordFields("What's you name? My name is XiaoMing.", 3, []string{"?"}...)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestLen(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected int
|
|||
|
|
}{
|
|||
|
|
{"t1", "hello", 5},
|
|||
|
|
{"t1", "hello world", 11},
|
|||
|
|
{"t1", "hello中国", 7},
|
|||
|
|
{"t1", "hello 中国", 8},
|
|||
|
|
{"t1", "你好中国", 4},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
n := Len(testCase.string)
|
|||
|
|
assert.Equal(t, testCase.expected, n, testCase.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestUpperFirst(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{"t1", "hello", "Hello"},
|
|||
|
|
{"t1", "hello world", "Hello world"},
|
|||
|
|
{"t1", "hello中国", "Hello中国"},
|
|||
|
|
{"t1", "hello 中国", "Hello 中国"},
|
|||
|
|
{"t1", "你好中国", "你好中国"},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
s := UpperFirst(testCase.string)
|
|||
|
|
assert.Equal(t, testCase.expected, s, testCase.tag)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func TestLowerFirst(t *testing.T) {
|
|||
|
|
testCases := []struct {
|
|||
|
|
tag string
|
|||
|
|
string string
|
|||
|
|
expected string
|
|||
|
|
}{
|
|||
|
|
{"t1", "Hello", "hello"},
|
|||
|
|
{"t1", "Hello world", "hello world"},
|
|||
|
|
{"t1", "Hello中国", "hello中国"},
|
|||
|
|
{"t1", "Hello 中国", "hello 中国"},
|
|||
|
|
{"t1", "你好中国", "你好中国"},
|
|||
|
|
}
|
|||
|
|
for _, testCase := range testCases {
|
|||
|
|
s := LowerFirst(testCase.string)
|
|||
|
|
assert.Equal(t, testCase.expected, s, testCase.tag)
|
|||
|
|
}
|
|||
|
|
}
|