mirror of https://github.com/gobwas/glob.git
547 lines
12 KiB
Go
547 lines
12 KiB
Go
package glob
|
|
|
|
import (
|
|
"github.com/gobwas/glob/match"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
var separators = []rune{'.'}
|
|
|
|
func TestGlueMatchers(t *testing.T) {
|
|
for id, test := range []struct {
|
|
in []match.Matcher
|
|
exp match.Matcher
|
|
}{
|
|
{
|
|
[]match.Matcher{
|
|
match.Super{},
|
|
match.Single{},
|
|
},
|
|
match.Min{1},
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.Any{separators},
|
|
match.Single{separators},
|
|
},
|
|
match.EveryOf{match.Matchers{
|
|
match.Min{1},
|
|
match.Contains{string(separators), true},
|
|
}},
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.Single{},
|
|
match.Single{},
|
|
match.Single{},
|
|
},
|
|
match.EveryOf{match.Matchers{
|
|
match.Min{3},
|
|
match.Max{3},
|
|
}},
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.List{[]rune{'a'}, true},
|
|
match.Any{[]rune{'a'}},
|
|
},
|
|
match.EveryOf{match.Matchers{
|
|
match.Min{1},
|
|
match.Contains{"a", true},
|
|
}},
|
|
},
|
|
} {
|
|
act, err := compileMatchers(test.in)
|
|
if err != nil {
|
|
t.Errorf("#%d convert matchers error: %s", id, err)
|
|
continue
|
|
}
|
|
|
|
if !reflect.DeepEqual(act, test.exp) {
|
|
t.Errorf("#%d unexpected convert matchers result:\nact: %s;\nexp: %s", id, act, test.exp)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompileMatchers(t *testing.T) {
|
|
for id, test := range []struct {
|
|
in []match.Matcher
|
|
exp match.Matcher
|
|
}{
|
|
{
|
|
[]match.Matcher{
|
|
match.Super{},
|
|
match.Single{separators},
|
|
match.NewText("c"),
|
|
},
|
|
match.NewBTree(
|
|
match.NewText("c"),
|
|
match.NewBTree(
|
|
match.Single{separators},
|
|
match.Super{},
|
|
nil,
|
|
),
|
|
nil,
|
|
),
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.Any{},
|
|
match.NewText("c"),
|
|
match.Any{},
|
|
},
|
|
match.NewBTree(
|
|
match.NewText("c"),
|
|
match.Any{},
|
|
match.Any{},
|
|
),
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
match.Single{},
|
|
},
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
match.Single{},
|
|
},
|
|
RunesLength: 4,
|
|
},
|
|
},
|
|
} {
|
|
act, err := compileMatchers(test.in)
|
|
if err != nil {
|
|
t.Errorf("#%d convert matchers error: %s", id, err)
|
|
continue
|
|
}
|
|
|
|
if !reflect.DeepEqual(act, test.exp) {
|
|
t.Errorf("#%d unexpected convert matchers result:\nact: %s;\nexp: %s", id, act, test.exp)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConvertMatchers(t *testing.T) {
|
|
for id, test := range []struct {
|
|
in, exp []match.Matcher
|
|
}{
|
|
{
|
|
[]match.Matcher{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
match.Single{},
|
|
match.Any{},
|
|
},
|
|
[]match.Matcher{
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
match.Single{},
|
|
},
|
|
RunesLength: 4,
|
|
},
|
|
match.Any{},
|
|
},
|
|
},
|
|
{
|
|
[]match.Matcher{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
match.Single{},
|
|
match.Any{},
|
|
match.Single{},
|
|
match.Single{},
|
|
match.Any{},
|
|
},
|
|
[]match.Matcher{
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.Range{'a', 'c', true},
|
|
match.List{[]rune{'z', 't', 'e'}, false},
|
|
match.NewText("c"),
|
|
},
|
|
RunesLength: 3,
|
|
},
|
|
match.Min{3},
|
|
},
|
|
},
|
|
} {
|
|
act := minimizeMatchers(test.in)
|
|
if !reflect.DeepEqual(act, test.exp) {
|
|
t.Errorf("#%d unexpected convert matchers 2 result:\nact: %s;\nexp: %s", id, act, test.exp)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func pattern(nodes ...node) *nodePattern {
|
|
return &nodePattern{
|
|
nodeImpl: nodeImpl{
|
|
desc: nodes,
|
|
},
|
|
}
|
|
}
|
|
func anyOf(nodes ...node) *nodeAnyOf {
|
|
return &nodeAnyOf{
|
|
nodeImpl: nodeImpl{
|
|
desc: nodes,
|
|
},
|
|
}
|
|
}
|
|
func TestCompiler(t *testing.T) {
|
|
for id, test := range []struct {
|
|
ast *nodePattern
|
|
result Glob
|
|
sep []rune
|
|
}{
|
|
{
|
|
ast: pattern(&nodeText{text: "abc"}),
|
|
result: match.NewText("abc"),
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}),
|
|
sep: separators,
|
|
result: match.Any{separators},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}),
|
|
result: match.Super{},
|
|
},
|
|
{
|
|
ast: pattern(&nodeSuper{}),
|
|
result: match.Super{},
|
|
},
|
|
{
|
|
ast: pattern(&nodeSingle{}),
|
|
sep: separators,
|
|
result: match.Single{separators},
|
|
},
|
|
{
|
|
ast: pattern(&nodeRange{
|
|
lo: 'a',
|
|
hi: 'z',
|
|
not: true,
|
|
}),
|
|
result: match.Range{'a', 'z', true},
|
|
},
|
|
{
|
|
ast: pattern(&nodeList{
|
|
chars: "abc",
|
|
not: true,
|
|
}),
|
|
result: match.List{[]rune{'a', 'b', 'c'}, true},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeSingle{}, &nodeSingle{}, &nodeSingle{}),
|
|
sep: separators,
|
|
result: match.EveryOf{Matchers: match.Matchers{
|
|
match.Min{3},
|
|
match.Contains{string(separators), true},
|
|
}},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeSingle{}, &nodeSingle{}, &nodeSingle{}),
|
|
result: match.Min{3},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeText{text: "abc"}, &nodeSingle{}),
|
|
sep: separators,
|
|
result: match.NewBTree(
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.NewText("abc"),
|
|
match.Single{separators},
|
|
},
|
|
RunesLength: 4,
|
|
},
|
|
match.Any{separators},
|
|
nil,
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(&nodeSuper{}, &nodeSingle{}, &nodeText{text: "abc"}, &nodeSingle{}),
|
|
sep: separators,
|
|
result: match.NewBTree(
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.Single{separators},
|
|
match.NewText("abc"),
|
|
match.Single{separators},
|
|
},
|
|
RunesLength: 5,
|
|
},
|
|
match.Super{},
|
|
nil,
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeText{text: "abc"}),
|
|
result: match.Suffix{"abc"},
|
|
},
|
|
{
|
|
ast: pattern(&nodeText{text: "abc"}, &nodeAny{}),
|
|
result: match.Prefix{"abc"},
|
|
},
|
|
{
|
|
ast: pattern(&nodeText{text: "abc"}, &nodeAny{}, &nodeText{text: "def"}),
|
|
result: match.PrefixSuffix{"abc", "def"},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeAny{}, &nodeAny{}, &nodeText{text: "abc"}, &nodeAny{}, &nodeAny{}),
|
|
result: match.Contains{"abc", false},
|
|
},
|
|
{
|
|
ast: pattern(&nodeAny{}, &nodeAny{}, &nodeAny{}, &nodeText{text: "abc"}, &nodeAny{}, &nodeAny{}),
|
|
sep: separators,
|
|
result: match.NewBTree(
|
|
match.NewText("abc"),
|
|
match.Any{separators},
|
|
match.Any{separators},
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(&nodeSuper{}, &nodeSingle{}, &nodeText{text: "abc"}, &nodeSuper{}, &nodeSingle{}),
|
|
result: match.NewBTree(
|
|
match.NewText("abc"),
|
|
match.Min{1},
|
|
match.Min{1},
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(anyOf(&nodeText{text: "abc"})),
|
|
result: match.NewText("abc"),
|
|
},
|
|
{
|
|
ast: pattern(anyOf(pattern(anyOf(pattern(&nodeText{text: "abc"}))))),
|
|
result: match.NewText("abc"),
|
|
},
|
|
{
|
|
ast: pattern(anyOf(
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
&nodeSingle{},
|
|
),
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
&nodeList{chars: "def"},
|
|
),
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
),
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
),
|
|
)),
|
|
result: match.NewBTree(
|
|
match.NewText("abc"),
|
|
nil,
|
|
match.AnyOf{Matchers: match.Matchers{
|
|
match.Single{},
|
|
match.List{List: []rune{'d', 'e', 'f'}},
|
|
match.Nothing{},
|
|
}},
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(
|
|
&nodeRange{lo: 'a', hi: 'z'},
|
|
&nodeRange{lo: 'a', hi: 'x', not: true},
|
|
&nodeAny{},
|
|
),
|
|
result: match.NewBTree(
|
|
match.Row{
|
|
Matchers: match.Matchers{
|
|
match.Range{Lo: 'a', Hi: 'z'},
|
|
match.Range{Lo: 'a', Hi: 'x', Not: true},
|
|
},
|
|
RunesLength: 2,
|
|
},
|
|
nil,
|
|
match.Super{},
|
|
),
|
|
},
|
|
{
|
|
ast: pattern(anyOf(
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
&nodeList{chars: "abc"},
|
|
&nodeText{text: "ghi"},
|
|
),
|
|
pattern(
|
|
&nodeText{text: "abc"},
|
|
&nodeList{chars: "def"},
|
|
&nodeText{text: "ghi"},
|
|
),
|
|
)),
|
|
result: match.Row{
|
|
RunesLength: 7,
|
|
Matchers: match.Matchers{
|
|
match.NewText("abc"),
|
|
match.AnyOf{Matchers: match.Matchers{
|
|
match.List{List: []rune{'a', 'b', 'c'}},
|
|
match.List{List: []rune{'d', 'e', 'f'}},
|
|
}},
|
|
match.NewText("ghi"),
|
|
},
|
|
},
|
|
},
|
|
// {
|
|
// ast: pattern(
|
|
// anyOf(&nodeText{text: "a"}, &nodeText{text: "b"}),
|
|
// anyOf(&nodeText{text: "c"}, &nodeText{text: "d"}),
|
|
// ),
|
|
// result: match.AnyOf{Matchers: match.Matchers{
|
|
// match.Row{Matchers: match.Matchers{match.Raw{"a"}, match.Raw{"c", 1}}},
|
|
// match.Row{Matchers: match.Matchers{match.Raw{"a"}, match.Raw{"d"}}},
|
|
// match.Row{Matchers: match.Matchers{match.Raw{"b"}, match.Raw{"c", 1}}},
|
|
// match.Row{Matchers: match.Matchers{match.Raw{"b"}, match.Raw{"d"}}},
|
|
// }},
|
|
// },
|
|
} {
|
|
prog, err := compile(test.ast, test.sep)
|
|
if err != nil {
|
|
t.Errorf("compilation error: %s", err)
|
|
continue
|
|
}
|
|
|
|
if !reflect.DeepEqual(prog, test.result) {
|
|
t.Errorf("#%d results are not equal:\nexp: %s,\nact: %s", id, test.result, prog)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
const complexityString = "abcd"
|
|
|
|
//func BenchmarkComplexityAny(b *testing.B) {
|
|
// m := match.Any{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityContains(b *testing.B) {
|
|
// m := match.Contains{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityList(b *testing.B) {
|
|
// m := match.List{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityMax(b *testing.B) {
|
|
// m := match.Max{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityMin(b *testing.B) {
|
|
// m := match.Min{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityNothing(b *testing.B) {
|
|
// m := match.Nothing{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityPrefix(b *testing.B) {
|
|
// m := match.Prefix{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityPrefixSuffix(b *testing.B) {
|
|
// m := match.PrefixSuffix{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityRange(b *testing.B) {
|
|
// m := match.Range{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityRow(b *testing.B) {
|
|
// m := match.Row{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexitySingle(b *testing.B) {
|
|
// m := match.Single{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexitySuffix(b *testing.B) {
|
|
// m := match.Suffix{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexitySuper(b *testing.B) {
|
|
// m := match.Super{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityText(b *testing.B) {
|
|
// m := match.Text{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityAnyOf(b *testing.B) {
|
|
// m := match.AnyOf{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityBTree(b *testing.B) {
|
|
// m := match.NewBTree(match.NewText("abc"), match.NewText("d"), match.NewText("e"))
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|
|
//func BenchmarkComplexityEveryOf(b *testing.B) {
|
|
// m := match.EveryOf{}
|
|
// for i := 0; i < b.N; i++ {
|
|
// _ = m.Match(complexityString)
|
|
// _, _ = m.Index(complexityString)
|
|
// }
|
|
//}
|