67c99255cc
Replace the individual matches and deps return values with a GlobResult struct. Use the GlobResult to create the file list file in GlobWithDepFile (used by bpglob) and in the glob singleton, as the generated files must match exactly so that soong_build is not rerun. Bug: 159845846 Test: glob_test.go Change-Id: I2159cc9d85f388073198eac7456e5bf43e813096
925 lines
20 KiB
Go
925 lines
20 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)
|
|
})
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
}
|