0e306e7a89
When globbing with following symlinks enabled, treat dangling symlinks as files instead of erroring. Bug: 202547639 Test: TestGlobFollowDanglingSymlinks Change-Id: Ic1b241d3fcf1bc6989cb724d00c2b97fefa8dcdb
976 lines
21 KiB
Go
976 lines
21 KiB
Go
// Copyright 2014 Google Inc. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package pathtools
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
var pwd, _ = os.Getwd()
|
|
|
|
type globTestCase struct {
|
|
pattern string
|
|
matches []string
|
|
excludes []string
|
|
deps []string
|
|
err error
|
|
}
|
|
|
|
var globTestCases = []globTestCase{
|
|
// Current directory tests
|
|
{
|
|
pattern: "*",
|
|
matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "*.ext",
|
|
matches: []string{"d.ext", "e.ext"},
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "*/a",
|
|
matches: []string{"a/a/", "b/a"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "*/*/a",
|
|
matches: []string{"a/a/a"},
|
|
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "*/a/a",
|
|
matches: []string{"a/a/a"},
|
|
deps: []string{".", "a", "b", "c", "a/a"},
|
|
},
|
|
{
|
|
pattern: "c/*/?",
|
|
matches: []string{"c/h/h"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/*/[gh]*",
|
|
matches: []string{"c/g/g.ext", "c/h/h"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/*/[fgh]*",
|
|
matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/*/[f-h]*",
|
|
matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
// ./ directory tests
|
|
{
|
|
pattern: "./*",
|
|
matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "./*.ext",
|
|
matches: []string{"d.ext", "e.ext"},
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "./*/a",
|
|
matches: []string{"a/a/", "b/a"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "./[ac]/a",
|
|
matches: []string{"a/a/"},
|
|
deps: []string{".", "a", "c"},
|
|
},
|
|
|
|
// subdirectory tests
|
|
{
|
|
pattern: "c/*/*.ext",
|
|
matches: []string{"c/f/f.ext", "c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "a/*/a",
|
|
matches: []string{"a/a/a"},
|
|
deps: []string{"a", "a/a", "a/b"},
|
|
},
|
|
|
|
// absolute tests
|
|
{
|
|
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
|
|
matches: []string{
|
|
filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
|
|
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
|
|
},
|
|
deps: []string{
|
|
filepath.Join(pwd, "testdata/glob/c"),
|
|
filepath.Join(pwd, "testdata/glob/c/f"),
|
|
filepath.Join(pwd, "testdata/glob/c/g"),
|
|
filepath.Join(pwd, "testdata/glob/c/h"),
|
|
},
|
|
},
|
|
|
|
// no-wild tests
|
|
{
|
|
pattern: "a",
|
|
matches: []string{"a/"},
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/a",
|
|
matches: []string{"a/a/"},
|
|
deps: []string{"a/a"},
|
|
},
|
|
|
|
// clean tests
|
|
{
|
|
pattern: "./c/*/*.ext",
|
|
matches: []string{"c/f/f.ext", "c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/../c/*/*.ext",
|
|
matches: []string{"c/f/f.ext", "c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
|
|
// recursive tests
|
|
{
|
|
pattern: "**/a",
|
|
matches: []string{"a/", "a/a/", "a/a/a", "b/a"},
|
|
deps: []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "a/**/a",
|
|
matches: []string{"a/a/", "a/a/a"},
|
|
deps: []string{"a", "a/a", "a/b"},
|
|
},
|
|
{
|
|
pattern: "a/**/*",
|
|
matches: []string{"a/a/", "a/b/", "a/a/a", "a/b/b"},
|
|
deps: []string{"a", "a/a", "a/b"},
|
|
},
|
|
|
|
// absolute recursive tests
|
|
{
|
|
pattern: filepath.Join(pwd, "testdata/glob/**/*.ext"),
|
|
matches: []string{
|
|
filepath.Join(pwd, "testdata/glob/d.ext"),
|
|
filepath.Join(pwd, "testdata/glob/e.ext"),
|
|
filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
|
|
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
|
|
},
|
|
deps: []string{
|
|
filepath.Join(pwd, "testdata/glob"),
|
|
filepath.Join(pwd, "testdata/glob/a"),
|
|
filepath.Join(pwd, "testdata/glob/a/a"),
|
|
filepath.Join(pwd, "testdata/glob/a/b"),
|
|
filepath.Join(pwd, "testdata/glob/b"),
|
|
filepath.Join(pwd, "testdata/glob/c"),
|
|
filepath.Join(pwd, "testdata/glob/c/f"),
|
|
filepath.Join(pwd, "testdata/glob/c/g"),
|
|
filepath.Join(pwd, "testdata/glob/c/h"),
|
|
},
|
|
},
|
|
|
|
// recursive error tests
|
|
{
|
|
pattern: "**/**/*",
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "a/**/**/*",
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/a/**/*",
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/**/a/*",
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "a/**",
|
|
err: GlobLastRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/**",
|
|
err: GlobLastRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "a**/",
|
|
err: GlobInvalidRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**a/",
|
|
err: GlobInvalidRecursiveErr,
|
|
},
|
|
|
|
// exclude tests
|
|
{
|
|
pattern: "*.ext",
|
|
excludes: []string{"d.ext"},
|
|
matches: []string{"e.ext"},
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"a/b"},
|
|
matches: []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"a/b", "c/c"},
|
|
matches: []string{"a/a/", "b/a", "c/f/", "c/g/", "c/h/"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"c/*", "*/a"},
|
|
matches: []string{"a/b/"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"*/*"},
|
|
matches: nil,
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
|
|
// absolute exclude tests
|
|
{
|
|
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
|
|
excludes: []string{filepath.Join(pwd, "testdata/glob/c/*/f.ext")},
|
|
matches: []string{
|
|
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
|
|
},
|
|
deps: []string{
|
|
filepath.Join(pwd, "testdata/glob/c"),
|
|
filepath.Join(pwd, "testdata/glob/c/f"),
|
|
filepath.Join(pwd, "testdata/glob/c/g"),
|
|
filepath.Join(pwd, "testdata/glob/c/h"),
|
|
},
|
|
},
|
|
{
|
|
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
|
|
excludes: []string{filepath.Join(pwd, "testdata/glob/c/f/*.ext")},
|
|
matches: []string{
|
|
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
|
|
},
|
|
deps: []string{
|
|
filepath.Join(pwd, "testdata/glob/c"),
|
|
filepath.Join(pwd, "testdata/glob/c/f"),
|
|
filepath.Join(pwd, "testdata/glob/c/g"),
|
|
filepath.Join(pwd, "testdata/glob/c/h"),
|
|
},
|
|
},
|
|
|
|
// recursive exclude tests
|
|
{
|
|
pattern: "*.ext",
|
|
excludes: []string{"**/*.ext"},
|
|
matches: nil,
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"**/b"},
|
|
matches: []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "*/*",
|
|
excludes: []string{"a/**/*"},
|
|
matches: []string{"b/a", "c/c", "c/f/", "c/g/", "c/h/"},
|
|
deps: []string{".", "a", "b", "c"},
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"**/*"},
|
|
matches: nil,
|
|
deps: []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "*/*/*",
|
|
excludes: []string{"a/**/a"},
|
|
matches: []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
|
|
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "*/*/*",
|
|
excludes: []string{"**/a"},
|
|
matches: []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
|
|
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/*/*.ext",
|
|
excludes: []string{"c/**/f.ext"},
|
|
matches: []string{"c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
|
|
// absoulte recursive exclude tests
|
|
{
|
|
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
|
|
excludes: []string{filepath.Join(pwd, "testdata/glob/**/f.ext")},
|
|
matches: []string{
|
|
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
|
|
},
|
|
deps: []string{
|
|
filepath.Join(pwd, "testdata/glob/c"),
|
|
filepath.Join(pwd, "testdata/glob/c/f"),
|
|
filepath.Join(pwd, "testdata/glob/c/g"),
|
|
filepath.Join(pwd, "testdata/glob/c/h"),
|
|
},
|
|
},
|
|
|
|
// clean exclude tests
|
|
{
|
|
pattern: "./c/*/*.ext",
|
|
excludes: []string{"./c/*/f.ext"},
|
|
matches: []string{"c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "c/*/*.ext",
|
|
excludes: []string{"./c/*/f.ext"},
|
|
matches: []string{"c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
{
|
|
pattern: "./c/*/*.ext",
|
|
excludes: []string{"c/*/f.ext"},
|
|
matches: []string{"c/g/g.ext"},
|
|
deps: []string{"c", "c/f", "c/g", "c/h"},
|
|
},
|
|
|
|
// non-existant non-wild path tests
|
|
{
|
|
pattern: "d/*",
|
|
matches: nil,
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "d",
|
|
matches: nil,
|
|
deps: []string{"."},
|
|
},
|
|
{
|
|
pattern: "a/d/*",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/d",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/a/d/*",
|
|
matches: nil,
|
|
deps: []string{"a/a"},
|
|
},
|
|
{
|
|
pattern: "a/a/d",
|
|
matches: nil,
|
|
deps: []string{"a/a"},
|
|
},
|
|
{
|
|
pattern: "a/d/a/*",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/d/a",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/d/a/*/a",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
{
|
|
pattern: "a/d/a/**/a",
|
|
matches: nil,
|
|
deps: []string{"a"},
|
|
},
|
|
|
|
// recursive exclude error tests
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"**/**/*"},
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"a/**/**/*"},
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"**/a/**/*"},
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"**/**/a/*"},
|
|
err: GlobMultipleRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"a/**"},
|
|
err: GlobLastRecursiveErr,
|
|
},
|
|
{
|
|
pattern: "**/*",
|
|
excludes: []string{"**/**"},
|
|
err: GlobLastRecursiveErr,
|
|
},
|
|
|
|
// If names are excluded by default, but referenced explicitly, they should return results
|
|
{
|
|
pattern: ".test/*",
|
|
matches: []string{".test/a"},
|
|
deps: []string{".test"},
|
|
},
|
|
{
|
|
pattern: ".t*/a",
|
|
matches: []string{".test/a"},
|
|
deps: []string{".", ".test"},
|
|
},
|
|
{
|
|
pattern: ".*/.*",
|
|
matches: []string{".test/.ing"},
|
|
deps: []string{".", ".test"},
|
|
},
|
|
{
|
|
pattern: ".t*",
|
|
matches: []string{".test/", ".testing"},
|
|
deps: []string{"."},
|
|
},
|
|
}
|
|
|
|
func TestMockGlob(t *testing.T) {
|
|
files := []string{
|
|
"a/a/a",
|
|
"a/b/b",
|
|
"b/a",
|
|
"c/c",
|
|
"c/f/f.ext",
|
|
"c/g/g.ext",
|
|
"c/h/h",
|
|
"d.ext",
|
|
"e.ext",
|
|
".test/a",
|
|
".testing",
|
|
".test/.ing",
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
mockFiles[filepath.Join(pwd, "testdata/glob", f)] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlob(t *testing.T) {
|
|
os.Chdir("testdata/glob")
|
|
defer os.Chdir("../..")
|
|
for _, testCase := range globTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
var globEscapeTestCases = []globTestCase{
|
|
{
|
|
pattern: `**/*`,
|
|
matches: []string{`*`, `**/`, `?`, `a/`, `b`, `**/*`, `**/a`, `**/b/`, `**/b/b`, `a/a`},
|
|
deps: []string{`.`, `**`, `**/b`, `a`},
|
|
},
|
|
{
|
|
pattern: `**/\*`,
|
|
matches: []string{`*`, `**/*`},
|
|
deps: []string{`.`, `**`, `**/b`, `a`},
|
|
},
|
|
{
|
|
pattern: `\*\*/*`,
|
|
matches: []string{`**/*`, `**/a`, `**/b/`},
|
|
deps: []string{`.`, `**`},
|
|
},
|
|
{
|
|
pattern: `\*\*/**/*`,
|
|
matches: []string{`**/*`, `**/a`, `**/b/`, `**/b/b`},
|
|
deps: []string{`.`, `**`, `**/b`},
|
|
},
|
|
}
|
|
|
|
func TestMockGlobEscapes(t *testing.T) {
|
|
files := []string{
|
|
`*`,
|
|
`**/*`,
|
|
`**/a`,
|
|
`**/b/b`,
|
|
`?`,
|
|
`a/a`,
|
|
`b`,
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globEscapeTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestGlobEscapes(t *testing.T) {
|
|
os.Chdir("testdata/escapes")
|
|
defer os.Chdir("../..")
|
|
for _, testCase := range globEscapeTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
var globSymlinkTestCases = []globTestCase{
|
|
{
|
|
pattern: `**/*`,
|
|
matches: []string{"a/", "b/", "c/", "d/", "e", "a/a/", "a/a/a", "b/a/", "b/a/a", "c/a", "d/a"},
|
|
deps: []string{".", "a", "a/a", "b", "b/a", "c", "d"},
|
|
},
|
|
{
|
|
pattern: `b/**/*`,
|
|
matches: []string{"b/a/", "b/a/a"},
|
|
deps: []string{"b", "b/a"},
|
|
},
|
|
}
|
|
|
|
func TestMockGlobSymlinks(t *testing.T) {
|
|
files := []string{
|
|
"a/a/a",
|
|
"b -> a",
|
|
"c -> a/a",
|
|
"d -> c",
|
|
"e -> a/a/a",
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlobSymlinks(t *testing.T) {
|
|
os.Chdir("testdata/symlinks")
|
|
defer os.Chdir("../..")
|
|
|
|
for _, testCase := range globSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
var globDontFollowSymlinkTestCases = []globTestCase{
|
|
{
|
|
pattern: `**/*`,
|
|
matches: []string{"a/", "b", "c", "d", "e", "a/a/", "a/a/a"},
|
|
deps: []string{".", "a", "a/a"},
|
|
},
|
|
{
|
|
pattern: `b/**/*`,
|
|
matches: []string{"b/a/", "b/a/a"},
|
|
deps: []string{"b", "b/a"},
|
|
},
|
|
}
|
|
|
|
func TestMockGlobDontFollowSymlinks(t *testing.T) {
|
|
files := []string{
|
|
"a/a/a",
|
|
"b -> a",
|
|
"c -> a/a",
|
|
"d -> c",
|
|
"e -> a/a/a",
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globDontFollowSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, DontFollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlobDontFollowSymlinks(t *testing.T) {
|
|
os.Chdir("testdata/symlinks")
|
|
defer os.Chdir("../..")
|
|
|
|
for _, testCase := range globDontFollowSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, DontFollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
var globDontFollowDanglingSymlinkTestCases = []globTestCase{
|
|
{
|
|
pattern: `**/*`,
|
|
matches: []string{"a/", "b", "c", "d", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f"},
|
|
deps: []string{".", "a", "a/a"},
|
|
},
|
|
{
|
|
pattern: `dangling`,
|
|
matches: []string{"dangling"},
|
|
deps: []string{"dangling"},
|
|
},
|
|
}
|
|
|
|
func TestMockGlobDontFollowDanglingSymlinks(t *testing.T) {
|
|
files := []string{
|
|
"a/a/a",
|
|
"a/a/f -> ../../f",
|
|
"b -> a",
|
|
"c -> a/a",
|
|
"d -> c",
|
|
"e -> a/a/a",
|
|
"f",
|
|
"dangling -> missing",
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globDontFollowDanglingSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, DontFollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlobDontFollowDanglingSymlinks(t *testing.T) {
|
|
os.Chdir("testdata/dangling")
|
|
defer os.Chdir("../..")
|
|
|
|
for _, testCase := range globDontFollowDanglingSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, DontFollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
var globFollowDanglingSymlinkTestCases = []globTestCase{
|
|
{
|
|
pattern: `**/*`,
|
|
matches: []string{"a/", "b/", "c/", "d/", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f", "b/a/", "b/a/a", "b/a/f", "c/a", "c/f", "d/a", "d/f"},
|
|
deps: []string{".", "a", "a/a", "b", "b/a", "c", "d"},
|
|
},
|
|
{
|
|
pattern: `dangling`,
|
|
matches: []string{"dangling"},
|
|
deps: []string{"dangling"},
|
|
},
|
|
}
|
|
|
|
func TestMockGlobFollowDanglingSymlinks(t *testing.T) {
|
|
files := []string{
|
|
"a/a/a",
|
|
"a/a/f -> ../../f",
|
|
"b -> a",
|
|
"c -> a/a",
|
|
"d -> c",
|
|
"e -> a/a/a",
|
|
"f",
|
|
"dangling -> missing",
|
|
}
|
|
|
|
mockFiles := make(map[string][]byte)
|
|
|
|
for _, f := range files {
|
|
mockFiles[f] = nil
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
for _, testCase := range globFollowDanglingSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, mock, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlobFollowDanglingSymlinks(t *testing.T) {
|
|
os.Chdir("testdata/dangling")
|
|
defer os.Chdir("../..")
|
|
|
|
for _, testCase := range globFollowDanglingSymlinkTestCases {
|
|
t.Run(testCase.pattern, func(t *testing.T) {
|
|
testGlob(t, OsFs, testCase, FollowSymlinks)
|
|
})
|
|
}
|
|
}
|
|
|
|
func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
|
|
t.Helper()
|
|
result, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
|
|
if err != testCase.err {
|
|
if err == nil {
|
|
t.Fatalf("missing error: %s", testCase.err)
|
|
} else {
|
|
t.Fatalf("error: %s", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if !reflect.DeepEqual(result.Matches, testCase.matches) {
|
|
t.Errorf("incorrect matches list:")
|
|
t.Errorf(" pattern: %q", testCase.pattern)
|
|
if testCase.excludes != nil {
|
|
t.Errorf("excludes: %q", testCase.excludes)
|
|
}
|
|
t.Errorf(" got: %#v", result.Matches)
|
|
t.Errorf("expected: %#v", testCase.matches)
|
|
}
|
|
if !reflect.DeepEqual(result.Deps, testCase.deps) {
|
|
t.Errorf("incorrect deps list:")
|
|
t.Errorf(" pattern: %q", testCase.pattern)
|
|
if testCase.excludes != nil {
|
|
t.Errorf("excludes: %q", testCase.excludes)
|
|
}
|
|
t.Errorf(" got: %#v", result.Deps)
|
|
t.Errorf("expected: %#v", testCase.deps)
|
|
}
|
|
}
|
|
|
|
func TestMatch(t *testing.T) {
|
|
testCases := []struct {
|
|
pattern, name string
|
|
match bool
|
|
}{
|
|
{"a/*", "b/", false},
|
|
{"a/*", "b/a", false},
|
|
{"a/*", "b/b/", false},
|
|
{"a/*", "b/b/c", false},
|
|
{"a/**/*", "b/", false},
|
|
{"a/**/*", "b/a", false},
|
|
{"a/**/*", "b/b/", false},
|
|
{"a/**/*", "b/b/c", false},
|
|
|
|
{"a/*", "a/", false},
|
|
{"a/*", "a/a", true},
|
|
{"a/*", "a/b/", false},
|
|
{"a/*", "a/b/c", false},
|
|
|
|
{"a/*/", "a/", false},
|
|
{"a/*/", "a/a", false},
|
|
{"a/*/", "a/b/", true},
|
|
{"a/*/", "a/b/c", false},
|
|
|
|
{"a/**/*", "a/", false},
|
|
{"a/**/*", "a/a", true},
|
|
{"a/**/*", "a/b/", false},
|
|
{"a/**/*", "a/b/c", true},
|
|
|
|
{"a/**/*/", "a/", false},
|
|
{"a/**/*/", "a/a", false},
|
|
{"a/**/*/", "a/b/", true},
|
|
{"a/**/*/", "a/b/c", false},
|
|
|
|
{"**/*", "a/", false},
|
|
{"**/*", "a/a", true},
|
|
{"**/*", "a/b/", false},
|
|
{"**/*", "a/b/c", true},
|
|
|
|
{"**/*/", "a/", true},
|
|
{"**/*/", "a/a", false},
|
|
{"**/*/", "a/b/", true},
|
|
{"**/*/", "a/b/c", false},
|
|
|
|
{`a/\*\*/\*`, `a/**/*`, true},
|
|
{`a/\*\*/\*`, `a/a/*`, false},
|
|
{`a/\*\*/\*`, `a/**/a`, false},
|
|
{`a/\*\*/\*`, `a/a/a`, false},
|
|
|
|
{`a/**/\*`, `a/**/*`, true},
|
|
{`a/**/\*`, `a/a/*`, true},
|
|
{`a/**/\*`, `a/**/a`, false},
|
|
{`a/**/\*`, `a/a/a`, false},
|
|
|
|
{`a/\*\*/*`, `a/**/*`, true},
|
|
{`a/\*\*/*`, `a/a/*`, false},
|
|
{`a/\*\*/*`, `a/**/a`, true},
|
|
{`a/\*\*/*`, `a/a/a`, false},
|
|
|
|
{`*/**/a`, `a/a/a`, true},
|
|
{`*/**/a`, `*/a/a`, true},
|
|
{`*/**/a`, `a/**/a`, true},
|
|
{`*/**/a`, `*/**/a`, true},
|
|
|
|
{`\*/\*\*/a`, `a/a/a`, false},
|
|
{`\*/\*\*/a`, `*/a/a`, false},
|
|
{`\*/\*\*/a`, `a/**/a`, false},
|
|
{`\*/\*\*/a`, `*/**/a`, true},
|
|
|
|
{`a/?`, `a/?`, true},
|
|
{`a/?`, `a/a`, true},
|
|
{`a/\?`, `a/?`, true},
|
|
{`a/\?`, `a/a`, false},
|
|
|
|
{`a/?`, `a/?`, true},
|
|
{`a/?`, `a/a`, true},
|
|
{`a/\?`, `a/?`, true},
|
|
{`a/\?`, `a/a`, false},
|
|
|
|
{`a/[a-c]`, `a/b`, true},
|
|
{`a/[abc]`, `a/b`, true},
|
|
|
|
{`a/\[abc]`, `a/b`, false},
|
|
{`a/\[abc]`, `a/[abc]`, true},
|
|
|
|
{`a/\[abc\]`, `a/b`, false},
|
|
{`a/\[abc\]`, `a/[abc]`, true},
|
|
|
|
{`a/?`, `a/?`, true},
|
|
{`a/?`, `a/a`, true},
|
|
{`a/\?`, `a/?`, true},
|
|
{`a/\?`, `a/a`, false},
|
|
|
|
{"/a/*", "/a/", false},
|
|
{"/a/*", "/a/a", true},
|
|
{"/a/*", "/a/b/", false},
|
|
{"/a/*", "/a/b/c", false},
|
|
|
|
{"/a/*/", "/a/", false},
|
|
{"/a/*/", "/a/a", false},
|
|
{"/a/*/", "/a/b/", true},
|
|
{"/a/*/", "/a/b/c", false},
|
|
|
|
{"/a/**/*", "/a/", false},
|
|
{"/a/**/*", "/a/a", true},
|
|
{"/a/**/*", "/a/b/", false},
|
|
{"/a/**/*", "/a/b/c", true},
|
|
|
|
{"/**/*", "/a/", false},
|
|
{"/**/*", "/a/a", true},
|
|
{"/**/*", "/a/b/", false},
|
|
{"/**/*", "/a/b/c", true},
|
|
|
|
{"/**/*/", "/a/", true},
|
|
{"/**/*/", "/a/a", false},
|
|
{"/**/*/", "/a/b/", true},
|
|
{"/**/*/", "/a/b/c", false},
|
|
|
|
{`a`, `/a`, false},
|
|
{`/a`, `a`, false},
|
|
{`*`, `/a`, false},
|
|
{`/*`, `a`, false},
|
|
{`**/*`, `/a`, false},
|
|
{`/**/*`, `a`, false},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
t.Run(test.pattern+","+test.name, func(t *testing.T) {
|
|
match, err := Match(test.pattern, test.name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if match != test.match {
|
|
t.Errorf("want: %v, got %v", test.match, match)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Run the same test cases through Glob
|
|
for _, test := range testCases {
|
|
// Glob and Match disagree on matching directories
|
|
if strings.HasSuffix(test.name, "/") || strings.HasSuffix(test.pattern, "/") {
|
|
continue
|
|
}
|
|
t.Run("glob:"+test.pattern+","+test.name, func(t *testing.T) {
|
|
mockFiles := map[string][]byte{
|
|
test.name: nil,
|
|
}
|
|
|
|
mock := MockFs(mockFiles)
|
|
|
|
result, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
|
|
t.Log(test.name, test.pattern, result.Matches)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
match := false
|
|
for _, x := range result.Matches {
|
|
if x == test.name {
|
|
match = true
|
|
}
|
|
}
|
|
|
|
if match != test.match {
|
|
t.Errorf("want: %v, got %v", test.match, match)
|
|
}
|
|
})
|
|
}
|
|
}
|