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.
430 lines
7.7 KiB
Go
430 lines
7.7 KiB
Go
package stringx
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestLongestMatchGuardedCondition(t *testing.T) {
|
|
n := new(node)
|
|
n.end = true
|
|
uselessLen, matchLen, jump := n.longestMatch([]rune(""), nil)
|
|
assert.Equal(t, 0, uselessLen)
|
|
assert.Nil(t, jump)
|
|
assert.Equal(t, 0, matchLen)
|
|
}
|
|
|
|
func TestFuzzNodeCase1(t *testing.T) {
|
|
keywords := []string{
|
|
"cs8Zh",
|
|
"G1OihlVuBz",
|
|
"K6azS2FBHjI",
|
|
"DQKvghI4",
|
|
"l7bA86Sze",
|
|
"tjBLZhCao",
|
|
"nEsXmVzP",
|
|
"cbRh8UE1nO3s",
|
|
"Wta3R2WcbGP",
|
|
"jpOIcA",
|
|
"TtkRr4k9hI",
|
|
"OKbSo0clAYTtk",
|
|
"uJs1WToEanlKV",
|
|
"05Y02iFD2",
|
|
"x2uJs1WToEanlK",
|
|
"ieaSWe",
|
|
"Kg",
|
|
"FD2bCKFazH",
|
|
}
|
|
scopes := []scope{
|
|
{62, 72},
|
|
{52, 65},
|
|
{21, 34},
|
|
{1, 10},
|
|
{19, 33},
|
|
{36, 42},
|
|
{42, 44},
|
|
{7, 17},
|
|
}
|
|
n := new(node)
|
|
for _, key := range keywords {
|
|
n.add(key)
|
|
}
|
|
n.build()
|
|
assert.ElementsMatch(t, scopes, n.find([]rune("Z05Y02iFD2bCKFazHtrx2uJs1WToEanlKVWKieaSWeKgmnUXV0ZjOKbSo0clAYTtkRr4k9hI")))
|
|
}
|
|
|
|
func TestFuzzNodeCase2(t *testing.T) {
|
|
keywords := []string{
|
|
"IP1NPsJKIvt",
|
|
"Iw7hQARwSTw",
|
|
"SmZIcA",
|
|
"OyxHPYkoQzFO",
|
|
"3suCnuSAS5d",
|
|
"HUMpbi",
|
|
"HPdvbGGpY",
|
|
"49qjMtR8bEt",
|
|
"a0zrrGKVTJ2",
|
|
"WbOBcszeo1FfZ",
|
|
"8tHUi5PJI",
|
|
"Oa2Di",
|
|
"6ZWa5nr1tU",
|
|
"o0LJRfmeXB9bF9",
|
|
"veF0ehKxH",
|
|
"Qp73r",
|
|
"B6Rmds4ELY8",
|
|
"uNpGybQZG",
|
|
"Ogm3JqicRZlA4n",
|
|
"FL6LVErKomc84H",
|
|
"qv2Pi0xJj3cR1",
|
|
"bPWLBg4",
|
|
"hYN8Q4M1sw",
|
|
"ExkTgNklmlIx",
|
|
"eVgHHDOxOUEj",
|
|
"5WPEVv0tR",
|
|
"CPjnOAqUZgV",
|
|
"oR3Ogtz",
|
|
"jwk1Zbg",
|
|
"DYqguyk8h",
|
|
"rieroDmpvYFK",
|
|
"MQ9hZnMjDqrNQe",
|
|
"EhM4KqkCBd",
|
|
"m9xalj6q",
|
|
"d5CTL5mzK",
|
|
"XJOoTvFtI8U",
|
|
"iFAwspJ",
|
|
"iGv8ErnRZIuSWX",
|
|
"i8C1BqsYX",
|
|
"vXN1KOaOgU",
|
|
"GHJFB",
|
|
"Y6OlAqbZxYG8",
|
|
"dzd4QscSih4u",
|
|
"SsLYMkKvB9APx",
|
|
"gi0huB3",
|
|
"CMICHDCSvSrgiACXVkN",
|
|
"MwOvyHbaxdaqpZpU",
|
|
"wOvyHbaxdaqpZpUbI",
|
|
"2TT5WEy",
|
|
"eoCq0T2MC",
|
|
"ZpUbI7",
|
|
"oCq0T2MCp",
|
|
"CpLFgLg0g",
|
|
"FgLg0gh",
|
|
"w5awC5HeoCq",
|
|
"1c",
|
|
}
|
|
scopes := []scope{
|
|
{0, 19},
|
|
{57, 73},
|
|
{58, 75},
|
|
{47, 54},
|
|
{29, 38},
|
|
{70, 76},
|
|
{30, 39},
|
|
{37, 46},
|
|
{40, 47},
|
|
{22, 33},
|
|
{92, 94},
|
|
}
|
|
n := new(node)
|
|
for _, key := range keywords {
|
|
n.add(key)
|
|
}
|
|
n.build()
|
|
assert.ElementsMatch(t, scopes, n.find([]rune("CMICHDCSvSrgiACXVkNF9lw5awC5HeoCq0T2MCpLFgLg0gh2TT5WEyINrMwOvyHbaxdaqpZpUbI7SpIY5yVWf33MuX7K1c")))
|
|
}
|
|
|
|
func TestFuzzNodeCase3(t *testing.T) {
|
|
keywords := []string{
|
|
"QAraACKOftI4",
|
|
"unRmd2EO0",
|
|
"s25OtuoU",
|
|
"aGlmn7KnbE4HCX",
|
|
"kuK6Uh",
|
|
"ckuK6Uh",
|
|
"uK6Uh",
|
|
"Iy",
|
|
"h",
|
|
"PMSSUNvyi",
|
|
"ahz0i",
|
|
"Lhs4XZ1e",
|
|
"shPp1Va7aQNVme",
|
|
"yIUckuK6Uh",
|
|
"pKjIyI",
|
|
"jIyIUckuK6Uh",
|
|
"UckuK6Uh",
|
|
"Uh",
|
|
"JPAULjQgHJ",
|
|
"Wp",
|
|
"sbkZxXurrI",
|
|
"pKjIyIUckuK6Uh",
|
|
}
|
|
scopes := []scope{
|
|
{9, 15},
|
|
{8, 15},
|
|
{5, 15},
|
|
{1, 7},
|
|
{10, 15},
|
|
{3, 15},
|
|
{0, 2},
|
|
{1, 15},
|
|
{7, 15},
|
|
{13, 15},
|
|
{4, 6},
|
|
{14, 15},
|
|
}
|
|
n := new(node)
|
|
for _, key := range keywords {
|
|
n.add(key)
|
|
}
|
|
n.build()
|
|
assert.ElementsMatch(t, scopes, n.find([]rune("WpKjIyIUckuK6Uh")))
|
|
}
|
|
|
|
func BenchmarkNodeFind(b *testing.B) {
|
|
b.ReportAllocs()
|
|
|
|
keywords := []string{
|
|
"A",
|
|
"AV",
|
|
"AV演员",
|
|
"无名氏",
|
|
"AV演员色情",
|
|
"日本AV女优",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
trie.find([]rune("日本AV演员兼电视、电影演员。无名氏AV女优是xx出道, 日本AV女优们最精彩的表演是AV演员色情表演"))
|
|
}
|
|
}
|
|
|
|
func TestNode_longestMatchCase0(t *testing.T) {
|
|
// match the longest word
|
|
keywords := []string{
|
|
"a",
|
|
"ab",
|
|
"abc",
|
|
"abcd",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, jump := trie.longestMatch([]rune("abcef"), nil)
|
|
assert.Equal(t, 0, uselessLen)
|
|
assert.Equal(t, 3, matchLen)
|
|
assert.Nil(t, jump)
|
|
}
|
|
|
|
func TestNode_longestMatchCase1(t *testing.T) {
|
|
keywords := []string{
|
|
"abcde",
|
|
"bcde",
|
|
"cde",
|
|
"de",
|
|
|
|
"b",
|
|
"bc",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, jump := trie.longestMatch([]rune("abcdf"), nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 2, matchLen)
|
|
assert.Nil(t, jump)
|
|
}
|
|
|
|
func TestNode_longestMatchCase2(t *testing.T) {
|
|
keywords := []string{
|
|
"abcde",
|
|
"bcde",
|
|
"cde",
|
|
"de",
|
|
|
|
"c",
|
|
"cd",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, jump := trie.longestMatch([]rune("abcdf"), nil)
|
|
assert.Equal(t, 2, uselessLen)
|
|
assert.Equal(t, 2, matchLen)
|
|
assert.Nil(t, jump)
|
|
}
|
|
|
|
func TestNode_longestMatchCase3(t *testing.T) {
|
|
keywords := []string{
|
|
"abcde",
|
|
"bcde",
|
|
"cde",
|
|
"de",
|
|
|
|
"b",
|
|
"bc",
|
|
"c",
|
|
"cd",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, jump := trie.longestMatch([]rune("abcdf"), nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 2, matchLen)
|
|
assert.Nil(t, jump)
|
|
}
|
|
|
|
func TestNode_longestMatchCase4(t *testing.T) {
|
|
keywords := []string{
|
|
"abcde",
|
|
"bcdf",
|
|
"bcd",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, paths := trie.longestMatch([]rune("abcdf"), nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 0, matchLen)
|
|
assert.Equal(t, 4, len(paths))
|
|
}
|
|
|
|
func TestNode_longestMatchCase5(t *testing.T) {
|
|
keywords := []string{
|
|
"abcdef",
|
|
"bcde",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, paths := trie.longestMatch([]rune("abcde"), nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 4, matchLen)
|
|
assert.Nil(t, paths)
|
|
}
|
|
|
|
func TestNode_longestMatchCase6(t *testing.T) {
|
|
keywords := []string{
|
|
"abcde",
|
|
"bc",
|
|
"d",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
uselessLen, matchLen, jump := trie.longestMatch([]rune("abcd"), nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 2, matchLen)
|
|
assert.Nil(t, jump)
|
|
}
|
|
|
|
func TestNode_longestMatchCase7(t *testing.T) {
|
|
keywords := []string{
|
|
"abcdeg",
|
|
"cdef",
|
|
"bcde",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
word := []rune("abcdef")
|
|
uselessLen, matchLen, paths := trie.longestMatch(word, nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 4, matchLen)
|
|
assert.Nil(t, paths)
|
|
uselessLen, matchLen, paths = trie.longestMatch(word[uselessLen+matchLen:], paths)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 0, matchLen)
|
|
assert.Nil(t, paths)
|
|
}
|
|
|
|
func TestNode_longestMatchCase8(t *testing.T) {
|
|
keywords := []string{
|
|
"abcdeg",
|
|
"cdef",
|
|
"cde",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
word := []rune("abcdef")
|
|
uselessLen, matchLen, paths := trie.longestMatch(word, nil)
|
|
assert.Equal(t, 2, uselessLen)
|
|
assert.Equal(t, 0, matchLen)
|
|
assert.NotNil(t, paths)
|
|
}
|
|
|
|
func TestNode_longestMatchCase9(t *testing.T) {
|
|
keywords := []string{
|
|
"abcdeg",
|
|
"cdef",
|
|
"cde",
|
|
"cd",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
|
|
word := []rune("abcde")
|
|
uselessLen, matchLen, paths := trie.longestMatch(word, nil)
|
|
assert.Equal(t, 2, uselessLen)
|
|
assert.Equal(t, 3, matchLen)
|
|
assert.Nil(t, paths)
|
|
}
|
|
|
|
func TestNode_jump(t *testing.T) {
|
|
keywords := []string{
|
|
"de",
|
|
"fe",
|
|
}
|
|
trie := new(node)
|
|
for _, keyword := range keywords {
|
|
trie.add(keyword)
|
|
}
|
|
trie.build()
|
|
target := []rune("dfe")
|
|
|
|
uselessLen, matchLen, paths := trie.longestMatch(target, nil)
|
|
assert.Equal(t, 1, uselessLen)
|
|
assert.Equal(t, 0, matchLen)
|
|
assert.NotNil(t, paths)
|
|
uselessLen, matchLen, paths = paths[len(paths)-1].longestMatch(target[uselessLen+matchLen:], paths)
|
|
assert.Equal(t, 0, uselessLen)
|
|
assert.Equal(t, 2, matchLen)
|
|
assert.Nil(t, paths)
|
|
}
|