blob: e75be4f97e09e1f89b8360f2ff7a2cb81243baa6 [file] [log] [blame]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package glob
import (
"testing"
)
func same(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
func TestStripFixedElements(t *testing.T) {
tests := []struct {
pattern string
fixed []string
rest string
}{
{"*", nil, "*"},
{"a/b/c/*", []string{"a", "b", "c"}, "*"},
{"a/b/*/...", []string{"a", "b"}, "*/..."},
{"a/b/c/...", []string{"a", "b", "c"}, "..."},
{"a/the\\?rain.in\\*spain", []string{"a", "the?rain.in*spain"}, ""},
}
for _, test := range tests {
g, err := Parse(test.pattern)
if err != nil {
t.Fatalf("parsing %q: %q", test.pattern, err.Error())
}
if f, ng := g.SplitFixedElements(); !same(f, test.fixed) || test.rest != ng.String() {
t.Fatalf("SplitFixedElements(%q) got %q,%q, expected %q,%q", test.pattern, f, ng.String(), test.fixed, test.rest)
}
}
}
func TestMatch(t *testing.T) {
tests := []struct {
pattern string
name string
matched bool
}{
{"...", "", true},
{"***", "", true},
{"...", "a", true},
{"***", "a", true},
{"a", "", false},
{"a", "a", true},
{"a", "b", false},
{"a*", "a", true},
{"a*", "b", false},
{"a*b", "ab", true},
{"a*b", "afoob", true},
{"a\\*", "a", false},
{"a\\*", "a*", true},
{"\\\\", "\\", true},
{"?", "?", true},
{"?", "a", true},
{"?", "", false},
{"*?", "", false},
{"*?", "a", true},
{"*?", "ab", true},
{"*?", "abv", true},
{"[abc]", "a", true},
{"[abc]", "b", true},
{"[abc]", "c", true},
{"[abc]", "d", false},
{"[a-c]", "a", true},
{"[a-c]", "b", true},
{"[a-c]", "c", true},
{"[a-c]", "d", false},
{"\\[abc]", "a", false},
{"\\[abc]", "[abc]", true},
{"a/*", "a", true},
{"a/*", "b", false},
{"a/...", "a", true},
{"a/...", "b", false},
}
for i, test := range tests {
g, err := Parse(test.pattern)
if err != nil {
t.Errorf("unexpected parsing error for %q (#%d): %v", test.pattern, i, err)
continue
}
if matched := g.Head().Match(test.name); matched != test.matched {
t.Errorf("unexpected result for %q.Match(%q) (#%d). Got %v, expected %v", test.pattern, test.name, i, matched, test.matched)
}
}
}
func TestFixedPrefix(t *testing.T) {
tests := []struct {
pattern string
prefix string
full bool
}{
{"", "", true},
{"...", "", false},
{"***", "", false},
{"...", "", false},
{"***", "", false},
{"a", "a", true},
{"*a", "", false},
{"a*", "a", false},
{"a*b", "a", false},
{"a\\*", "a*", true},
{"\\\\", "\\", true},
{"?", "", false},
{"\\?", "?", true},
{"*?", "", false},
{"[abc]", "", false},
{"\\[abc]", "[abc]", true},
{"\\[abc]*", "[abc]", false},
}
for i, test := range tests {
g, err := Parse(test.pattern)
if err != nil {
t.Errorf("unexpected parsing error for %q (#%d): %v", test.pattern, i, err)
continue
}
if prefix, full := g.Head().FixedPrefix(); prefix != test.prefix || full != test.full {
t.Errorf("unexpected result for %q.FixedPrefix() (#%d). Got (%q,%v), expected (%q,%v)", test.pattern, i, prefix, full, test.prefix, test.full)
}
}
}
func TestBadPattern(t *testing.T) {
tests := []string{"[", "[foo", "[^foo", "\\", "a\\", "abc[foo", "a//b"}
for _, test := range tests {
if _, err := Parse(test); err == nil {
t.Errorf("Unexpected success for %q", test)
}
}
}
func TestExactMatch(t *testing.T) {
tests := []struct {
pattern string
elems []string
matched bool
exact bool
}{
// Test recursive.
{"...", []string{}, true, true},
{"...", []string{"a"}, true, false},
{"a/...", []string{"a"}, true, true},
{"a/...", []string{"a", "b"}, true, false},
// Test one element, fixed.
{"a", []string{"a"}, true, true},
{"a", []string{"b"}, false, false},
{"\\\\", []string{"\\"}, true, true},
// Test one element, containing *.
{"*", []string{"*"}, true, false},
{"*", []string{"abc"}, true, false},
{"\\*", []string{"*"}, true, true},
{"\\*", []string{"abc"}, false, false},
{"\\\\*", []string{"\\"}, true, false},
{"\\\\*", []string{"\\*"}, true, false},
{"\\\\*", []string{"\\abc"}, true, false},
// Test one element, containing ?.
{"?", []string{"?"}, true, false},
{"?", []string{"a"}, true, false},
{"\\?", []string{"?"}, true, true},
{"\\?", []string{"a"}, false, false},
{"\\\\?", []string{"\\"}, false, false},
{"\\\\?", []string{"\\?"}, true, false},
{"\\\\?", []string{"\\a"}, true, false},
// Test one element, containing [].
{"[abc]", []string{"c"}, true, false},
{"\\[abc\\]", []string{"[abc]"}, true, true},
{"\\[abc\\]", []string{"a"}, false, false},
{"\\\\[abc]", []string{"\\a"}, true, false},
{"\\\\[abc]", []string{"a"}, false, false},
{"[\\\\]", []string{"\\"}, true, false},
{"[\\\\]", []string{"a"}, false, false},
// Test multiple elements.
{"a/b", []string{"a", "b"}, true, true},
{"a/\\*", []string{"a", "*"}, true, true},
{"a/\\?", []string{"a", "?"}, true, true},
{"a/\\[b\\]", []string{"a", "[b]"}, true, true},
{"a/*", []string{"a", "bc"}, true, false},
{"a/?", []string{"a", "b"}, true, false},
{"a/[bc]", []string{"a", "b"}, true, false},
{"a/*/c", []string{"a", "b", "c"}, true, false},
{"a/?/c", []string{"a", "b", "c"}, true, false},
{"a/[bc]/d", []string{"a", "b", "d"}, true, false},
}
for _, test := range tests {
g, err := Parse(test.pattern)
if err != nil {
t.Fatalf("parsing %q: %q", test.pattern, err.Error())
}
matched, exact, _ := g.PartialMatch(0, test.elems)
if matched != test.matched || exact != test.exact {
t.Fatalf("'%v'.PartialMatch(0, '%v') got (%v, %v), expected (%v, %v)",
test.pattern, test.elems, matched, exact, test.matched, test.exact)
}
}
}