tequilaOS/platform_build_blueprint
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
platform_build_blueprint/pathtools/glob_test.go

926 lines
20 KiB
Go
Raw Normal View History

Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
// 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"
Add more pathtools.Match test cases Add some more test cases for pathtools.Match before making signficant changes to it. Test: glob_test.go Change-Id: I2eeb5ebf03fb645a2053852a1a9f4e368d22084a
2019-03-25 23:04:17 +01:00
"strings"
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
"testing"
)
var pwd, _ = os.Getwd()
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
type globTestCase struct {
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
pattern string
matches []string
excludes []string
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps []string
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
err error
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
}
var globTestCases = []globTestCase{
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
// Current directory tests
{
pattern: "*",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "*.ext",
matches: []string{"d.ext", "e.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "*/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "b/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "*/*/a",
matches: []string{"a/a/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "*/a/a",
matches: []string{"a/a/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c", "a/a"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
{
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"},
},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
// ./ directory tests
{
pattern: "./*",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "./*.ext",
matches: []string{"d.ext", "e.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "./*/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "b/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "./[ac]/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "c"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
// subdirectory tests
{
pattern: "c/*/*.ext",
matches: []string{"c/f/f.ext", "c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "a/*/a",
matches: []string{"a/a/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a", "a/a", "a/b"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
// absolute tests
{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
matches: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
},
// no-wild tests
{
pattern: "a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
pattern: "a/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a/a"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
// clean tests
{
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
pattern: "./c/*/*.ext",
matches: []string{"c/f/f.ext", "c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
{
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
pattern: "c/../c/*/*.ext",
matches: []string{"c/f/f.ext", "c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
},
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
// recursive tests
{
pattern: "**/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/", "a/a/", "a/a/a", "b/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
},
{
pattern: "a/**/a",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "a/a/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a", "a/a", "a/b"},
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
},
{
pattern: "a/**/*",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "a/b/", "a/a/a", "a/b/b"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a", "a/a", "a/b"},
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
},
// absolute recursive tests
{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
pattern: filepath.Join(pwd, "testdata/glob/**/*.ext"),
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
matches: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Add recursive glob support to pathtools.Glob Recursive globs are supported by passing ** in any single non-final path element. For example, path/**/*.java will find all files named *.java under "path". Change-Id: Ifebd76f8959289f7d0d378504053c1c6b88cdeed
2015-04-24 00:45:25 +02:00
},
},
// 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,
},
Add more pathtools.Match test cases Add some more test cases for pathtools.Match before making signficant changes to it. Test: glob_test.go Change-Id: I2eeb5ebf03fb645a2053852a1a9f4e368d22084a
2019-03-25 23:04:17 +01:00
{
pattern: "a**/",
err: GlobInvalidRecursiveErr,
},
{
pattern: "**a/",
err: GlobInvalidRecursiveErr,
},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
// exclude tests
{
pattern: "*.ext",
excludes: []string{"d.ext"},
matches: []string{"e.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"a/b"},
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"a/b", "c/c"},
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "b/a", "c/f/", "c/g/", "c/h/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"c/*", "*/a"},
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/b/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"*/*"},
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
// absolute exclude tests
{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
excludes: []string{filepath.Join(pwd, "testdata/glob/c/*/f.ext")},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
matches: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
},
{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
excludes: []string{filepath.Join(pwd, "testdata/glob/c/f/*.ext")},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
matches: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
},
// recursive exclude tests
{
pattern: "*.ext",
excludes: []string{"**/*.ext"},
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"**/b"},
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*",
excludes: []string{"a/**/*"},
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{"b/a", "c/c", "c/f/", "c/g/", "c/h/"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "**/*",
excludes: []string{"**/*"},
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*/*",
excludes: []string{"a/**/a"},
matches: []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "*/*/*",
excludes: []string{"**/a"},
matches: []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "c/*/*.ext",
excludes: []string{"c/**/f.ext"},
matches: []string{"c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
// absoulte recursive exclude tests
{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
excludes: []string{filepath.Join(pwd, "testdata/glob/**/f.ext")},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
matches: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
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"),
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
},
// clean exclude tests
{
pattern: "./c/*/*.ext",
excludes: []string{"./c/*/f.ext"},
matches: []string{"c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "c/*/*.ext",
excludes: []string{"./c/*/f.ext"},
matches: []string{"c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
{
pattern: "./c/*/*.ext",
excludes: []string{"c/*/f.ext"},
matches: []string{"c/g/g.ext"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"c", "c/f", "c/g", "c/h"},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
// non-existant non-wild path tests
{
pattern: "d/*",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "d",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d/*",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/a/d/*",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a/a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/a/d",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a/a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d/a/*",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d/a",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d/a/*/a",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
{
pattern: "a/d/a/**/a",
matches: nil,
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"a"},
Fix glob dependencies when initial non-wild path does not exist If the initial non-wild part of a glob path does not exist, return the last existing part of the path as a dependency to detect if the path is created later. Change-Id: Ib5a39e6830cb386deed26e017279d0aac1bc9a20
2015-06-18 19:48:15 +02:00
},
Add GlobWithExcludes to pathtools Add GlobWithExcludes, which takes a pattern and a list of exclude patterns, and returns all files that match the pattern but do not match any exclude patterns. Change-Id: I8b94b3ba5a37409071b475b9a4035f52f47863f1
2015-04-24 02:56:11 +02:00
// 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,
},
Prevent glob from accessing hidden files Hidden files are often source control related (".git", ".repo", etc) or editor related (vim's .*.swp), so are not guaranteed to exist, and may be temporary. The build system shouldn't be using these files by default. If the glob pattern explicitly uses "." at the beginning of a path component, allow returning hidden files for that component. Because of this behavior, non-wildcard globs remain unchanged. The one behavior that cannot be handled anymore is including hidden files in recursive globs. Change-Id: I583c506e9a18ed2ff7ca011a791165d9582de90f
2016-07-26 03:40:02 +02:00
// If names are excluded by default, but referenced explicitly, they should return results
{
pattern: ".test/*",
matches: []string{".test/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".test"},
Prevent glob from accessing hidden files Hidden files are often source control related (".git", ".repo", etc) or editor related (vim's .*.swp), so are not guaranteed to exist, and may be temporary. The build system shouldn't be using these files by default. If the glob pattern explicitly uses "." at the beginning of a path component, allow returning hidden files for that component. Because of this behavior, non-wildcard globs remain unchanged. The one behavior that cannot be handled anymore is including hidden files in recursive globs. Change-Id: I583c506e9a18ed2ff7ca011a791165d9582de90f
2016-07-26 03:40:02 +02:00
},
{
pattern: ".t*/a",
matches: []string{".test/a"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", ".test"},
Prevent glob from accessing hidden files Hidden files are often source control related (".git", ".repo", etc) or editor related (vim's .*.swp), so are not guaranteed to exist, and may be temporary. The build system shouldn't be using these files by default. If the glob pattern explicitly uses "." at the beginning of a path component, allow returning hidden files for that component. Because of this behavior, non-wildcard globs remain unchanged. The one behavior that cannot be handled anymore is including hidden files in recursive globs. Change-Id: I583c506e9a18ed2ff7ca011a791165d9582de90f
2016-07-26 03:40:02 +02:00
},
{
pattern: ".*/.*",
matches: []string{".test/.ing"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{".", ".test"},
Prevent glob from accessing hidden files Hidden files are often source control related (".git", ".repo", etc) or editor related (vim's .*.swp), so are not guaranteed to exist, and may be temporary. The build system shouldn't be using these files by default. If the glob pattern explicitly uses "." at the beginning of a path component, allow returning hidden files for that component. Because of this behavior, non-wildcard globs remain unchanged. The one behavior that cannot be handled anymore is including hidden files in recursive globs. Change-Id: I583c506e9a18ed2ff7ca011a791165d9582de90f
2016-07-26 03:40:02 +02:00
},
{
pattern: ".t*",
Append / to directories in Glob results This makes it easy for users of Glob to detect whether the match is a file or directory. Doing the check at this level means that the filelist file used as a dependency will be updated if a directory is replaced with a file of the same name, or vice versa. Change-Id: I79ebba39327218bcdcf50b393498306119de9d6c
2018-02-23 23:49:45 +01:00
matches: []string{".test/", ".testing"},
Fix glob deps for non-wild patterns Patterns that were not wild would return an empty "dirs" list if the file was found. But then if they were removed, we wouldn't know to update the glob file and re-run the primary builder. In this case, instead of adding the final directory into the dirs list, add the matched files themselves. Due to editors performing atomic writes (the directory timestamp often gets updated at the same time as file timestamp) this is probably more efficient. In either case, we're only re-running the individual glob, which is rather cheap. Rename startGlob/Glob return name from "dirs" to "deps" since it may contain files now too.
2017-06-23 02:01:24 +02:00
deps: []string{"."},
Prevent glob from accessing hidden files Hidden files are often source control related (".git", ".repo", etc) or editor related (vim's .*.swp), so are not guaranteed to exist, and may be temporary. The build system shouldn't be using these files by default. If the glob pattern explicitly uses "." at the beginning of a path component, allow returning hidden files for that component. Because of this behavior, non-wildcard globs remain unchanged. The one behavior that cannot be handled anymore is including hidden files in recursive globs. Change-Id: I583c506e9a18ed2ff7ca011a791165d9582de90f
2016-07-26 03:40:02 +02:00
},
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
}
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
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
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
mockFiles[filepath.Join(pwd, "testdata/glob", f)] = nil
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
}
mock := MockFs(mockFiles)
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
for _, testCase := range globTestCases {
t.Run(testCase.pattern, func(t *testing.T) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
testGlob(t, mock, testCase, FollowSymlinks)
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
})
}
}
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
func TestGlob(t *testing.T) {
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
os.Chdir("testdata/glob")
defer os.Chdir("../..")
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
for _, testCase := range globTestCases {
t.Run(testCase.pattern, func(t *testing.T) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
testGlob(t, OsFs, testCase, FollowSymlinks)
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
})
}
}
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
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`},
},
}
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
func TestMockGlobEscapes(t *testing.T) {
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
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) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
testGlob(t, mock, testCase, FollowSymlinks)
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
})
}
}
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
func TestGlobEscapes(t *testing.T) {
os.Chdir("testdata/escapes")
defer os.Chdir("../..")
for _, testCase := range globEscapeTestCases {
t.Run(testCase.pattern, func(t *testing.T) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
testGlob(t, OsFs, testCase, FollowSymlinks)
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
})
}
}
Fix recursive globs through symlinks filepath.Walk does not walk symlinks to directories, which leads to inconsitent behavior with following symlinks. Replace the use of filepath.Walk in ListDirsRecursive with a helper function that lists each directory and walks anything for which IsDir reports true, which includes following symlinks, and then reconstructs the path through the symlink. Test: fs_test.go Test: glob_test.go Change-Id: Ie4dd0820e9c7c0a124caa65210ce20439a44da16
2018-09-21 07:44:36 +02:00
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"},
},
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
{
pattern: `b/**/*`,
matches: []string{"b/a/", "b/a/a"},
deps: []string{"b", "b/a"},
},
Fix recursive globs through symlinks filepath.Walk does not walk symlinks to directories, which leads to inconsitent behavior with following symlinks. Replace the use of filepath.Walk in ListDirsRecursive with a helper function that lists each directory and walks anything for which IsDir reports true, which includes following symlinks, and then reconstructs the path through the symlink. Test: fs_test.go Test: glob_test.go Change-Id: Ie4dd0820e9c7c0a124caa65210ce20439a44da16
2018-09-21 07:44:36 +02:00
}
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) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
testGlob(t, mock, testCase, FollowSymlinks)
Fix recursive globs through symlinks filepath.Walk does not walk symlinks to directories, which leads to inconsitent behavior with following symlinks. Replace the use of filepath.Walk in ListDirsRecursive with a helper function that lists each directory and walks anything for which IsDir reports true, which includes following symlinks, and then reconstructs the path through the symlink. Test: fs_test.go Test: glob_test.go Change-Id: Ie4dd0820e9c7c0a124caa65210ce20439a44da16
2018-09-21 07:44:36 +02:00
})
}
}
func TestGlobSymlinks(t *testing.T) {
os.Chdir("testdata/symlinks")
defer os.Chdir("../..")
for _, testCase := range globSymlinkTestCases {
t.Run(testCase.pattern, func(t *testing.T) {
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
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)
Fix recursive globs through symlinks filepath.Walk does not walk symlinks to directories, which leads to inconsitent behavior with following symlinks. Replace the use of filepath.Walk in ListDirsRecursive with a helper function that lists each directory and walks anything for which IsDir reports true, which includes following symlinks, and then reconstructs the path through the symlink. Test: fs_test.go Test: glob_test.go Change-Id: Ie4dd0820e9c7c0a124caa65210ce20439a44da16
2018-09-21 07:44:36 +02:00
})
}
}
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
Add OsFs tests for escaped globs Test: glob_test.go Change-Id: I18d5f0c1139c68eafe4993792e8640d2144d49e1
2018-09-21 23:13:03 +02:00
t.Helper()
Add ShouldFollowSymlinks argument to pathtools.Glob Allow the caller to specify whether symlinks should be followed (the old behavior) or not. Test: glob_test.go Test: fs_test.go Change-Id: I550dc91b8e6370fb32a9a1cbdcb2edade48bda46
2018-09-22 00:30:13 +02:00
matches, deps, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
if err != testCase.err {
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
if err == nil {
t.Fatalf("missing error: %s", testCase.err)
} else {
t.Fatalf("error: %s", err)
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
}
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
return
}
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
if !reflect.DeepEqual(matches, testCase.matches) {
t.Errorf("incorrect matches list:")
t.Errorf(" pattern: %q", testCase.pattern)
if testCase.excludes != nil {
t.Errorf("excludes: %q", testCase.excludes)
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
}
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
t.Errorf(" got: %#v", matches)
t.Errorf("expected: %#v", testCase.matches)
}
if !reflect.DeepEqual(deps, testCase.deps) {
t.Errorf("incorrect deps list:")
t.Errorf(" pattern: %q", testCase.pattern)
if testCase.excludes != nil {
t.Errorf("excludes: %q", testCase.excludes)
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
}
Fix recursive glob on MockFs Recursive globs on MockFs were ending up in an unmocked os.Lstat call in walkAllDirs. Move walkAllDirs into the FileSystem interface as ListDirsRecursive. Also duplicate the glob tests on both the real filesystem and on MockFs. Test: glob_test.go Change-Id: Ia6b6b5eecdd17955a49d684a0fd5e55df05cfe62
2017-10-04 00:58:50 +02:00
t.Errorf(" got: %#v", deps)
t.Errorf("expected: %#v", testCase.deps)
Rewrite pathtools.Glob to track partially-matched directories The directory structure: a/ a b/ b With the glob pattern */a would previously return []string{"a"} for dirs, but it needs to return []string{"a", "b"} in order to re-run the generator if a file called "a" is created inside b/. Rewrite Glob to manually recurse through path elements, only calling filepath.Glob for a pattern with wilds in the last element of the path, and add the globbed directory to the dirs list each time. Also add tests and test data for pathtools.Glob. Change-Id: Ibbdb2f99809ea0826d4fa82066cf84103005ef57
2015-04-23 22:29:28 +02:00
}
}
Support trailing slash in pathtools.Match patterns pathtools.Match was trimming the trailing slash from patterns. Make it handle a trailing slash by first confirming that both the pattern and name either both have or both do not have a trailing slash, and then trimming it from both. Bug: 111389216 Test: TestMatch in glob_test.go Change-Id: I743e00c14d885de5b5a060aa9e2b22c81dc7e09d
2018-07-14 06:17:48 +02:00
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},
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
Add more pathtools.Match test cases Add some more test cases for pathtools.Match before making signficant changes to it. Test: glob_test.go Change-Id: I2eeb5ebf03fb645a2053852a1a9f4e368d22084a
2019-03-25 23:04:17 +01:00
{"**/*", "a/", false},
{"**/*", "a/a", true},
{"**/*", "a/b/", false},
{"**/*", "a/b/c", true},
{"**/*/", "a/", true},
{"**/*/", "a/a", false},
{"**/*/", "a/b/", true},
{"**/*/", "a/b/c", false},
Fix globs matching files with wildcard characters in the name Globs that match a file that looks like a glob were causing duplicate results because the prefix match would then re-match the filename as a wildcard. Add escaping to prevent re-matching. Also add tests for globs on files with wildcards, tests for ? and [a-z] glob matches supported by filepath.Match, and tests for escaped wildcard characters. Test: glob_test.go Change-Id: Id11a754863979bb36cca0dbd18ea2e76dd1470e3
2018-09-19 22:36:42 +02:00
{`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},
Add more pathtools.Match test cases Add some more test cases for pathtools.Match before making signficant changes to it. Test: glob_test.go Change-Id: I2eeb5ebf03fb645a2053852a1a9f4e368d22084a
2019-03-25 23:04:17 +01:00
{"/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},
Support trailing slash in pathtools.Match patterns pathtools.Match was trimming the trailing slash from patterns. Make it handle a trailing slash by first confirming that both the pattern and name either both have or both do not have a trailing slash, and then trimming it from both. Bug: 111389216 Test: TestMatch in glob_test.go Change-Id: I743e00c14d885de5b5a060aa9e2b22c81dc7e09d
2018-07-14 06:17:48 +02:00
}
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)
}
})
}
Add more pathtools.Match test cases Add some more test cases for pathtools.Match before making signficant changes to it. Test: glob_test.go Change-Id: I2eeb5ebf03fb645a2053852a1a9f4e368d22084a
2019-03-25 23:04:17 +01:00
// 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)
matches, _, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
t.Log(test.name, test.pattern, matches)
if err != nil {
t.Fatal(err)
}
match := false
for _, x := range matches {
if x == test.name {
match = true
}
}
if match != test.match {
t.Errorf("want: %v, got %v", test.match, match)
}
})
}
Support trailing slash in pathtools.Match patterns pathtools.Match was trimming the trailing slash from patterns. Make it handle a trailing slash by first confirming that both the pattern and name either both have or both do not have a trailing slash, and then trimming it from both. Bug: 111389216 Test: TestMatch in glob_test.go Change-Id: I743e00c14d885de5b5a060aa9e2b22c81dc7e09d
2018-07-14 06:17:48 +02:00
}
Reference in a new issue Copy permalink