+20

pkg/path/testdata/example_test.go

reviewed

··· 1 1 + // Copyright 2017 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath_test 6 6 + 7 7 + import ( 8 8 + "fmt" 9 9 + "path/filepath" 10 10 + ) 11 11 + 12 12 + func ExampleExt() { 13 13 + fmt.Printf("No dots: %q\n", filepath.Ext("index")) 14 14 + fmt.Printf("One dot: %q\n", filepath.Ext("index.js")) 15 15 + fmt.Printf("Two dots: %q\n", filepath.Ext("main.test.js")) 16 16 + // Output: 17 17 + // No dots: "" 18 18 + // One dot: ".js" 19 19 + // Two dots: ".js" 20 20 + }

+171

pkg/path/testdata/example_unix_test.go

reviewed

··· 1 1 + // Copyright 2013 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + // +build !windows,!plan9 6 6 + 7 7 + package filepath_test 8 8 + 9 9 + import ( 10 10 + "fmt" 11 11 + "path/filepath" 12 12 + ) 13 13 + 14 14 + func ExampleSplitList() { 15 15 + fmt.Println("On Unix:", filepath.SplitList("/a/b/c:/usr/bin")) 16 16 + // Output: 17 17 + // On Unix: [/a/b/c /usr/bin] 18 18 + } 19 19 + 20 20 + func ExampleRel() { 21 21 + paths := []string{ 22 22 + "/a/b/c", 23 23 + "/b/c", 24 24 + "./b/c", 25 25 + } 26 26 + base := "/a" 27 27 + 28 28 + fmt.Println("On Unix:") 29 29 + for _, p := range paths { 30 30 + rel, err := filepath.Rel(base, p) 31 31 + fmt.Printf("%q: %q %v\n", p, rel, err) 32 32 + } 33 33 + 34 34 + // Output: 35 35 + // On Unix: 36 36 + // "/a/b/c": "b/c" <nil> 37 37 + // "/b/c": "../b/c" <nil> 38 38 + // "./b/c": "" Rel: can't make ./b/c relative to /a 39 39 + } 40 40 + 41 41 + func ExampleSplit() { 42 42 + paths := []string{ 43 43 + "/home/arnie/amelia.jpg", 44 44 + "/mnt/photos/", 45 45 + "rabbit.jpg", 46 46 + "/usr/local//go", 47 47 + } 48 48 + fmt.Println("On Unix:") 49 49 + for _, p := range paths { 50 50 + dir, file := filepath.Split(p) 51 51 + fmt.Printf("input: %q\n\tdir: %q\n\tfile: %q\n", p, dir, file) 52 52 + } 53 53 + // Output: 54 54 + // On Unix: 55 55 + // input: "/home/arnie/amelia.jpg" 56 56 + // dir: "/home/arnie/" 57 57 + // file: "amelia.jpg" 58 58 + // input: "/mnt/photos/" 59 59 + // dir: "/mnt/photos/" 60 60 + // file: "" 61 61 + // input: "rabbit.jpg" 62 62 + // dir: "" 63 63 + // file: "rabbit.jpg" 64 64 + // input: "/usr/local//go" 65 65 + // dir: "/usr/local//" 66 66 + // file: "go" 67 67 + } 68 68 + 69 69 + func ExampleJoin() { 70 70 + fmt.Println("On Unix:") 71 71 + fmt.Println(filepath.Join("a", "b", "c")) 72 72 + fmt.Println(filepath.Join("a", "b/c")) 73 73 + fmt.Println(filepath.Join("a/b", "c")) 74 74 + fmt.Println(filepath.Join("a/b", "/c")) 75 75 + 76 76 + fmt.Println(filepath.Join("a/b", "../../../xyz")) 77 77 + 78 78 + // Output: 79 79 + // On Unix: 80 80 + // a/b/c 81 81 + // a/b/c 82 82 + // a/b/c 83 83 + // a/b/c 84 84 + // ../xyz 85 85 + } 86 86 + 87 87 + func ExampleMatch() { 88 88 + fmt.Println("On Unix:") 89 89 + fmt.Println(filepath.Match("/home/catch/*", "/home/catch/foo")) 90 90 + fmt.Println(filepath.Match("/home/catch/*", "/home/catch/foo/bar")) 91 91 + fmt.Println(filepath.Match("/home/?opher", "/home/gopher")) 92 92 + fmt.Println(filepath.Match("/home/\\*", "/home/*")) 93 93 + 94 94 + // Output: 95 95 + // On Unix: 96 96 + // true <nil> 97 97 + // false <nil> 98 98 + // true <nil> 99 99 + // true <nil> 100 100 + } 101 101 + 102 102 + func ExampleBase() { 103 103 + fmt.Println("On Unix:") 104 104 + fmt.Println(filepath.Base("/foo/bar/baz.js")) 105 105 + fmt.Println(filepath.Base("/foo/bar/baz")) 106 106 + fmt.Println(filepath.Base("/foo/bar/baz/")) 107 107 + fmt.Println(filepath.Base("dev.txt")) 108 108 + fmt.Println(filepath.Base("../todo.txt")) 109 109 + fmt.Println(filepath.Base("..")) 110 110 + fmt.Println(filepath.Base(".")) 111 111 + fmt.Println(filepath.Base("/")) 112 112 + fmt.Println(filepath.Base("")) 113 113 + 114 114 + // Output: 115 115 + // On Unix: 116 116 + // baz.js 117 117 + // baz 118 118 + // baz 119 119 + // dev.txt 120 120 + // todo.txt 121 121 + // .. 122 122 + // . 123 123 + // / 124 124 + // . 125 125 + } 126 126 + 127 127 + func ExampleDir() { 128 128 + fmt.Println("On Unix:") 129 129 + fmt.Println(filepath.Dir("/foo/bar/baz.js")) 130 130 + fmt.Println(filepath.Dir("/foo/bar/baz")) 131 131 + fmt.Println(filepath.Dir("/foo/bar/baz/")) 132 132 + fmt.Println(filepath.Dir("/dirty//path///")) 133 133 + fmt.Println(filepath.Dir("dev.txt")) 134 134 + fmt.Println(filepath.Dir("../todo.txt")) 135 135 + fmt.Println(filepath.Dir("..")) 136 136 + fmt.Println(filepath.Dir(".")) 137 137 + fmt.Println(filepath.Dir("/")) 138 138 + fmt.Println(filepath.Dir("")) 139 139 + 140 140 + // Output: 141 141 + // On Unix: 142 142 + // /foo/bar 143 143 + // /foo/bar 144 144 + // /foo/bar/baz 145 145 + // /dirty/path 146 146 + // . 147 147 + // .. 148 148 + // . 149 149 + // . 150 150 + // / 151 151 + // . 152 152 + } 153 153 + 154 154 + func ExampleIsAbs() { 155 155 + fmt.Println("On Unix:") 156 156 + fmt.Println(filepath.IsAbs("/home/gopher")) 157 157 + fmt.Println(filepath.IsAbs(".bashrc")) 158 158 + fmt.Println(filepath.IsAbs("..")) 159 159 + fmt.Println(filepath.IsAbs(".")) 160 160 + fmt.Println(filepath.IsAbs("/")) 161 161 + fmt.Println(filepath.IsAbs("")) 162 162 + 163 163 + // Output: 164 164 + // On Unix: 165 165 + // true 166 166 + // false 167 167 + // false 168 168 + // false 169 169 + // true 170 170 + // false 171 171 + }

+67

pkg/path/testdata/example_unix_walk_test.go

reviewed

··· 1 1 + // Copyright 2018 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + // +build !windows,!plan9 6 6 + 7 7 + package filepath_test 8 8 + 9 9 + import ( 10 10 + "fmt" 11 11 + "io/fs" 12 12 + "io/ioutil" 13 13 + "os" 14 14 + "path/filepath" 15 15 + ) 16 16 + 17 17 + func prepareTestDirTree(tree string) (string, error) { 18 18 + tmpDir, err := ioutil.TempDir("", "") 19 19 + if err != nil { 20 20 + return "", fmt.Errorf("error creating temp directory: %v\n", err) 21 21 + } 22 22 + 23 23 + err = os.MkdirAll(filepath.Join(tmpDir, tree), 0755) 24 24 + if err != nil { 25 25 + os.RemoveAll(tmpDir) 26 26 + return "", err 27 27 + } 28 28 + 29 29 + return tmpDir, nil 30 30 + } 31 31 + 32 32 + func ExampleWalk() { 33 33 + tmpDir, err := prepareTestDirTree("dir/to/walk/skip") 34 34 + if err != nil { 35 35 + fmt.Printf("unable to create test dir tree: %v\n", err) 36 36 + return 37 37 + } 38 38 + defer os.RemoveAll(tmpDir) 39 39 + os.Chdir(tmpDir) 40 40 + 41 41 + subDirToSkip := "skip" 42 42 + 43 43 + fmt.Println("On Unix:") 44 44 + err = filepath.Walk(".", func(path string, info fs.FileInfo, err error) error { 45 45 + if err != nil { 46 46 + fmt.Printf("prevent panic by handling failure accessing a path %q: %v\n", path, err) 47 47 + return err 48 48 + } 49 49 + if info.IsDir() && info.Name() == subDirToSkip { 50 50 + fmt.Printf("skipping a dir without errors: %+v \n", info.Name()) 51 51 + return filepath.SkipDir 52 52 + } 53 53 + fmt.Printf("visited file or dir: %q\n", path) 54 54 + return nil 55 55 + }) 56 56 + if err != nil { 57 57 + fmt.Printf("error walking the path %q: %v\n", tmpDir, err) 58 58 + return 59 59 + } 60 60 + // Output: 61 61 + // On Unix: 62 62 + // visited file or dir: "." 63 63 + // visited file or dir: "dir" 64 64 + // visited file or dir: "dir/to" 65 65 + // visited file or dir: "dir/to/walk" 66 66 + // skipping a dir without errors: skip 67 67 + }

+7

pkg/path/testdata/export_test.go

reviewed

··· 1 1 + // Copyright 2013 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + var LstatP = &lstat

+10

pkg/path/testdata/export_windows_test.go

reviewed

··· 1 1 + // Copyright 2016 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + var ( 8 8 + ToNorm = toNorm 9 9 + NormBase = normBase 10 10 + )

+360

pkg/path/testdata/match.go

reviewed

··· 1 1 + // Copyright 2010 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + import ( 8 8 + "errors" 9 9 + "os" 10 10 + "runtime" 11 11 + "sort" 12 12 + "strings" 13 13 + "unicode/utf8" 14 14 + ) 15 15 + 16 16 + // ErrBadPattern indicates a pattern was malformed. 17 17 + var ErrBadPattern = errors.New("syntax error in pattern") 18 18 + 19 19 + // Match reports whether name matches the shell file name pattern. 20 20 + // The pattern syntax is: 21 21 + // 22 22 + // pattern: 23 23 + // { term } 24 24 + // term: 25 25 + // '*' matches any sequence of non-Separator characters 26 26 + // '?' matches any single non-Separator character 27 27 + // '[' [ '^' ] { character-range } ']' 28 28 + // character class (must be non-empty) 29 29 + // c matches character c (c != '*', '?', '\\', '[') 30 30 + // '\\' c matches character c 31 31 + // 32 32 + // character-range: 33 33 + // c matches character c (c != '\\', '-', ']') 34 34 + // '\\' c matches character c 35 35 + // lo '-' hi matches character c for lo <= c <= hi 36 36 + // 37 37 + // Match requires pattern to match all of name, not just a substring. 38 38 + // The only possible returned error is ErrBadPattern, when pattern 39 39 + // is malformed. 40 40 + // 41 41 + // On Windows, escaping is disabled. Instead, '\\' is treated as 42 42 + // path separator. 43 43 + // 44 44 + func Match(pattern, name string) (matched bool, err error) { 45 45 + Pattern: 46 46 + for len(pattern) > 0 { 47 47 + var star bool 48 48 + var chunk string 49 49 + star, chunk, pattern = scanChunk(pattern) 50 50 + if star && chunk == "" { 51 51 + // Trailing * matches rest of string unless it has a /. 52 52 + return !strings.Contains(name, string(Separator)), nil 53 53 + } 54 54 + // Look for match at current position. 55 55 + t, ok, err := matchChunk(chunk, name) 56 56 + // if we're the last chunk, make sure we've exhausted the name 57 57 + // otherwise we'll give a false result even if we could still match 58 58 + // using the star 59 59 + if ok && (len(t) == 0 || len(pattern) > 0) { 60 60 + name = t 61 61 + continue 62 62 + } 63 63 + if err != nil { 64 64 + return false, err 65 65 + } 66 66 + if star { 67 67 + // Look for match skipping i+1 bytes. 68 68 + // Cannot skip /. 69 69 + for i := 0; i < len(name) && name[i] != Separator; i++ { 70 70 + t, ok, err := matchChunk(chunk, name[i+1:]) 71 71 + if ok { 72 72 + // if we're the last chunk, make sure we exhausted the name 73 73 + if len(pattern) == 0 && len(t) > 0 { 74 74 + continue 75 75 + } 76 76 + name = t 77 77 + continue Pattern 78 78 + } 79 79 + if err != nil { 80 80 + return false, err 81 81 + } 82 82 + } 83 83 + } 84 84 + return false, nil 85 85 + } 86 86 + return len(name) == 0, nil 87 87 + } 88 88 + 89 89 + // scanChunk gets the next segment of pattern, which is a non-star string 90 90 + // possibly preceded by a star. 91 91 + func scanChunk(pattern string) (star bool, chunk, rest string) { 92 92 + for len(pattern) > 0 && pattern[0] == '*' { 93 93 + pattern = pattern[1:] 94 94 + star = true 95 95 + } 96 96 + inrange := false 97 97 + var i int 98 98 + Scan: 99 99 + for i = 0; i < len(pattern); i++ { 100 100 + switch pattern[i] { 101 101 + case '\\': 102 102 + if runtime.GOOS != "windows" { 103 103 + // error check handled in matchChunk: bad pattern. 104 104 + if i+1 < len(pattern) { 105 105 + i++ 106 106 + } 107 107 + } 108 108 + case '[': 109 109 + inrange = true 110 110 + case ']': 111 111 + inrange = false 112 112 + case '*': 113 113 + if !inrange { 114 114 + break Scan 115 115 + } 116 116 + } 117 117 + } 118 118 + return star, pattern[0:i], pattern[i:] 119 119 + } 120 120 + 121 121 + // matchChunk checks whether chunk matches the beginning of s. 122 122 + // If so, it returns the remainder of s (after the match). 123 123 + // Chunk is all single-character operators: literals, char classes, and ?. 124 124 + func matchChunk(chunk, s string) (rest string, ok bool, err error) { 125 125 + // failed records whether the match has failed. 126 126 + // After the match fails, the loop continues on processing chunk, 127 127 + // checking that the pattern is well-formed but no longer reading s. 128 128 + failed := false 129 129 + for len(chunk) > 0 { 130 130 + if !failed && len(s) == 0 { 131 131 + failed = true 132 132 + } 133 133 + switch chunk[0] { 134 134 + case '[': 135 135 + // character class 136 136 + var r rune 137 137 + if !failed { 138 138 + var n int 139 139 + r, n = utf8.DecodeRuneInString(s) 140 140 + s = s[n:] 141 141 + } 142 142 + chunk = chunk[1:] 143 143 + // possibly negated 144 144 + negated := false 145 145 + if len(chunk) > 0 && chunk[0] == '^' { 146 146 + negated = true 147 147 + chunk = chunk[1:] 148 148 + } 149 149 + // parse all ranges 150 150 + match := false 151 151 + nrange := 0 152 152 + for { 153 153 + if len(chunk) > 0 && chunk[0] == ']' && nrange > 0 { 154 154 + chunk = chunk[1:] 155 155 + break 156 156 + } 157 157 + var lo, hi rune 158 158 + if lo, chunk, err = getEsc(chunk); err != nil { 159 159 + return "", false, err 160 160 + } 161 161 + hi = lo 162 162 + if chunk[0] == '-' { 163 163 + if hi, chunk, err = getEsc(chunk[1:]); err != nil { 164 164 + return "", false, err 165 165 + } 166 166 + } 167 167 + if lo <= r && r <= hi { 168 168 + match = true 169 169 + } 170 170 + nrange++ 171 171 + } 172 172 + if match == negated { 173 173 + failed = true 174 174 + } 175 175 + 176 176 + case '?': 177 177 + if !failed { 178 178 + if s[0] == Separator { 179 179 + failed = true 180 180 + } 181 181 + _, n := utf8.DecodeRuneInString(s) 182 182 + s = s[n:] 183 183 + } 184 184 + chunk = chunk[1:] 185 185 + 186 186 + case '\\': 187 187 + if runtime.GOOS != "windows" { 188 188 + chunk = chunk[1:] 189 189 + if len(chunk) == 0 { 190 190 + return "", false, ErrBadPattern 191 191 + } 192 192 + } 193 193 + fallthrough 194 194 + 195 195 + default: 196 196 + if !failed { 197 197 + if chunk[0] != s[0] { 198 198 + failed = true 199 199 + } 200 200 + s = s[1:] 201 201 + } 202 202 + chunk = chunk[1:] 203 203 + } 204 204 + } 205 205 + if failed { 206 206 + return "", false, nil 207 207 + } 208 208 + return s, true, nil 209 209 + } 210 210 + 211 211 + // getEsc gets a possibly-escaped character from chunk, for a character class. 212 212 + func getEsc(chunk string) (r rune, nchunk string, err error) { 213 213 + if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' { 214 214 + err = ErrBadPattern 215 215 + return 216 216 + } 217 217 + if chunk[0] == '\\' && runtime.GOOS != "windows" { 218 218 + chunk = chunk[1:] 219 219 + if len(chunk) == 0 { 220 220 + err = ErrBadPattern 221 221 + return 222 222 + } 223 223 + } 224 224 + r, n := utf8.DecodeRuneInString(chunk) 225 225 + if r == utf8.RuneError && n == 1 { 226 226 + err = ErrBadPattern 227 227 + } 228 228 + nchunk = chunk[n:] 229 229 + if len(nchunk) == 0 { 230 230 + err = ErrBadPattern 231 231 + } 232 232 + return 233 233 + } 234 234 + 235 235 + // Glob returns the names of all files matching pattern or nil 236 236 + // if there is no matching file. The syntax of patterns is the same 237 237 + // as in Match. The pattern may describe hierarchical names such as 238 238 + // /usr/*/bin/ed (assuming the Separator is '/'). 239 239 + // 240 240 + // Glob ignores file system errors such as I/O errors reading directories. 241 241 + // The only possible returned error is ErrBadPattern, when pattern 242 242 + // is malformed. 243 243 + func Glob(pattern string) (matches []string, err error) { 244 244 + // Check pattern is well-formed. 245 245 + if _, err := Match(pattern, ""); err != nil { 246 246 + return nil, err 247 247 + } 248 248 + if !hasMeta(pattern) { 249 249 + if _, err = os.Lstat(pattern); err != nil { 250 250 + return nil, nil 251 251 + } 252 252 + return []string{pattern}, nil 253 253 + } 254 254 + 255 255 + dir, file := Split(pattern) 256 256 + volumeLen := 0 257 257 + if runtime.GOOS == "windows" { 258 258 + volumeLen, dir = cleanGlobPathWindows(dir) 259 259 + } else { 260 260 + dir = cleanGlobPath(dir) 261 261 + } 262 262 + 263 263 + if !hasMeta(dir[volumeLen:]) { 264 264 + return glob(dir, file, nil) 265 265 + } 266 266 + 267 267 + // Prevent infinite recursion. See issue 15879. 268 268 + if dir == pattern { 269 269 + return nil, ErrBadPattern 270 270 + } 271 271 + 272 272 + var m []string 273 273 + m, err = Glob(dir) 274 274 + if err != nil { 275 275 + return 276 276 + } 277 277 + for _, d := range m { 278 278 + matches, err = glob(d, file, matches) 279 279 + if err != nil { 280 280 + return 281 281 + } 282 282 + } 283 283 + return 284 284 + } 285 285 + 286 286 + // cleanGlobPath prepares path for glob matching. 287 287 + func cleanGlobPath(path string) string { 288 288 + switch path { 289 289 + case "": 290 290 + return "." 291 291 + case string(Separator): 292 292 + // do nothing to the path 293 293 + return path 294 294 + default: 295 295 + return path[0 : len(path)-1] // chop off trailing separator 296 296 + } 297 297 + } 298 298 + 299 299 + // cleanGlobPathWindows is windows version of cleanGlobPath. 300 300 + func cleanGlobPathWindows(path string) (prefixLen int, cleaned string) { 301 301 + vollen := volumeNameLen(path) 302 302 + switch { 303 303 + case path == "": 304 304 + return 0, "." 305 305 + case vollen+1 == len(path) && os.IsPathSeparator(path[len(path)-1]): // /, \, C:\ and C:/ 306 306 + // do nothing to the path 307 307 + return vollen + 1, path 308 308 + case vollen == len(path) && len(path) == 2: // C: 309 309 + return vollen, path + "." // convert C: into C:. 310 310 + default: 311 311 + if vollen >= len(path) { 312 312 + vollen = len(path) - 1 313 313 + } 314 314 + return vollen, path[0 : len(path)-1] // chop off trailing separator 315 315 + } 316 316 + } 317 317 + 318 318 + // glob searches for files matching pattern in the directory dir 319 319 + // and appends them to matches. If the directory cannot be 320 320 + // opened, it returns the existing matches. New matches are 321 321 + // added in lexicographical order. 322 322 + func glob(dir, pattern string, matches []string) (m []string, e error) { 323 323 + m = matches 324 324 + fi, err := os.Stat(dir) 325 325 + if err != nil { 326 326 + return // ignore I/O error 327 327 + } 328 328 + if !fi.IsDir() { 329 329 + return // ignore I/O error 330 330 + } 331 331 + d, err := os.Open(dir) 332 332 + if err != nil { 333 333 + return // ignore I/O error 334 334 + } 335 335 + defer d.Close() 336 336 + 337 337 + names, _ := d.Readdirnames(-1) 338 338 + sort.Strings(names) 339 339 + 340 340 + for _, n := range names { 341 341 + matched, err := Match(pattern, n) 342 342 + if err != nil { 343 343 + return m, err 344 344 + } 345 345 + if matched { 346 346 + m = append(m, Join(dir, n)) 347 347 + } 348 348 + } 349 349 + return 350 350 + } 351 351 + 352 352 + // hasMeta reports whether path contains any of the magic characters 353 353 + // recognized by Match. 354 354 + func hasMeta(path string) bool { 355 355 + magicChars := `*?[` 356 356 + if runtime.GOOS != "windows" { 357 357 + magicChars = `*?[\` 358 358 + } 359 359 + return strings.ContainsAny(path, magicChars) 360 360 + }

+393

pkg/path/testdata/match_test.go

reviewed

··· 1 1 + // Copyright 2009 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath_test 6 6 + 7 7 + import ( 8 8 + "fmt" 9 9 + "internal/testenv" 10 10 + "io/ioutil" 11 11 + "os" 12 12 + . "path/filepath" 13 13 + "reflect" 14 14 + "runtime" 15 15 + "sort" 16 16 + "strings" 17 17 + "testing" 18 18 + ) 19 19 + 20 20 + type MatchTest struct { 21 21 + pattern, s string 22 22 + match bool 23 23 + err error 24 24 + } 25 25 + 26 26 + var matchTests = []MatchTest{ 27 27 + {"abc", "abc", true, nil}, 28 28 + {"*", "abc", true, nil}, 29 29 + {"*c", "abc", true, nil}, 30 30 + {"a*", "a", true, nil}, 31 31 + {"a*", "abc", true, nil}, 32 32 + {"a*", "ab/c", false, nil}, 33 33 + {"a*/b", "abc/b", true, nil}, 34 34 + {"a*/b", "a/c/b", false, nil}, 35 35 + {"a*b*c*d*e*/f", "axbxcxdxe/f", true, nil}, 36 36 + {"a*b*c*d*e*/f", "axbxcxdxexxx/f", true, nil}, 37 37 + {"a*b*c*d*e*/f", "axbxcxdxe/xxx/f", false, nil}, 38 38 + {"a*b*c*d*e*/f", "axbxcxdxexxx/fff", false, nil}, 39 39 + {"a*b?c*x", "abxbbxdbxebxczzx", true, nil}, 40 40 + {"a*b?c*x", "abxbbxdbxebxczzy", false, nil}, 41 41 + {"ab[c]", "abc", true, nil}, 42 42 + {"ab[b-d]", "abc", true, nil}, 43 43 + {"ab[e-g]", "abc", false, nil}, 44 44 + {"ab[^c]", "abc", false, nil}, 45 45 + {"ab[^b-d]", "abc", false, nil}, 46 46 + {"ab[^e-g]", "abc", true, nil}, 47 47 + {"a\\*b", "a*b", true, nil}, 48 48 + {"a\\*b", "ab", false, nil}, 49 49 + {"a?b", "a☺b", true, nil}, 50 50 + {"a[^a]b", "a☺b", true, nil}, 51 51 + {"a???b", "a☺b", false, nil}, 52 52 + {"a[^a][^a][^a]b", "a☺b", false, nil}, 53 53 + {"[a-ζ]*", "α", true, nil}, 54 54 + {"*[a-ζ]", "A", false, nil}, 55 55 + {"a?b", "a/b", false, nil}, 56 56 + {"a*b", "a/b", false, nil}, 57 57 + {"[\\]a]", "]", true, nil}, 58 58 + {"[\\-]", "-", true, nil}, 59 59 + {"[x\\-]", "x", true, nil}, 60 60 + {"[x\\-]", "-", true, nil}, 61 61 + {"[x\\-]", "z", false, nil}, 62 62 + {"[\\-x]", "x", true, nil}, 63 63 + {"[\\-x]", "-", true, nil}, 64 64 + {"[\\-x]", "a", false, nil}, 65 65 + {"[]a]", "]", false, ErrBadPattern}, 66 66 + {"[-]", "-", false, ErrBadPattern}, 67 67 + {"[x-]", "x", false, ErrBadPattern}, 68 68 + {"[x-]", "-", false, ErrBadPattern}, 69 69 + {"[x-]", "z", false, ErrBadPattern}, 70 70 + {"[-x]", "x", false, ErrBadPattern}, 71 71 + {"[-x]", "-", false, ErrBadPattern}, 72 72 + {"[-x]", "a", false, ErrBadPattern}, 73 73 + {"\\", "a", false, ErrBadPattern}, 74 74 + {"[a-b-c]", "a", false, ErrBadPattern}, 75 75 + {"[", "a", false, ErrBadPattern}, 76 76 + {"[^", "a", false, ErrBadPattern}, 77 77 + {"[^bc", "a", false, ErrBadPattern}, 78 78 + {"a[", "a", false, ErrBadPattern}, 79 79 + {"a[", "ab", false, ErrBadPattern}, 80 80 + {"a[", "x", false, ErrBadPattern}, 81 81 + {"a/b[", "x", false, ErrBadPattern}, 82 82 + {"*x", "xxx", true, nil}, 83 83 + } 84 84 + 85 85 + func errp(e error) string { 86 86 + if e == nil { 87 87 + return "<nil>" 88 88 + } 89 89 + return e.Error() 90 90 + } 91 91 + 92 92 + func TestMatch(t *testing.T) { 93 93 + for _, tt := range matchTests { 94 94 + pattern := tt.pattern 95 95 + s := tt.s 96 96 + if runtime.GOOS == "windows" { 97 97 + if strings.Contains(pattern, "\\") { 98 98 + // no escape allowed on windows. 99 99 + continue 100 100 + } 101 101 + pattern = Clean(pattern) 102 102 + s = Clean(s) 103 103 + } 104 104 + ok, err := Match(pattern, s) 105 105 + if ok != tt.match || err != tt.err { 106 106 + t.Errorf("Match(%#q, %#q) = %v, %q want %v, %q", pattern, s, ok, errp(err), tt.match, errp(tt.err)) 107 107 + } 108 108 + } 109 109 + } 110 110 + 111 111 + // contains reports whether vector contains the string s. 112 112 + func contains(vector []string, s string) bool { 113 113 + for _, elem := range vector { 114 114 + if elem == s { 115 115 + return true 116 116 + } 117 117 + } 118 118 + return false 119 119 + } 120 120 + 121 121 + var globTests = []struct { 122 122 + pattern, result string 123 123 + }{ 124 124 + {"match.go", "match.go"}, 125 125 + {"mat?h.go", "match.go"}, 126 126 + {"*", "match.go"}, 127 127 + {"../*/match.go", "../filepath/match.go"}, 128 128 + } 129 129 + 130 130 + func TestGlob(t *testing.T) { 131 131 + for _, tt := range globTests { 132 132 + pattern := tt.pattern 133 133 + result := tt.result 134 134 + if runtime.GOOS == "windows" { 135 135 + pattern = Clean(pattern) 136 136 + result = Clean(result) 137 137 + } 138 138 + matches, err := Glob(pattern) 139 139 + if err != nil { 140 140 + t.Errorf("Glob error for %q: %s", pattern, err) 141 141 + continue 142 142 + } 143 143 + if !contains(matches, result) { 144 144 + t.Errorf("Glob(%#q) = %#v want %v", pattern, matches, result) 145 145 + } 146 146 + } 147 147 + for _, pattern := range []string{"no_match", "../*/no_match"} { 148 148 + matches, err := Glob(pattern) 149 149 + if err != nil { 150 150 + t.Errorf("Glob error for %q: %s", pattern, err) 151 151 + continue 152 152 + } 153 153 + if len(matches) != 0 { 154 154 + t.Errorf("Glob(%#q) = %#v want []", pattern, matches) 155 155 + } 156 156 + } 157 157 + } 158 158 + 159 159 + func TestGlobError(t *testing.T) { 160 160 + bad := []string{`[]`, `nonexist/[]`} 161 161 + for _, pattern := range bad { 162 162 + if _, err := Glob(pattern); err != ErrBadPattern { 163 163 + t.Errorf("Glob(%#q) returned err=%v, want ErrBadPattern", pattern, err) 164 164 + } 165 165 + } 166 166 + } 167 167 + 168 168 + func TestGlobUNC(t *testing.T) { 169 169 + // Just make sure this runs without crashing for now. 170 170 + // See issue 15879. 171 171 + Glob(`\\?\C:\*`) 172 172 + } 173 173 + 174 174 + var globSymlinkTests = []struct { 175 175 + path, dest string 176 176 + brokenLink bool 177 177 + }{ 178 178 + {"test1", "link1", false}, 179 179 + {"test2", "link2", true}, 180 180 + } 181 181 + 182 182 + func TestGlobSymlink(t *testing.T) { 183 183 + testenv.MustHaveSymlink(t) 184 184 + 185 185 + tmpDir, err := ioutil.TempDir("", "globsymlink") 186 186 + if err != nil { 187 187 + t.Fatal("creating temp dir:", err) 188 188 + } 189 189 + defer os.RemoveAll(tmpDir) 190 190 + 191 191 + for _, tt := range globSymlinkTests { 192 192 + path := Join(tmpDir, tt.path) 193 193 + dest := Join(tmpDir, tt.dest) 194 194 + f, err := os.Create(path) 195 195 + if err != nil { 196 196 + t.Fatal(err) 197 197 + } 198 198 + if err := f.Close(); err != nil { 199 199 + t.Fatal(err) 200 200 + } 201 201 + err = os.Symlink(path, dest) 202 202 + if err != nil { 203 203 + t.Fatal(err) 204 204 + } 205 205 + if tt.brokenLink { 206 206 + // Break the symlink. 207 207 + os.Remove(path) 208 208 + } 209 209 + matches, err := Glob(dest) 210 210 + if err != nil { 211 211 + t.Errorf("GlobSymlink error for %q: %s", dest, err) 212 212 + } 213 213 + if !contains(matches, dest) { 214 214 + t.Errorf("Glob(%#q) = %#v want %v", dest, matches, dest) 215 215 + } 216 216 + } 217 217 + } 218 218 + 219 219 + type globTest struct { 220 220 + pattern string 221 221 + matches []string 222 222 + } 223 223 + 224 224 + func (test *globTest) buildWant(root string) []string { 225 225 + want := make([]string, 0) 226 226 + for _, m := range test.matches { 227 227 + want = append(want, root+FromSlash(m)) 228 228 + } 229 229 + sort.Strings(want) 230 230 + return want 231 231 + } 232 232 + 233 233 + func (test *globTest) globAbs(root, rootPattern string) error { 234 234 + p := FromSlash(rootPattern + `\` + test.pattern) 235 235 + have, err := Glob(p) 236 236 + if err != nil { 237 237 + return err 238 238 + } 239 239 + sort.Strings(have) 240 240 + want := test.buildWant(root + `\`) 241 241 + if strings.Join(want, "_") == strings.Join(have, "_") { 242 242 + return nil 243 243 + } 244 244 + return fmt.Errorf("Glob(%q) returns %q, but %q expected", p, have, want) 245 245 + } 246 246 + 247 247 + func (test *globTest) globRel(root string) error { 248 248 + p := root + FromSlash(test.pattern) 249 249 + have, err := Glob(p) 250 250 + if err != nil { 251 251 + return err 252 252 + } 253 253 + sort.Strings(have) 254 254 + want := test.buildWant(root) 255 255 + if strings.Join(want, "_") == strings.Join(have, "_") { 256 256 + return nil 257 257 + } 258 258 + // try also matching version without root prefix 259 259 + wantWithNoRoot := test.buildWant("") 260 260 + if strings.Join(wantWithNoRoot, "_") == strings.Join(have, "_") { 261 261 + return nil 262 262 + } 263 263 + return fmt.Errorf("Glob(%q) returns %q, but %q expected", p, have, want) 264 264 + } 265 265 + 266 266 + func TestWindowsGlob(t *testing.T) { 267 267 + if runtime.GOOS != "windows" { 268 268 + t.Skipf("skipping windows specific test") 269 269 + } 270 270 + 271 271 + tmpDir, err := ioutil.TempDir("", "TestWindowsGlob") 272 272 + if err != nil { 273 273 + t.Fatal(err) 274 274 + } 275 275 + defer os.RemoveAll(tmpDir) 276 276 + 277 277 + // /tmp may itself be a symlink 278 278 + tmpDir, err = EvalSymlinks(tmpDir) 279 279 + if err != nil { 280 280 + t.Fatal("eval symlink for tmp dir:", err) 281 281 + } 282 282 + 283 283 + if len(tmpDir) < 3 { 284 284 + t.Fatalf("tmpDir path %q is too short", tmpDir) 285 285 + } 286 286 + if tmpDir[1] != ':' { 287 287 + t.Fatalf("tmpDir path %q must have drive letter in it", tmpDir) 288 288 + } 289 289 + 290 290 + dirs := []string{ 291 291 + "a", 292 292 + "b", 293 293 + "dir/d/bin", 294 294 + } 295 295 + files := []string{ 296 296 + "dir/d/bin/git.exe", 297 297 + } 298 298 + for _, dir := range dirs { 299 299 + err := os.MkdirAll(Join(tmpDir, dir), 0777) 300 300 + if err != nil { 301 301 + t.Fatal(err) 302 302 + } 303 303 + } 304 304 + for _, file := range files { 305 305 + err := ioutil.WriteFile(Join(tmpDir, file), nil, 0666) 306 306 + if err != nil { 307 307 + t.Fatal(err) 308 308 + } 309 309 + } 310 310 + 311 311 + tests := []globTest{ 312 312 + {"a", []string{"a"}}, 313 313 + {"b", []string{"b"}}, 314 314 + {"c", []string{}}, 315 315 + {"*", []string{"a", "b", "dir"}}, 316 316 + {"d*", []string{"dir"}}, 317 317 + {"*i*", []string{"dir"}}, 318 318 + {"*r", []string{"dir"}}, 319 319 + {"?ir", []string{"dir"}}, 320 320 + {"?r", []string{}}, 321 321 + {"d*/*/bin/git.exe", []string{"dir/d/bin/git.exe"}}, 322 322 + } 323 323 + 324 324 + // test absolute paths 325 325 + for _, test := range tests { 326 326 + var p string 327 327 + err = test.globAbs(tmpDir, tmpDir) 328 328 + if err != nil { 329 329 + t.Error(err) 330 330 + } 331 331 + // test C:\*Documents and Settings\... 332 332 + p = tmpDir 333 333 + p = strings.Replace(p, `:\`, `:\*`, 1) 334 334 + err = test.globAbs(tmpDir, p) 335 335 + if err != nil { 336 336 + t.Error(err) 337 337 + } 338 338 + // test C:\Documents and Settings*\... 339 339 + p = tmpDir 340 340 + p = strings.Replace(p, `:\`, `:`, 1) 341 341 + p = strings.Replace(p, `\`, `*\`, 1) 342 342 + p = strings.Replace(p, `:`, `:\`, 1) 343 343 + err = test.globAbs(tmpDir, p) 344 344 + if err != nil { 345 345 + t.Error(err) 346 346 + } 347 347 + } 348 348 + 349 349 + // test relative paths 350 350 + wd, err := os.Getwd() 351 351 + if err != nil { 352 352 + t.Fatal(err) 353 353 + } 354 354 + err = os.Chdir(tmpDir) 355 355 + if err != nil { 356 356 + t.Fatal(err) 357 357 + } 358 358 + defer func() { 359 359 + err := os.Chdir(wd) 360 360 + if err != nil { 361 361 + t.Fatal(err) 362 362 + } 363 363 + }() 364 364 + for _, test := range tests { 365 365 + err := test.globRel("") 366 366 + if err != nil { 367 367 + t.Error(err) 368 368 + } 369 369 + err = test.globRel(`.\`) 370 370 + if err != nil { 371 371 + t.Error(err) 372 372 + } 373 373 + err = test.globRel(tmpDir[:2]) // C: 374 374 + if err != nil { 375 375 + t.Error(err) 376 376 + } 377 377 + } 378 378 + } 379 379 + 380 380 + func TestNonWindowsGlobEscape(t *testing.T) { 381 381 + if runtime.GOOS == "windows" { 382 382 + t.Skipf("skipping non-windows specific test") 383 383 + } 384 384 + pattern := `\match.go` 385 385 + want := []string{"match.go"} 386 386 + matches, err := Glob(pattern) 387 387 + if err != nil { 388 388 + t.Fatalf("Glob error for %q: %s", pattern, err) 389 389 + } 390 390 + if !reflect.DeepEqual(matches, want) { 391 391 + t.Fatalf("Glob(%#q) = %v want %v", pattern, matches, want) 392 392 + } 393 393 + }

+596

pkg/path/testdata/path.go

reviewed

··· 1 1 + // Copyright 2009 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + // Package filepath implements utility routines for manipulating filename paths 6 6 + // in a way compatible with the target operating system-defined file paths. 7 7 + // 8 8 + // The filepath package uses either forward slashes or backslashes, 9 9 + // depending on the operating system. To process paths such as URLs 10 10 + // that always use forward slashes regardless of the operating 11 11 + // system, see the path package. 12 12 + package filepath 13 13 + 14 14 + import ( 15 15 + "errors" 16 16 + "io/fs" 17 17 + "os" 18 18 + "sort" 19 19 + "strings" 20 20 + ) 21 21 + 22 22 + // A lazybuf is a lazily constructed path buffer. 23 23 + // It supports append, reading previously appended bytes, 24 24 + // and retrieving the final string. It does not allocate a buffer 25 25 + // to hold the output until that output diverges from s. 26 26 + type lazybuf struct { 27 27 + path string 28 28 + buf []byte 29 29 + w int 30 30 + volAndPath string 31 31 + volLen int 32 32 + } 33 33 + 34 34 + func (b *lazybuf) index(i int) byte { 35 35 + if b.buf != nil { 36 36 + return b.buf[i] 37 37 + } 38 38 + return b.path[i] 39 39 + } 40 40 + 41 41 + func (b *lazybuf) append(c byte) { 42 42 + if b.buf == nil { 43 43 + if b.w < len(b.path) && b.path[b.w] == c { 44 44 + b.w++ 45 45 + return 46 46 + } 47 47 + b.buf = make([]byte, len(b.path)) 48 48 + copy(b.buf, b.path[:b.w]) 49 49 + } 50 50 + b.buf[b.w] = c 51 51 + b.w++ 52 52 + } 53 53 + 54 54 + func (b *lazybuf) string() string { 55 55 + if b.buf == nil { 56 56 + return b.volAndPath[:b.volLen+b.w] 57 57 + } 58 58 + return b.volAndPath[:b.volLen] + string(b.buf[:b.w]) 59 59 + } 60 60 + 61 61 + const ( 62 62 + Separator = os.PathSeparator 63 63 + ListSeparator = os.PathListSeparator 64 64 + ) 65 65 + 66 66 + // Clean returns the shortest path name equivalent to path 67 67 + // by purely lexical processing. It applies the following rules 68 68 + // iteratively until no further processing can be done: 69 69 + // 70 70 + // 1. Replace multiple Separator elements with a single one. 71 71 + // 2. Eliminate each . path name element (the current directory). 72 72 + // 3. Eliminate each inner .. path name element (the parent directory) 73 73 + // along with the non-.. element that precedes it. 74 74 + // 4. Eliminate .. elements that begin a rooted path: 75 75 + // that is, replace "/.." by "/" at the beginning of a path, 76 76 + // assuming Separator is '/'. 77 77 + // 78 78 + // The returned path ends in a slash only if it represents a root directory, 79 79 + // such as "/" on Unix or `C:\` on Windows. 80 80 + // 81 81 + // Finally, any occurrences of slash are replaced by Separator. 82 82 + // 83 83 + // If the result of this process is an empty string, Clean 84 84 + // returns the string ".". 85 85 + // 86 86 + // See also Rob Pike, ``Lexical File Names in Plan 9 or 87 87 + // Getting Dot-Dot Right,'' 88 88 + // https://9p.io/sys/doc/lexnames.html 89 89 + func Clean(path string) string { 90 90 + originalPath := path 91 91 + volLen := volumeNameLen(path) 92 92 + path = path[volLen:] 93 93 + if path == "" { 94 94 + if volLen > 1 && originalPath[1] != ':' { 95 95 + // should be UNC 96 96 + return FromSlash(originalPath) 97 97 + } 98 98 + return originalPath + "." 99 99 + } 100 100 + rooted := os.IsPathSeparator(path[0]) 101 101 + 102 102 + // Invariants: 103 103 + // reading from path; r is index of next byte to process. 104 104 + // writing to buf; w is index of next byte to write. 105 105 + // dotdot is index in buf where .. must stop, either because 106 106 + // it is the leading slash or it is a leading ../../.. prefix. 107 107 + n := len(path) 108 108 + out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen} 109 109 + r, dotdot := 0, 0 110 110 + if rooted { 111 111 + out.append(Separator) 112 112 + r, dotdot = 1, 1 113 113 + } 114 114 + 115 115 + for r < n { 116 116 + switch { 117 117 + case os.IsPathSeparator(path[r]): 118 118 + // empty path element 119 119 + r++ 120 120 + case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])): 121 121 + // . element 122 122 + r++ 123 123 + case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])): 124 124 + // .. element: remove to last separator 125 125 + r += 2 126 126 + switch { 127 127 + case out.w > dotdot: 128 128 + // can backtrack 129 129 + out.w-- 130 130 + for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) { 131 131 + out.w-- 132 132 + } 133 133 + case !rooted: 134 134 + // cannot backtrack, but not rooted, so append .. element. 135 135 + if out.w > 0 { 136 136 + out.append(Separator) 137 137 + } 138 138 + out.append('.') 139 139 + out.append('.') 140 140 + dotdot = out.w 141 141 + } 142 142 + default: 143 143 + // real path element. 144 144 + // add slash if needed 145 145 + if rooted && out.w != 1 || !rooted && out.w != 0 { 146 146 + out.append(Separator) 147 147 + } 148 148 + // copy element 149 149 + for ; r < n && !os.IsPathSeparator(path[r]); r++ { 150 150 + out.append(path[r]) 151 151 + } 152 152 + } 153 153 + } 154 154 + 155 155 + // Turn empty string into "." 156 156 + if out.w == 0 { 157 157 + out.append('.') 158 158 + } 159 159 + 160 160 + return FromSlash(out.string()) 161 161 + } 162 162 + 163 163 + // ToSlash returns the result of replacing each separator character 164 164 + // in path with a slash ('/') character. Multiple separators are 165 165 + // replaced by multiple slashes. 166 166 + func ToSlash(path string) string { 167 167 + if Separator == '/' { 168 168 + return path 169 169 + } 170 170 + return strings.ReplaceAll(path, string(Separator), "/") 171 171 + } 172 172 + 173 173 + // FromSlash returns the result of replacing each slash ('/') character 174 174 + // in path with a separator character. Multiple slashes are replaced 175 175 + // by multiple separators. 176 176 + func FromSlash(path string) string { 177 177 + if Separator == '/' { 178 178 + return path 179 179 + } 180 180 + return strings.ReplaceAll(path, "/", string(Separator)) 181 181 + } 182 182 + 183 183 + // SplitList splits a list of paths joined by the OS-specific ListSeparator, 184 184 + // usually found in PATH or GOPATH environment variables. 185 185 + // Unlike strings.Split, SplitList returns an empty slice when passed an empty 186 186 + // string. 187 187 + func SplitList(path string) []string { 188 188 + return splitList(path) 189 189 + } 190 190 + 191 191 + // Split splits path immediately following the final Separator, 192 192 + // separating it into a directory and file name component. 193 193 + // If there is no Separator in path, Split returns an empty dir 194 194 + // and file set to path. 195 195 + // The returned values have the property that path = dir+file. 196 196 + func Split(path string) (dir, file string) { 197 197 + vol := VolumeName(path) 198 198 + i := len(path) - 1 199 199 + for i >= len(vol) && !os.IsPathSeparator(path[i]) { 200 200 + i-- 201 201 + } 202 202 + return path[:i+1], path[i+1:] 203 203 + } 204 204 + 205 205 + // Join joins any number of path elements into a single path, 206 206 + // separating them with an OS specific Separator. Empty elements 207 207 + // are ignored. The result is Cleaned. However, if the argument 208 208 + // list is empty or all its elements are empty, Join returns 209 209 + // an empty string. 210 210 + // On Windows, the result will only be a UNC path if the first 211 211 + // non-empty element is a UNC path. 212 212 + func Join(elem ...string) string { 213 213 + return join(elem) 214 214 + } 215 215 + 216 216 + // Ext returns the file name extension used by path. 217 217 + // The extension is the suffix beginning at the final dot 218 218 + // in the final element of path; it is empty if there is 219 219 + // no dot. 220 220 + func Ext(path string) string { 221 221 + for i := len(path) - 1; i >= 0 && !os.IsPathSeparator(path[i]); i-- { 222 222 + if path[i] == '.' { 223 223 + return path[i:] 224 224 + } 225 225 + } 226 226 + return "" 227 227 + } 228 228 + 229 229 + // EvalSymlinks returns the path name after the evaluation of any symbolic 230 230 + // links. 231 231 + // If path is relative the result will be relative to the current directory, 232 232 + // unless one of the components is an absolute symbolic link. 233 233 + // EvalSymlinks calls Clean on the result. 234 234 + func EvalSymlinks(path string) (string, error) { 235 235 + return evalSymlinks(path) 236 236 + } 237 237 + 238 238 + // Abs returns an absolute representation of path. 239 239 + // If the path is not absolute it will be joined with the current 240 240 + // working directory to turn it into an absolute path. The absolute 241 241 + // path name for a given file is not guaranteed to be unique. 242 242 + // Abs calls Clean on the result. 243 243 + func Abs(path string) (string, error) { 244 244 + return abs(path) 245 245 + } 246 246 + 247 247 + func unixAbs(path string) (string, error) { 248 248 + if IsAbs(path) { 249 249 + return Clean(path), nil 250 250 + } 251 251 + wd, err := os.Getwd() 252 252 + if err != nil { 253 253 + return "", err 254 254 + } 255 255 + return Join(wd, path), nil 256 256 + } 257 257 + 258 258 + // Rel returns a relative path that is lexically equivalent to targpath when 259 259 + // joined to basepath with an intervening separator. That is, 260 260 + // Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself. 261 261 + // On success, the returned path will always be relative to basepath, 262 262 + // even if basepath and targpath share no elements. 263 263 + // An error is returned if targpath can't be made relative to basepath or if 264 264 + // knowing the current working directory would be necessary to compute it. 265 265 + // Rel calls Clean on the result. 266 266 + func Rel(basepath, targpath string) (string, error) { 267 267 + baseVol := VolumeName(basepath) 268 268 + targVol := VolumeName(targpath) 269 269 + base := Clean(basepath) 270 270 + targ := Clean(targpath) 271 271 + if sameWord(targ, base) { 272 272 + return ".", nil 273 273 + } 274 274 + base = base[len(baseVol):] 275 275 + targ = targ[len(targVol):] 276 276 + if base == "." { 277 277 + base = "" 278 278 + } 279 279 + // Can't use IsAbs - `\a` and `a` are both relative in Windows. 280 280 + baseSlashed := len(base) > 0 && base[0] == Separator 281 281 + targSlashed := len(targ) > 0 && targ[0] == Separator 282 282 + if baseSlashed != targSlashed || !sameWord(baseVol, targVol) { 283 283 + return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 284 284 + } 285 285 + // Position base[b0:bi] and targ[t0:ti] at the first differing elements. 286 286 + bl := len(base) 287 287 + tl := len(targ) 288 288 + var b0, bi, t0, ti int 289 289 + for { 290 290 + for bi < bl && base[bi] != Separator { 291 291 + bi++ 292 292 + } 293 293 + for ti < tl && targ[ti] != Separator { 294 294 + ti++ 295 295 + } 296 296 + if !sameWord(targ[t0:ti], base[b0:bi]) { 297 297 + break 298 298 + } 299 299 + if bi < bl { 300 300 + bi++ 301 301 + } 302 302 + if ti < tl { 303 303 + ti++ 304 304 + } 305 305 + b0 = bi 306 306 + t0 = ti 307 307 + } 308 308 + if base[b0:bi] == ".." { 309 309 + return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 310 310 + } 311 311 + if b0 != bl { 312 312 + // Base elements left. Must go up before going down. 313 313 + seps := strings.Count(base[b0:bl], string(Separator)) 314 314 + size := 2 + seps*3 315 315 + if tl != t0 { 316 316 + size += 1 + tl - t0 317 317 + } 318 318 + buf := make([]byte, size) 319 319 + n := copy(buf, "..") 320 320 + for i := 0; i < seps; i++ { 321 321 + buf[n] = Separator 322 322 + copy(buf[n+1:], "..") 323 323 + n += 3 324 324 + } 325 325 + if t0 != tl { 326 326 + buf[n] = Separator 327 327 + copy(buf[n+1:], targ[t0:]) 328 328 + } 329 329 + return string(buf), nil 330 330 + } 331 331 + return targ[t0:], nil 332 332 + } 333 333 + 334 334 + // SkipDir is used as a return value from WalkFuncs to indicate that 335 335 + // the directory named in the call is to be skipped. It is not returned 336 336 + // as an error by any function. 337 337 + var SkipDir error = fs.SkipDir 338 338 + 339 339 + // WalkFunc is the type of the function called by Walk to visit each each 340 340 + // file or directory. 341 341 + // 342 342 + // The path argument contains the argument to Walk as a prefix. 343 343 + // That is, if Walk is called with root argument "dir" and finds a file 344 344 + // named "a" in that directory, the walk function will be called with 345 345 + // argument "dir/a". 346 346 + // 347 347 + // The directory and file are joined with Join, which may clean the 348 348 + // directory name: if Walk is called with the root argument "x/../dir" 349 349 + // and finds a file named "a" in that directory, the walk function will 350 350 + // be called with argument "dir/a", not "x/../dir/a". 351 351 + // 352 352 + // The info argument is the fs.FileInfo for the named path. 353 353 + // 354 354 + // The error result returned by the function controls how Walk continues. 355 355 + // If the function returns the special value SkipDir, Walk skips the 356 356 + // current directory (path if info.IsDir() is true, otherwise path's 357 357 + // parent directory). Otherwise, if the function returns a non-nil error, 358 358 + // Walk stops entirely and returns that error. 359 359 + // 360 360 + // The err argument reports an error related to path, signaling that Walk 361 361 + // will not walk into that directory. The function can decide how to 362 362 + // handle that error; as described earlier, returning the error will 363 363 + // cause Walk to stop walking the entire tree. 364 364 + // 365 365 + // Walk calls the function with a non-nil err argument in two cases. 366 366 + // 367 367 + // First, if an os.Lstat on the root directory or any directory or file 368 368 + // in the tree fails, Walk calls the function with path set to that 369 369 + // directory or file's path, info set to nil, and err set to the error 370 370 + // from os.Lstat. 371 371 + // 372 372 + // Second, if a directory's Readdirnames method fails, Walk calls the 373 373 + // function with path set to the directory's path, info, set to an 374 374 + // fs.FileInfo describing the directory, and err set to the error from 375 375 + // Readdirnames. 376 376 + type WalkFunc func(path string, info fs.FileInfo, err error) error 377 377 + 378 378 + var lstat = os.Lstat // for testing 379 379 + 380 380 + // walkDir recursively descends path, calling walkDirFn. 381 381 + func walkDir(path string, d fs.DirEntry, walkDirFn fs.WalkDirFunc) error { 382 382 + if err := walkDirFn(path, d, nil); err != nil || !d.IsDir() { 383 383 + if err == SkipDir && d.IsDir() { 384 384 + // Successfully skipped directory. 385 385 + err = nil 386 386 + } 387 387 + return err 388 388 + } 389 389 + 390 390 + dirs, err := readDir(path) 391 391 + if err != nil { 392 392 + // Second call, to report ReadDir error. 393 393 + err = walkDirFn(path, d, err) 394 394 + if err != nil { 395 395 + return err 396 396 + } 397 397 + } 398 398 + 399 399 + for _, d1 := range dirs { 400 400 + path1 := Join(path, d1.Name()) 401 401 + if err := walkDir(path1, d1, walkDirFn); err != nil { 402 402 + if err == SkipDir { 403 403 + break 404 404 + } 405 405 + return err 406 406 + } 407 407 + } 408 408 + return nil 409 409 + } 410 410 + 411 411 + // walk recursively descends path, calling walkFn. 412 412 + func walk(path string, info fs.FileInfo, walkFn WalkFunc) error { 413 413 + if !info.IsDir() { 414 414 + return walkFn(path, info, nil) 415 415 + } 416 416 + 417 417 + names, err := readDirNames(path) 418 418 + err1 := walkFn(path, info, err) 419 419 + // If err != nil, walk can't walk into this directory. 420 420 + // err1 != nil means walkFn want walk to skip this directory or stop walking. 421 421 + // Therefore, if one of err and err1 isn't nil, walk will return. 422 422 + if err != nil || err1 != nil { 423 423 + // The caller's behavior is controlled by the return value, which is decided 424 424 + // by walkFn. walkFn may ignore err and return nil. 425 425 + // If walkFn returns SkipDir, it will be handled by the caller. 426 426 + // So walk should return whatever walkFn returns. 427 427 + return err1 428 428 + } 429 429 + 430 430 + for _, name := range names { 431 431 + filename := Join(path, name) 432 432 + fileInfo, err := lstat(filename) 433 433 + if err != nil { 434 434 + if err := walkFn(filename, fileInfo, err); err != nil && err != SkipDir { 435 435 + return err 436 436 + } 437 437 + } else { 438 438 + err = walk(filename, fileInfo, walkFn) 439 439 + if err != nil { 440 440 + if !fileInfo.IsDir() || err != SkipDir { 441 441 + return err 442 442 + } 443 443 + } 444 444 + } 445 445 + } 446 446 + return nil 447 447 + } 448 448 + 449 449 + // WalkDir walks the file tree rooted at root, calling fn for each file or 450 450 + // directory in the tree, including root. 451 451 + // 452 452 + // All errors that arise visiting files and directories are filtered by fn: 453 453 + // see the fs.WalkDirFunc documentation for details. 454 454 + // 455 455 + // The files are walked in lexical order, which makes the output deterministic 456 456 + // but requires WalkDir to read an entire directory into memory before proceeding 457 457 + // to walk that directory. 458 458 + // 459 459 + // WalkDir does not follow symbolic links. 460 460 + func WalkDir(root string, fn fs.WalkDirFunc) error { 461 461 + info, err := os.Lstat(root) 462 462 + if err != nil { 463 463 + err = fn(root, nil, err) 464 464 + } else { 465 465 + err = walkDir(root, &statDirEntry{info}, fn) 466 466 + } 467 467 + if err == SkipDir { 468 468 + return nil 469 469 + } 470 470 + return err 471 471 + } 472 472 + 473 473 + type statDirEntry struct { 474 474 + info fs.FileInfo 475 475 + } 476 476 + 477 477 + func (d *statDirEntry) Name() string { return d.info.Name() } 478 478 + func (d *statDirEntry) IsDir() bool { return d.info.IsDir() } 479 479 + func (d *statDirEntry) Type() fs.FileMode { return d.info.Mode().Type() } 480 480 + func (d *statDirEntry) Info() (fs.FileInfo, error) { return d.info, nil } 481 481 + 482 482 + // Walk walks the file tree rooted at root, calling fn for each file or 483 483 + // directory in the tree, including root. 484 484 + // 485 485 + // All errors that arise visiting files and directories are filtered by fn: 486 486 + // see the WalkFunc documentation for details. 487 487 + // 488 488 + // The files are walked in lexical order, which makes the output deterministic 489 489 + // but requires Walk to read an entire directory into memory before proceeding 490 490 + // to walk that directory. 491 491 + // 492 492 + // Walk does not follow symbolic links. 493 493 + // 494 494 + // Walk is less efficient than WalkDir, introduced in Go 1.16, 495 495 + // which avoids calling os.Lstat on every visited file or directory. 496 496 + func Walk(root string, fn WalkFunc) error { 497 497 + info, err := os.Lstat(root) 498 498 + if err != nil { 499 499 + err = fn(root, nil, err) 500 500 + } else { 501 501 + err = walk(root, info, fn) 502 502 + } 503 503 + if err == SkipDir { 504 504 + return nil 505 505 + } 506 506 + return err 507 507 + } 508 508 + 509 509 + // readDir reads the directory named by dirname and returns 510 510 + // a sorted list of directory entries. 511 511 + func readDir(dirname string) ([]fs.DirEntry, error) { 512 512 + f, err := os.Open(dirname) 513 513 + if err != nil { 514 514 + return nil, err 515 515 + } 516 516 + dirs, err := f.ReadDir(-1) 517 517 + f.Close() 518 518 + if err != nil { 519 519 + return nil, err 520 520 + } 521 521 + sort.Slice(dirs, func(i, j int) bool { return dirs[i].Name() < dirs[j].Name() }) 522 522 + return dirs, nil 523 523 + } 524 524 + 525 525 + // readDirNames reads the directory named by dirname and returns 526 526 + // a sorted list of directory entry names. 527 527 + func readDirNames(dirname string) ([]string, error) { 528 528 + f, err := os.Open(dirname) 529 529 + if err != nil { 530 530 + return nil, err 531 531 + } 532 532 + names, err := f.Readdirnames(-1) 533 533 + f.Close() 534 534 + if err != nil { 535 535 + return nil, err 536 536 + } 537 537 + sort.Strings(names) 538 538 + return names, nil 539 539 + } 540 540 + 541 541 + // Base returns the last element of path. 542 542 + // Trailing path separators are removed before extracting the last element. 543 543 + // If the path is empty, Base returns ".". 544 544 + // If the path consists entirely of separators, Base returns a single separator. 545 545 + func Base(path string) string { 546 546 + if path == "" { 547 547 + return "." 548 548 + } 549 549 + // Strip trailing slashes. 550 550 + for len(path) > 0 && os.IsPathSeparator(path[len(path)-1]) { 551 551 + path = path[0 : len(path)-1] 552 552 + } 553 553 + // Throw away volume name 554 554 + path = path[len(VolumeName(path)):] 555 555 + // Find the last element 556 556 + i := len(path) - 1 557 557 + for i >= 0 && !os.IsPathSeparator(path[i]) { 558 558 + i-- 559 559 + } 560 560 + if i >= 0 { 561 561 + path = path[i+1:] 562 562 + } 563 563 + // If empty now, it had only slashes. 564 564 + if path == "" { 565 565 + return string(Separator) 566 566 + } 567 567 + return path 568 568 + } 569 569 + 570 570 + // Dir returns all but the last element of path, typically the path's directory. 571 571 + // After dropping the final element, Dir calls Clean on the path and trailing 572 572 + // slashes are removed. 573 573 + // If the path is empty, Dir returns ".". 574 574 + // If the path consists entirely of separators, Dir returns a single separator. 575 575 + // The returned path does not end in a separator unless it is the root directory. 576 576 + func Dir(path string) string { 577 577 + vol := VolumeName(path) 578 578 + i := len(path) - 1 579 579 + for i >= len(vol) && !os.IsPathSeparator(path[i]) { 580 580 + i-- 581 581 + } 582 582 + dir := Clean(path[len(vol) : i+1]) 583 583 + if dir == "." && len(vol) > 2 { 584 584 + // must be UNC 585 585 + return vol 586 586 + } 587 587 + return vol + dir 588 588 + } 589 589 + 590 590 + // VolumeName returns leading volume name. 591 591 + // Given "C:\foo\bar" it returns "C:" on Windows. 592 592 + // Given "\\host\share\foo" it returns "\\host\share". 593 593 + // On other platforms it returns "". 594 594 + func VolumeName(path string) string { 595 595 + return path[:volumeNameLen(path)] 596 596 + }

+51

pkg/path/testdata/path_plan9.go

reviewed

··· 1 1 + // Copyright 2010 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + import "strings" 8 8 + 9 9 + // IsAbs reports whether the path is absolute. 10 10 + func IsAbs(path string) bool { 11 11 + return strings.HasPrefix(path, "/") || strings.HasPrefix(path, "#") 12 12 + } 13 13 + 14 14 + // volumeNameLen returns length of the leading volume name on Windows. 15 15 + // It returns 0 elsewhere. 16 16 + func volumeNameLen(path string) int { 17 17 + return 0 18 18 + } 19 19 + 20 20 + // HasPrefix exists for historical compatibility and should not be used. 21 21 + // 22 22 + // Deprecated: HasPrefix does not respect path boundaries and 23 23 + // does not ignore case when required. 24 24 + func HasPrefix(p, prefix string) bool { 25 25 + return strings.HasPrefix(p, prefix) 26 26 + } 27 27 + 28 28 + func splitList(path string) []string { 29 29 + if path == "" { 30 30 + return []string{} 31 31 + } 32 32 + return strings.Split(path, string(ListSeparator)) 33 33 + } 34 34 + 35 35 + func abs(path string) (string, error) { 36 36 + return unixAbs(path) 37 37 + } 38 38 + 39 39 + func join(elem []string) string { 40 40 + // If there's a bug here, fix the logic in ./path_unix.go too. 41 41 + for i, e := range elem { 42 42 + if e != "" { 43 43 + return Clean(strings.Join(elem[i:], string(Separator))) 44 44 + } 45 45 + } 46 46 + return "" 47 47 + } 48 48 + 49 49 + func sameWord(a, b string) bool { 50 50 + return a == b 51 51 + }

+1538

pkg/path/testdata/path_test.go

reviewed

··· 1 1 + // Copyright 2009 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath_test 6 6 + 7 7 + import ( 8 8 + "errors" 9 9 + "fmt" 10 10 + "internal/testenv" 11 11 + "io/fs" 12 12 + "io/ioutil" 13 13 + "os" 14 14 + "path/filepath" 15 15 + "reflect" 16 16 + "runtime" 17 17 + "sort" 18 18 + "strings" 19 19 + "syscall" 20 20 + "testing" 21 21 + ) 22 22 + 23 23 + type PathTest struct { 24 24 + path, result string 25 25 + } 26 26 + 27 27 + var cleantests = []PathTest{ 28 28 + // Already clean 29 29 + {"abc", "abc"}, 30 30 + {"abc/def", "abc/def"}, 31 31 + {"a/b/c", "a/b/c"}, 32 32 + {".", "."}, 33 33 + {"..", ".."}, 34 34 + {"../..", "../.."}, 35 35 + {"../../abc", "../../abc"}, 36 36 + {"/abc", "/abc"}, 37 37 + {"/", "/"}, 38 38 + 39 39 + // Empty is current dir 40 40 + {"", "."}, 41 41 + 42 42 + // Remove trailing slash 43 43 + {"abc/", "abc"}, 44 44 + {"abc/def/", "abc/def"}, 45 45 + {"a/b/c/", "a/b/c"}, 46 46 + {"./", "."}, 47 47 + {"../", ".."}, 48 48 + {"../../", "../.."}, 49 49 + {"/abc/", "/abc"}, 50 50 + 51 51 + // Remove doubled slash 52 52 + {"abc//def//ghi", "abc/def/ghi"}, 53 53 + {"//abc", "/abc"}, 54 54 + {"///abc", "/abc"}, 55 55 + {"//abc//", "/abc"}, 56 56 + {"abc//", "abc"}, 57 57 + 58 58 + // Remove . elements 59 59 + {"abc/./def", "abc/def"}, 60 60 + {"/./abc/def", "/abc/def"}, 61 61 + {"abc/.", "abc"}, 62 62 + 63 63 + // Remove .. elements 64 64 + {"abc/def/ghi/../jkl", "abc/def/jkl"}, 65 65 + {"abc/def/../ghi/../jkl", "abc/jkl"}, 66 66 + {"abc/def/..", "abc"}, 67 67 + {"abc/def/../..", "."}, 68 68 + {"/abc/def/../..", "/"}, 69 69 + {"abc/def/../../..", ".."}, 70 70 + {"/abc/def/../../..", "/"}, 71 71 + {"abc/def/../../../ghi/jkl/../../../mno", "../../mno"}, 72 72 + {"/../abc", "/abc"}, 73 73 + 74 74 + // Combinations 75 75 + {"abc/./../def", "def"}, 76 76 + {"abc//./../def", "def"}, 77 77 + {"abc/../../././../def", "../../def"}, 78 78 + } 79 79 + 80 80 + var wincleantests = []PathTest{ 81 81 + {`c:`, `c:.`}, 82 82 + {`c:\`, `c:\`}, 83 83 + {`c:\abc`, `c:\abc`}, 84 84 + {`c:abc\..\..\.\.\..\def`, `c:..\..\def`}, 85 85 + {`c:\abc\def\..\..`, `c:\`}, 86 86 + {`c:\..\abc`, `c:\abc`}, 87 87 + {`c:..\abc`, `c:..\abc`}, 88 88 + {`\`, `\`}, 89 89 + {`/`, `\`}, 90 90 + {`\\i\..\c$`, `\c$`}, 91 91 + {`\\i\..\i\c$`, `\i\c$`}, 92 92 + {`\\i\..\I\c$`, `\I\c$`}, 93 93 + {`\\host\share\foo\..\bar`, `\\host\share\bar`}, 94 94 + {`//host/share/foo/../baz`, `\\host\share\baz`}, 95 95 + {`\\a\b\..\c`, `\\a\b\c`}, 96 96 + {`\\a\b`, `\\a\b`}, 97 97 + } 98 98 + 99 99 + func TestClean(t *testing.T) { 100 100 + tests := cleantests 101 101 + if runtime.GOOS == "windows" { 102 102 + for i := range tests { 103 103 + tests[i].result = filepath.FromSlash(tests[i].result) 104 104 + } 105 105 + tests = append(tests, wincleantests...) 106 106 + } 107 107 + for _, test := range tests { 108 108 + if s := filepath.Clean(test.path); s != test.result { 109 109 + t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result) 110 110 + } 111 111 + if s := filepath.Clean(test.result); s != test.result { 112 112 + t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result) 113 113 + } 114 114 + } 115 115 + 116 116 + if testing.Short() { 117 117 + t.Skip("skipping malloc count in short mode") 118 118 + } 119 119 + if runtime.GOMAXPROCS(0) > 1 { 120 120 + t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1") 121 121 + return 122 122 + } 123 123 + 124 124 + for _, test := range tests { 125 125 + allocs := testing.AllocsPerRun(100, func() { filepath.Clean(test.result) }) 126 126 + if allocs > 0 { 127 127 + t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs) 128 128 + } 129 129 + } 130 130 + } 131 131 + 132 132 + const sep = filepath.Separator 133 133 + 134 134 + var slashtests = []PathTest{ 135 135 + {"", ""}, 136 136 + {"/", string(sep)}, 137 137 + {"/a/b", string([]byte{sep, 'a', sep, 'b'})}, 138 138 + {"a//b", string([]byte{'a', sep, sep, 'b'})}, 139 139 + } 140 140 + 141 141 + func TestFromAndToSlash(t *testing.T) { 142 142 + for _, test := range slashtests { 143 143 + if s := filepath.FromSlash(test.path); s != test.result { 144 144 + t.Errorf("FromSlash(%q) = %q, want %q", test.path, s, test.result) 145 145 + } 146 146 + if s := filepath.ToSlash(test.result); s != test.path { 147 147 + t.Errorf("ToSlash(%q) = %q, want %q", test.result, s, test.path) 148 148 + } 149 149 + } 150 150 + } 151 151 + 152 152 + type SplitListTest struct { 153 153 + list string 154 154 + result []string 155 155 + } 156 156 + 157 157 + const lsep = filepath.ListSeparator 158 158 + 159 159 + var splitlisttests = []SplitListTest{ 160 160 + {"", []string{}}, 161 161 + {string([]byte{'a', lsep, 'b'}), []string{"a", "b"}}, 162 162 + {string([]byte{lsep, 'a', lsep, 'b'}), []string{"", "a", "b"}}, 163 163 + } 164 164 + 165 165 + var winsplitlisttests = []SplitListTest{ 166 166 + // quoted 167 167 + {`"a"`, []string{`a`}}, 168 168 + 169 169 + // semicolon 170 170 + {`";"`, []string{`;`}}, 171 171 + {`"a;b"`, []string{`a;b`}}, 172 172 + {`";";`, []string{`;`, ``}}, 173 173 + {`;";"`, []string{``, `;`}}, 174 174 + 175 175 + // partially quoted 176 176 + {`a";"b`, []string{`a;b`}}, 177 177 + {`a; ""b`, []string{`a`, ` b`}}, 178 178 + {`"a;b`, []string{`a;b`}}, 179 179 + {`""a;b`, []string{`a`, `b`}}, 180 180 + {`"""a;b`, []string{`a;b`}}, 181 181 + {`""""a;b`, []string{`a`, `b`}}, 182 182 + {`a";b`, []string{`a;b`}}, 183 183 + {`a;b";c`, []string{`a`, `b;c`}}, 184 184 + {`"a";b";c`, []string{`a`, `b;c`}}, 185 185 + } 186 186 + 187 187 + func TestSplitList(t *testing.T) { 188 188 + tests := splitlisttests 189 189 + if runtime.GOOS == "windows" { 190 190 + tests = append(tests, winsplitlisttests...) 191 191 + } 192 192 + for _, test := range tests { 193 193 + if l := filepath.SplitList(test.list); !reflect.DeepEqual(l, test.result) { 194 194 + t.Errorf("SplitList(%#q) = %#q, want %#q", test.list, l, test.result) 195 195 + } 196 196 + } 197 197 + } 198 198 + 199 199 + type SplitTest struct { 200 200 + path, dir, file string 201 201 + } 202 202 + 203 203 + var unixsplittests = []SplitTest{ 204 204 + {"a/b", "a/", "b"}, 205 205 + {"a/b/", "a/b/", ""}, 206 206 + {"a/", "a/", ""}, 207 207 + {"a", "", "a"}, 208 208 + {"/", "/", ""}, 209 209 + } 210 210 + 211 211 + var winsplittests = []SplitTest{ 212 212 + {`c:`, `c:`, ``}, 213 213 + {`c:/`, `c:/`, ``}, 214 214 + {`c:/foo`, `c:/`, `foo`}, 215 215 + {`c:/foo/bar`, `c:/foo/`, `bar`}, 216 216 + {`//host/share`, `//host/share`, ``}, 217 217 + {`//host/share/`, `//host/share/`, ``}, 218 218 + {`//host/share/foo`, `//host/share/`, `foo`}, 219 219 + {`\\host\share`, `\\host\share`, ``}, 220 220 + {`\\host\share\`, `\\host\share\`, ``}, 221 221 + {`\\host\share\foo`, `\\host\share\`, `foo`}, 222 222 + } 223 223 + 224 224 + func TestSplit(t *testing.T) { 225 225 + var splittests []SplitTest 226 226 + splittests = unixsplittests 227 227 + if runtime.GOOS == "windows" { 228 228 + splittests = append(splittests, winsplittests...) 229 229 + } 230 230 + for _, test := range splittests { 231 231 + if d, f := filepath.Split(test.path); d != test.dir || f != test.file { 232 232 + t.Errorf("Split(%q) = %q, %q, want %q, %q", test.path, d, f, test.dir, test.file) 233 233 + } 234 234 + } 235 235 + } 236 236 + 237 237 + type JoinTest struct { 238 238 + elem []string 239 239 + path string 240 240 + } 241 241 + 242 242 + var jointests = []JoinTest{ 243 243 + // zero parameters 244 244 + {[]string{}, ""}, 245 245 + 246 246 + // one parameter 247 247 + {[]string{""}, ""}, 248 248 + {[]string{"/"}, "/"}, 249 249 + {[]string{"a"}, "a"}, 250 250 + 251 251 + // two parameters 252 252 + {[]string{"a", "b"}, "a/b"}, 253 253 + {[]string{"a", ""}, "a"}, 254 254 + {[]string{"", "b"}, "b"}, 255 255 + {[]string{"/", "a"}, "/a"}, 256 256 + {[]string{"/", "a/b"}, "/a/b"}, 257 257 + {[]string{"/", ""}, "/"}, 258 258 + {[]string{"//", "a"}, "/a"}, 259 259 + {[]string{"/a", "b"}, "/a/b"}, 260 260 + {[]string{"a/", "b"}, "a/b"}, 261 261 + {[]string{"a/", ""}, "a"}, 262 262 + {[]string{"", ""}, ""}, 263 263 + 264 264 + // three parameters 265 265 + {[]string{"/", "a", "b"}, "/a/b"}, 266 266 + } 267 267 + 268 268 + var winjointests = []JoinTest{ 269 269 + {[]string{`directory`, `file`}, `directory\file`}, 270 270 + {[]string{`C:\Windows\`, `System32`}, `C:\Windows\System32`}, 271 271 + {[]string{`C:\Windows\`, ``}, `C:\Windows`}, 272 272 + {[]string{`C:\`, `Windows`}, `C:\Windows`}, 273 273 + {[]string{`C:`, `a`}, `C:a`}, 274 274 + {[]string{`C:`, `a\b`}, `C:a\b`}, 275 275 + {[]string{`C:`, `a`, `b`}, `C:a\b`}, 276 276 + {[]string{`C:`, ``, `b`}, `C:b`}, 277 277 + {[]string{`C:`, ``, ``, `b`}, `C:b`}, 278 278 + {[]string{`C:`, ``}, `C:.`}, 279 279 + {[]string{`C:`, ``, ``}, `C:.`}, 280 280 + {[]string{`C:.`, `a`}, `C:a`}, 281 281 + {[]string{`C:a`, `b`}, `C:a\b`}, 282 282 + {[]string{`C:a`, `b`, `d`}, `C:a\b\d`}, 283 283 + {[]string{`\\host\share`, `foo`}, `\\host\share\foo`}, 284 284 + {[]string{`\\host\share\foo`}, `\\host\share\foo`}, 285 285 + {[]string{`//host/share`, `foo/bar`}, `\\host\share\foo\bar`}, 286 286 + {[]string{`\`}, `\`}, 287 287 + {[]string{`\`, ``}, `\`}, 288 288 + {[]string{`\`, `a`}, `\a`}, 289 289 + {[]string{`\\`, `a`}, `\a`}, 290 290 + {[]string{`\`, `a`, `b`}, `\a\b`}, 291 291 + {[]string{`\\`, `a`, `b`}, `\a\b`}, 292 292 + {[]string{`\`, `\\a\b`, `c`}, `\a\b\c`}, 293 293 + {[]string{`\\a`, `b`, `c`}, `\a\b\c`}, 294 294 + {[]string{`\\a\`, `b`, `c`}, `\a\b\c`}, 295 295 + } 296 296 + 297 297 + func TestJoin(t *testing.T) { 298 298 + if runtime.GOOS == "windows" { 299 299 + jointests = append(jointests, winjointests...) 300 300 + } 301 301 + for _, test := range jointests { 302 302 + expected := filepath.FromSlash(test.path) 303 303 + if p := filepath.Join(test.elem...); p != expected { 304 304 + t.Errorf("join(%q) = %q, want %q", test.elem, p, expected) 305 305 + } 306 306 + } 307 307 + } 308 308 + 309 309 + type ExtTest struct { 310 310 + path, ext string 311 311 + } 312 312 + 313 313 + var exttests = []ExtTest{ 314 314 + {"path.go", ".go"}, 315 315 + {"path.pb.go", ".go"}, 316 316 + {"a.dir/b", ""}, 317 317 + {"a.dir/b.go", ".go"}, 318 318 + {"a.dir/", ""}, 319 319 + } 320 320 + 321 321 + func TestExt(t *testing.T) { 322 322 + for _, test := range exttests { 323 323 + if x := filepath.Ext(test.path); x != test.ext { 324 324 + t.Errorf("Ext(%q) = %q, want %q", test.path, x, test.ext) 325 325 + } 326 326 + } 327 327 + } 328 328 + 329 329 + type Node struct { 330 330 + name string 331 331 + entries []*Node // nil if the entry is a file 332 332 + mark int 333 333 + } 334 334 + 335 335 + var tree = &Node{ 336 336 + "testdata", 337 337 + []*Node{ 338 338 + {"a", nil, 0}, 339 339 + {"b", []*Node{}, 0}, 340 340 + {"c", nil, 0}, 341 341 + { 342 342 + "d", 343 343 + []*Node{ 344 344 + {"x", nil, 0}, 345 345 + {"y", []*Node{}, 0}, 346 346 + { 347 347 + "z", 348 348 + []*Node{ 349 349 + {"u", nil, 0}, 350 350 + {"v", nil, 0}, 351 351 + }, 352 352 + 0, 353 353 + }, 354 354 + }, 355 355 + 0, 356 356 + }, 357 357 + }, 358 358 + 0, 359 359 + } 360 360 + 361 361 + func walkTree(n *Node, path string, f func(path string, n *Node)) { 362 362 + f(path, n) 363 363 + for _, e := range n.entries { 364 364 + walkTree(e, filepath.Join(path, e.name), f) 365 365 + } 366 366 + } 367 367 + 368 368 + func makeTree(t *testing.T) { 369 369 + walkTree(tree, tree.name, func(path string, n *Node) { 370 370 + if n.entries == nil { 371 371 + fd, err := os.Create(path) 372 372 + if err != nil { 373 373 + t.Errorf("makeTree: %v", err) 374 374 + return 375 375 + } 376 376 + fd.Close() 377 377 + } else { 378 378 + os.Mkdir(path, 0770) 379 379 + } 380 380 + }) 381 381 + } 382 382 + 383 383 + func markTree(n *Node) { walkTree(n, "", func(path string, n *Node) { n.mark++ }) } 384 384 + 385 385 + func checkMarks(t *testing.T, report bool) { 386 386 + walkTree(tree, tree.name, func(path string, n *Node) { 387 387 + if n.mark != 1 && report { 388 388 + t.Errorf("node %s mark = %d; expected 1", path, n.mark) 389 389 + } 390 390 + n.mark = 0 391 391 + }) 392 392 + } 393 393 + 394 394 + // Assumes that each node name is unique. Good enough for a test. 395 395 + // If clear is true, any incoming error is cleared before return. The errors 396 396 + // are always accumulated, though. 397 397 + func mark(d fs.DirEntry, err error, errors *[]error, clear bool) error { 398 398 + name := d.Name() 399 399 + walkTree(tree, tree.name, func(path string, n *Node) { 400 400 + if n.name == name { 401 401 + n.mark++ 402 402 + } 403 403 + }) 404 404 + if err != nil { 405 405 + *errors = append(*errors, err) 406 406 + if clear { 407 407 + return nil 408 408 + } 409 409 + return err 410 410 + } 411 411 + return nil 412 412 + } 413 413 + 414 414 + func chtmpdir(t *testing.T) (restore func()) { 415 415 + oldwd, err := os.Getwd() 416 416 + if err != nil { 417 417 + t.Fatalf("chtmpdir: %v", err) 418 418 + } 419 419 + d, err := ioutil.TempDir("", "test") 420 420 + if err != nil { 421 421 + t.Fatalf("chtmpdir: %v", err) 422 422 + } 423 423 + if err := os.Chdir(d); err != nil { 424 424 + t.Fatalf("chtmpdir: %v", err) 425 425 + } 426 426 + return func() { 427 427 + if err := os.Chdir(oldwd); err != nil { 428 428 + t.Fatalf("chtmpdir: %v", err) 429 429 + } 430 430 + os.RemoveAll(d) 431 431 + } 432 432 + } 433 433 + 434 434 + func TestWalk(t *testing.T) { 435 435 + walk := func(root string, fn fs.WalkDirFunc) error { 436 436 + return filepath.Walk(root, func(path string, info fs.FileInfo, err error) error { 437 437 + return fn(path, &statDirEntry{info}, err) 438 438 + }) 439 439 + } 440 440 + testWalk(t, walk, 1) 441 441 + } 442 442 + 443 443 + type statDirEntry struct { 444 444 + info fs.FileInfo 445 445 + } 446 446 + 447 447 + func (d *statDirEntry) Name() string { return d.info.Name() } 448 448 + func (d *statDirEntry) IsDir() bool { return d.info.IsDir() } 449 449 + func (d *statDirEntry) Type() fs.FileMode { return d.info.Mode().Type() } 450 450 + func (d *statDirEntry) Info() (fs.FileInfo, error) { return d.info, nil } 451 451 + 452 452 + func TestWalkDir(t *testing.T) { 453 453 + testWalk(t, filepath.WalkDir, 2) 454 454 + } 455 455 + 456 456 + func testWalk(t *testing.T, walk func(string, fs.WalkDirFunc) error, errVisit int) { 457 457 + if runtime.GOOS == "ios" { 458 458 + restore := chtmpdir(t) 459 459 + defer restore() 460 460 + } 461 461 + 462 462 + tmpDir, err := ioutil.TempDir("", "TestWalk") 463 463 + if err != nil { 464 464 + t.Fatal("creating temp dir:", err) 465 465 + } 466 466 + defer os.RemoveAll(tmpDir) 467 467 + 468 468 + origDir, err := os.Getwd() 469 469 + if err != nil { 470 470 + t.Fatal("finding working dir:", err) 471 471 + } 472 472 + if err = os.Chdir(tmpDir); err != nil { 473 473 + t.Fatal("entering temp dir:", err) 474 474 + } 475 475 + defer os.Chdir(origDir) 476 476 + 477 477 + makeTree(t) 478 478 + errors := make([]error, 0, 10) 479 479 + clear := true 480 480 + markFn := func(path string, d fs.DirEntry, err error) error { 481 481 + return mark(d, err, &errors, clear) 482 482 + } 483 483 + // Expect no errors. 484 484 + err = walk(tree.name, markFn) 485 485 + if err != nil { 486 486 + t.Fatalf("no error expected, found: %s", err) 487 487 + } 488 488 + if len(errors) != 0 { 489 489 + t.Fatalf("unexpected errors: %s", errors) 490 490 + } 491 491 + checkMarks(t, true) 492 492 + errors = errors[0:0] 493 493 + 494 494 + t.Run("PermErr", func(t *testing.T) { 495 495 + // Test permission errors. Only possible if we're not root 496 496 + // and only on some file systems (AFS, FAT). To avoid errors during 497 497 + // all.bash on those file systems, skip during go test -short. 498 498 + if runtime.GOOS == "windows" { 499 499 + t.Skip("skipping on Windows") 500 500 + } 501 501 + if os.Getuid() == 0 { 502 502 + t.Skip("skipping as root") 503 503 + } 504 504 + if testing.Short() { 505 505 + t.Skip("skipping in short mode") 506 506 + } 507 507 + 508 508 + // introduce 2 errors: chmod top-level directories to 0 509 509 + os.Chmod(filepath.Join(tree.name, tree.entries[1].name), 0) 510 510 + os.Chmod(filepath.Join(tree.name, tree.entries[3].name), 0) 511 511 + 512 512 + // 3) capture errors, expect two. 513 513 + // mark respective subtrees manually 514 514 + markTree(tree.entries[1]) 515 515 + markTree(tree.entries[3]) 516 516 + // correct double-marking of directory itself 517 517 + tree.entries[1].mark -= errVisit 518 518 + tree.entries[3].mark -= errVisit 519 519 + err := walk(tree.name, markFn) 520 520 + if err != nil { 521 521 + t.Fatalf("expected no error return from Walk, got %s", err) 522 522 + } 523 523 + if len(errors) != 2 { 524 524 + t.Errorf("expected 2 errors, got %d: %s", len(errors), errors) 525 525 + } 526 526 + // the inaccessible subtrees were marked manually 527 527 + checkMarks(t, true) 528 528 + errors = errors[0:0] 529 529 + 530 530 + // 4) capture errors, stop after first error. 531 531 + // mark respective subtrees manually 532 532 + markTree(tree.entries[1]) 533 533 + markTree(tree.entries[3]) 534 534 + // correct double-marking of directory itself 535 535 + tree.entries[1].mark -= errVisit 536 536 + tree.entries[3].mark -= errVisit 537 537 + clear = false // error will stop processing 538 538 + err = walk(tree.name, markFn) 539 539 + if err == nil { 540 540 + t.Fatalf("expected error return from Walk") 541 541 + } 542 542 + if len(errors) != 1 { 543 543 + t.Errorf("expected 1 error, got %d: %s", len(errors), errors) 544 544 + } 545 545 + // the inaccessible subtrees were marked manually 546 546 + checkMarks(t, false) 547 547 + errors = errors[0:0] 548 548 + 549 549 + // restore permissions 550 550 + os.Chmod(filepath.Join(tree.name, tree.entries[1].name), 0770) 551 551 + os.Chmod(filepath.Join(tree.name, tree.entries[3].name), 0770) 552 552 + }) 553 553 + } 554 554 + 555 555 + func touch(t *testing.T, name string) { 556 556 + f, err := os.Create(name) 557 557 + if err != nil { 558 558 + t.Fatal(err) 559 559 + } 560 560 + if err := f.Close(); err != nil { 561 561 + t.Fatal(err) 562 562 + } 563 563 + } 564 564 + 565 565 + func TestWalkSkipDirOnFile(t *testing.T) { 566 566 + td, err := ioutil.TempDir("", "walktest") 567 567 + if err != nil { 568 568 + t.Fatal(err) 569 569 + } 570 570 + defer os.RemoveAll(td) 571 571 + 572 572 + if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil { 573 573 + t.Fatal(err) 574 574 + } 575 575 + touch(t, filepath.Join(td, "dir/foo1")) 576 576 + touch(t, filepath.Join(td, "dir/foo2")) 577 577 + 578 578 + sawFoo2 := false 579 579 + walker := func(path string) error { 580 580 + if strings.HasSuffix(path, "foo2") { 581 581 + sawFoo2 = true 582 582 + } 583 583 + if strings.HasSuffix(path, "foo1") { 584 584 + return filepath.SkipDir 585 585 + } 586 586 + return nil 587 587 + } 588 588 + walkFn := func(path string, _ fs.FileInfo, _ error) error { return walker(path) } 589 589 + walkDirFn := func(path string, _ fs.DirEntry, _ error) error { return walker(path) } 590 590 + 591 591 + check := func(t *testing.T, walk func(root string) error, root string) { 592 592 + t.Helper() 593 593 + sawFoo2 = false 594 594 + err = walk(root) 595 595 + if err != nil { 596 596 + t.Fatal(err) 597 597 + } 598 598 + if sawFoo2 { 599 599 + t.Errorf("SkipDir on file foo1 did not block processing of foo2") 600 600 + } 601 601 + } 602 602 + 603 603 + t.Run("Walk", func(t *testing.T) { 604 604 + Walk := func(root string) error { return filepath.Walk(td, walkFn) } 605 605 + check(t, Walk, td) 606 606 + check(t, Walk, filepath.Join(td, "dir")) 607 607 + }) 608 608 + t.Run("WalkDir", func(t *testing.T) { 609 609 + WalkDir := func(root string) error { return filepath.WalkDir(td, walkDirFn) } 610 610 + check(t, WalkDir, td) 611 611 + check(t, WalkDir, filepath.Join(td, "dir")) 612 612 + }) 613 613 + } 614 614 + 615 615 + func TestWalkFileError(t *testing.T) { 616 616 + td, err := ioutil.TempDir("", "walktest") 617 617 + if err != nil { 618 618 + t.Fatal(err) 619 619 + } 620 620 + defer os.RemoveAll(td) 621 621 + 622 622 + touch(t, filepath.Join(td, "foo")) 623 623 + touch(t, filepath.Join(td, "bar")) 624 624 + dir := filepath.Join(td, "dir") 625 625 + if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil { 626 626 + t.Fatal(err) 627 627 + } 628 628 + touch(t, filepath.Join(dir, "baz")) 629 629 + touch(t, filepath.Join(dir, "stat-error")) 630 630 + defer func() { 631 631 + *filepath.LstatP = os.Lstat 632 632 + }() 633 633 + statErr := errors.New("some stat error") 634 634 + *filepath.LstatP = func(path string) (fs.FileInfo, error) { 635 635 + if strings.HasSuffix(path, "stat-error") { 636 636 + return nil, statErr 637 637 + } 638 638 + return os.Lstat(path) 639 639 + } 640 640 + got := map[string]error{} 641 641 + err = filepath.Walk(td, func(path string, fi fs.FileInfo, err error) error { 642 642 + rel, _ := filepath.Rel(td, path) 643 643 + got[filepath.ToSlash(rel)] = err 644 644 + return nil 645 645 + }) 646 646 + if err != nil { 647 647 + t.Errorf("Walk error: %v", err) 648 648 + } 649 649 + want := map[string]error{ 650 650 + ".": nil, 651 651 + "foo": nil, 652 652 + "bar": nil, 653 653 + "dir": nil, 654 654 + "dir/baz": nil, 655 655 + "dir/stat-error": statErr, 656 656 + } 657 657 + if !reflect.DeepEqual(got, want) { 658 658 + t.Errorf("Walked %#v; want %#v", got, want) 659 659 + } 660 660 + } 661 661 + 662 662 + var basetests = []PathTest{ 663 663 + {"", "."}, 664 664 + {".", "."}, 665 665 + {"/.", "."}, 666 666 + {"/", "/"}, 667 667 + {"////", "/"}, 668 668 + {"x/", "x"}, 669 669 + {"abc", "abc"}, 670 670 + {"abc/def", "def"}, 671 671 + {"a/b/.x", ".x"}, 672 672 + {"a/b/c.", "c."}, 673 673 + {"a/b/c.x", "c.x"}, 674 674 + } 675 675 + 676 676 + var winbasetests = []PathTest{ 677 677 + {`c:\`, `\`}, 678 678 + {`c:.`, `.`}, 679 679 + {`c:\a\b`, `b`}, 680 680 + {`c:a\b`, `b`}, 681 681 + {`c:a\b\c`, `c`}, 682 682 + {`\\host\share\`, `\`}, 683 683 + {`\\host\share\a`, `a`}, 684 684 + {`\\host\share\a\b`, `b`}, 685 685 + } 686 686 + 687 687 + func TestBase(t *testing.T) { 688 688 + tests := basetests 689 689 + if runtime.GOOS == "windows" { 690 690 + // make unix tests work on windows 691 691 + for i := range tests { 692 692 + tests[i].result = filepath.Clean(tests[i].result) 693 693 + } 694 694 + // add windows specific tests 695 695 + tests = append(tests, winbasetests...) 696 696 + } 697 697 + for _, test := range tests { 698 698 + if s := filepath.Base(test.path); s != test.result { 699 699 + t.Errorf("Base(%q) = %q, want %q", test.path, s, test.result) 700 700 + } 701 701 + } 702 702 + } 703 703 + 704 704 + var dirtests = []PathTest{ 705 705 + {"", "."}, 706 706 + {".", "."}, 707 707 + {"/.", "/"}, 708 708 + {"/", "/"}, 709 709 + {"////", "/"}, 710 710 + {"/foo", "/"}, 711 711 + {"x/", "x"}, 712 712 + {"abc", "."}, 713 713 + {"abc/def", "abc"}, 714 714 + {"a/b/.x", "a/b"}, 715 715 + {"a/b/c.", "a/b"}, 716 716 + {"a/b/c.x", "a/b"}, 717 717 + } 718 718 + 719 719 + var windirtests = []PathTest{ 720 720 + {`c:\`, `c:\`}, 721 721 + {`c:.`, `c:.`}, 722 722 + {`c:\a\b`, `c:\a`}, 723 723 + {`c:a\b`, `c:a`}, 724 724 + {`c:a\b\c`, `c:a\b`}, 725 725 + {`\\host\share`, `\\host\share`}, 726 726 + {`\\host\share\`, `\\host\share\`}, 727 727 + {`\\host\share\a`, `\\host\share\`}, 728 728 + {`\\host\share\a\b`, `\\host\share\a`}, 729 729 + } 730 730 + 731 731 + func TestDir(t *testing.T) { 732 732 + tests := dirtests 733 733 + if runtime.GOOS == "windows" { 734 734 + // make unix tests work on windows 735 735 + for i := range tests { 736 736 + tests[i].result = filepath.Clean(tests[i].result) 737 737 + } 738 738 + // add windows specific tests 739 739 + tests = append(tests, windirtests...) 740 740 + } 741 741 + for _, test := range tests { 742 742 + if s := filepath.Dir(test.path); s != test.result { 743 743 + t.Errorf("Dir(%q) = %q, want %q", test.path, s, test.result) 744 744 + } 745 745 + } 746 746 + } 747 747 + 748 748 + type IsAbsTest struct { 749 749 + path string 750 750 + isAbs bool 751 751 + } 752 752 + 753 753 + var isabstests = []IsAbsTest{ 754 754 + {"", false}, 755 755 + {"/", true}, 756 756 + {"/usr/bin/gcc", true}, 757 757 + {"..", false}, 758 758 + {"/a/../bb", true}, 759 759 + {".", false}, 760 760 + {"./", false}, 761 761 + {"lala", false}, 762 762 + } 763 763 + 764 764 + var winisabstests = []IsAbsTest{ 765 765 + {`C:\`, true}, 766 766 + {`c\`, false}, 767 767 + {`c::`, false}, 768 768 + {`c:`, false}, 769 769 + {`/`, false}, 770 770 + {`\`, false}, 771 771 + {`\Windows`, false}, 772 772 + {`c:a\b`, false}, 773 773 + {`c:\a\b`, true}, 774 774 + {`c:/a/b`, true}, 775 775 + {`\\host\share\foo`, true}, 776 776 + {`//host/share/foo/bar`, true}, 777 777 + } 778 778 + 779 779 + func TestIsAbs(t *testing.T) { 780 780 + var tests []IsAbsTest 781 781 + if runtime.GOOS == "windows" { 782 782 + tests = append(tests, winisabstests...) 783 783 + // All non-windows tests should fail, because they have no volume letter. 784 784 + for _, test := range isabstests { 785 785 + tests = append(tests, IsAbsTest{test.path, false}) 786 786 + } 787 787 + // All non-windows test should work as intended if prefixed with volume letter. 788 788 + for _, test := range isabstests { 789 789 + tests = append(tests, IsAbsTest{"c:" + test.path, test.isAbs}) 790 790 + } 791 791 + // Test reserved names. 792 792 + tests = append(tests, IsAbsTest{os.DevNull, true}) 793 793 + tests = append(tests, IsAbsTest{"NUL", true}) 794 794 + tests = append(tests, IsAbsTest{"nul", true}) 795 795 + tests = append(tests, IsAbsTest{"CON", true}) 796 796 + } else { 797 797 + tests = isabstests 798 798 + } 799 799 + 800 800 + for _, test := range tests { 801 801 + if r := filepath.IsAbs(test.path); r != test.isAbs { 802 802 + t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs) 803 803 + } 804 804 + } 805 805 + } 806 806 + 807 807 + type EvalSymlinksTest struct { 808 808 + // If dest is empty, the path is created; otherwise the dest is symlinked to the path. 809 809 + path, dest string 810 810 + } 811 811 + 812 812 + var EvalSymlinksTestDirs = []EvalSymlinksTest{ 813 813 + {"test", ""}, 814 814 + {"test/dir", ""}, 815 815 + {"test/dir/link3", "../../"}, 816 816 + {"test/link1", "../test"}, 817 817 + {"test/link2", "dir"}, 818 818 + {"test/linkabs", "/"}, 819 819 + {"test/link4", "../test2"}, 820 820 + {"test2", "test/dir"}, 821 821 + // Issue 23444. 822 822 + {"src", ""}, 823 823 + {"src/pool", ""}, 824 824 + {"src/pool/test", ""}, 825 825 + {"src/versions", ""}, 826 826 + {"src/versions/current", "../../version"}, 827 827 + {"src/versions/v1", ""}, 828 828 + {"src/versions/v1/modules", ""}, 829 829 + {"src/versions/v1/modules/test", "../../../pool/test"}, 830 830 + {"version", "src/versions/v1"}, 831 831 + } 832 832 + 833 833 + var EvalSymlinksTests = []EvalSymlinksTest{ 834 834 + {"test", "test"}, 835 835 + {"test/dir", "test/dir"}, 836 836 + {"test/dir/../..", "."}, 837 837 + {"test/link1", "test"}, 838 838 + {"test/link2", "test/dir"}, 839 839 + {"test/link1/dir", "test/dir"}, 840 840 + {"test/link2/..", "test"}, 841 841 + {"test/dir/link3", "."}, 842 842 + {"test/link2/link3/test", "test"}, 843 843 + {"test/linkabs", "/"}, 844 844 + {"test/link4/..", "test"}, 845 845 + {"src/versions/current/modules/test", "src/pool/test"}, 846 846 + } 847 847 + 848 848 + // simpleJoin builds a file name from the directory and path. 849 849 + // It does not use Join because we don't want ".." to be evaluated. 850 850 + func simpleJoin(dir, path string) string { 851 851 + return dir + string(filepath.Separator) + path 852 852 + } 853 853 + 854 854 + func testEvalSymlinks(t *testing.T, path, want string) { 855 855 + have, err := filepath.EvalSymlinks(path) 856 856 + if err != nil { 857 857 + t.Errorf("EvalSymlinks(%q) error: %v", path, err) 858 858 + return 859 859 + } 860 860 + if filepath.Clean(have) != filepath.Clean(want) { 861 861 + t.Errorf("EvalSymlinks(%q) returns %q, want %q", path, have, want) 862 862 + } 863 863 + } 864 864 + 865 865 + func testEvalSymlinksAfterChdir(t *testing.T, wd, path, want string) { 866 866 + cwd, err := os.Getwd() 867 867 + if err != nil { 868 868 + t.Fatal(err) 869 869 + } 870 870 + defer func() { 871 871 + err := os.Chdir(cwd) 872 872 + if err != nil { 873 873 + t.Fatal(err) 874 874 + } 875 875 + }() 876 876 + 877 877 + err = os.Chdir(wd) 878 878 + if err != nil { 879 879 + t.Fatal(err) 880 880 + } 881 881 + 882 882 + have, err := filepath.EvalSymlinks(path) 883 883 + if err != nil { 884 884 + t.Errorf("EvalSymlinks(%q) in %q directory error: %v", path, wd, err) 885 885 + return 886 886 + } 887 887 + if filepath.Clean(have) != filepath.Clean(want) { 888 888 + t.Errorf("EvalSymlinks(%q) in %q directory returns %q, want %q", path, wd, have, want) 889 889 + } 890 890 + } 891 891 + 892 892 + func TestEvalSymlinks(t *testing.T) { 893 893 + testenv.MustHaveSymlink(t) 894 894 + 895 895 + tmpDir, err := ioutil.TempDir("", "evalsymlink") 896 896 + if err != nil { 897 897 + t.Fatal("creating temp dir:", err) 898 898 + } 899 899 + defer os.RemoveAll(tmpDir) 900 900 + 901 901 + // /tmp may itself be a symlink! Avoid the confusion, although 902 902 + // it means trusting the thing we're testing. 903 903 + tmpDir, err = filepath.EvalSymlinks(tmpDir) 904 904 + if err != nil { 905 905 + t.Fatal("eval symlink for tmp dir:", err) 906 906 + } 907 907 + 908 908 + // Create the symlink farm using relative paths. 909 909 + for _, d := range EvalSymlinksTestDirs { 910 910 + var err error 911 911 + path := simpleJoin(tmpDir, d.path) 912 912 + if d.dest == "" { 913 913 + err = os.Mkdir(path, 0755) 914 914 + } else { 915 915 + err = os.Symlink(d.dest, path) 916 916 + } 917 917 + if err != nil { 918 918 + t.Fatal(err) 919 919 + } 920 920 + } 921 921 + 922 922 + // Evaluate the symlink farm. 923 923 + for _, test := range EvalSymlinksTests { 924 924 + path := simpleJoin(tmpDir, test.path) 925 925 + 926 926 + dest := simpleJoin(tmpDir, test.dest) 927 927 + if filepath.IsAbs(test.dest) || os.IsPathSeparator(test.dest[0]) { 928 928 + dest = test.dest 929 929 + } 930 930 + testEvalSymlinks(t, path, dest) 931 931 + 932 932 + // test EvalSymlinks(".") 933 933 + testEvalSymlinksAfterChdir(t, path, ".", ".") 934 934 + 935 935 + // test EvalSymlinks("C:.") on Windows 936 936 + if runtime.GOOS == "windows" { 937 937 + volDot := filepath.VolumeName(tmpDir) + "." 938 938 + testEvalSymlinksAfterChdir(t, path, volDot, volDot) 939 939 + } 940 940 + 941 941 + // test EvalSymlinks(".."+path) 942 942 + dotdotPath := simpleJoin("..", test.dest) 943 943 + if filepath.IsAbs(test.dest) || os.IsPathSeparator(test.dest[0]) { 944 944 + dotdotPath = test.dest 945 945 + } 946 946 + testEvalSymlinksAfterChdir(t, 947 947 + simpleJoin(tmpDir, "test"), 948 948 + simpleJoin("..", test.path), 949 949 + dotdotPath) 950 950 + 951 951 + // test EvalSymlinks(p) where p is relative path 952 952 + testEvalSymlinksAfterChdir(t, tmpDir, test.path, test.dest) 953 953 + } 954 954 + } 955 955 + 956 956 + func TestEvalSymlinksIsNotExist(t *testing.T) { 957 957 + testenv.MustHaveSymlink(t) 958 958 + 959 959 + defer chtmpdir(t)() 960 960 + 961 961 + _, err := filepath.EvalSymlinks("notexist") 962 962 + if !os.IsNotExist(err) { 963 963 + t.Errorf("expected the file is not found, got %v\n", err) 964 964 + } 965 965 + 966 966 + err = os.Symlink("notexist", "link") 967 967 + if err != nil { 968 968 + t.Fatal(err) 969 969 + } 970 970 + defer os.Remove("link") 971 971 + 972 972 + _, err = filepath.EvalSymlinks("link") 973 973 + if !os.IsNotExist(err) { 974 974 + t.Errorf("expected the file is not found, got %v\n", err) 975 975 + } 976 976 + } 977 977 + 978 978 + func TestIssue13582(t *testing.T) { 979 979 + testenv.MustHaveSymlink(t) 980 980 + 981 981 + tmpDir, err := ioutil.TempDir("", "issue13582") 982 982 + if err != nil { 983 983 + t.Fatal(err) 984 984 + } 985 985 + defer os.RemoveAll(tmpDir) 986 986 + 987 987 + dir := filepath.Join(tmpDir, "dir") 988 988 + err = os.Mkdir(dir, 0755) 989 989 + if err != nil { 990 990 + t.Fatal(err) 991 991 + } 992 992 + linkToDir := filepath.Join(tmpDir, "link_to_dir") 993 993 + err = os.Symlink(dir, linkToDir) 994 994 + if err != nil { 995 995 + t.Fatal(err) 996 996 + } 997 997 + file := filepath.Join(linkToDir, "file") 998 998 + err = ioutil.WriteFile(file, nil, 0644) 999 999 + if err != nil { 1000 1000 + t.Fatal(err) 1001 1001 + } 1002 1002 + link1 := filepath.Join(linkToDir, "link1") 1003 1003 + err = os.Symlink(file, link1) 1004 1004 + if err != nil { 1005 1005 + t.Fatal(err) 1006 1006 + } 1007 1007 + link2 := filepath.Join(linkToDir, "link2") 1008 1008 + err = os.Symlink(link1, link2) 1009 1009 + if err != nil { 1010 1010 + t.Fatal(err) 1011 1011 + } 1012 1012 + 1013 1013 + // /tmp may itself be a symlink! 1014 1014 + realTmpDir, err := filepath.EvalSymlinks(tmpDir) 1015 1015 + if err != nil { 1016 1016 + t.Fatal(err) 1017 1017 + } 1018 1018 + realDir := filepath.Join(realTmpDir, "dir") 1019 1019 + realFile := filepath.Join(realDir, "file") 1020 1020 + 1021 1021 + tests := []struct { 1022 1022 + path, want string 1023 1023 + }{ 1024 1024 + {dir, realDir}, 1025 1025 + {linkToDir, realDir}, 1026 1026 + {file, realFile}, 1027 1027 + {link1, realFile}, 1028 1028 + {link2, realFile}, 1029 1029 + } 1030 1030 + for i, test := range tests { 1031 1031 + have, err := filepath.EvalSymlinks(test.path) 1032 1032 + if err != nil { 1033 1033 + t.Fatal(err) 1034 1034 + } 1035 1035 + if have != test.want { 1036 1036 + t.Errorf("test#%d: EvalSymlinks(%q) returns %q, want %q", i, test.path, have, test.want) 1037 1037 + } 1038 1038 + } 1039 1039 + } 1040 1040 + 1041 1041 + // Test directories relative to temporary directory. 1042 1042 + // The tests are run in absTestDirs[0]. 1043 1043 + var absTestDirs = []string{ 1044 1044 + "a", 1045 1045 + "a/b", 1046 1046 + "a/b/c", 1047 1047 + } 1048 1048 + 1049 1049 + // Test paths relative to temporary directory. $ expands to the directory. 1050 1050 + // The tests are run in absTestDirs[0]. 1051 1051 + // We create absTestDirs first. 1052 1052 + var absTests = []string{ 1053 1053 + ".", 1054 1054 + "b", 1055 1055 + "b/", 1056 1056 + "../a", 1057 1057 + "../a/b", 1058 1058 + "../a/b/./c/../../.././a", 1059 1059 + "../a/b/./c/../../.././a/", 1060 1060 + "$", 1061 1061 + "$/.", 1062 1062 + "$/a/../a/b", 1063 1063 + "$/a/b/c/../../.././a", 1064 1064 + "$/a/b/c/../../.././a/", 1065 1065 + } 1066 1066 + 1067 1067 + func TestAbs(t *testing.T) { 1068 1068 + root, err := ioutil.TempDir("", "TestAbs") 1069 1069 + if err != nil { 1070 1070 + t.Fatal("TempDir failed: ", err) 1071 1071 + } 1072 1072 + defer os.RemoveAll(root) 1073 1073 + 1074 1074 + wd, err := os.Getwd() 1075 1075 + if err != nil { 1076 1076 + t.Fatal("getwd failed: ", err) 1077 1077 + } 1078 1078 + err = os.Chdir(root) 1079 1079 + if err != nil { 1080 1080 + t.Fatal("chdir failed: ", err) 1081 1081 + } 1082 1082 + defer os.Chdir(wd) 1083 1083 + 1084 1084 + for _, dir := range absTestDirs { 1085 1085 + err = os.Mkdir(dir, 0777) 1086 1086 + if err != nil { 1087 1087 + t.Fatal("Mkdir failed: ", err) 1088 1088 + } 1089 1089 + } 1090 1090 + 1091 1091 + if runtime.GOOS == "windows" { 1092 1092 + vol := filepath.VolumeName(root) 1093 1093 + var extra []string 1094 1094 + for _, path := range absTests { 1095 1095 + if strings.Contains(path, "$") { 1096 1096 + continue 1097 1097 + } 1098 1098 + path = vol + path 1099 1099 + extra = append(extra, path) 1100 1100 + } 1101 1101 + absTests = append(absTests, extra...) 1102 1102 + } 1103 1103 + 1104 1104 + err = os.Chdir(absTestDirs[0]) 1105 1105 + if err != nil { 1106 1106 + t.Fatal("chdir failed: ", err) 1107 1107 + } 1108 1108 + 1109 1109 + for _, path := range absTests { 1110 1110 + path = strings.ReplaceAll(path, "$", root) 1111 1111 + info, err := os.Stat(path) 1112 1112 + if err != nil { 1113 1113 + t.Errorf("%s: %s", path, err) 1114 1114 + continue 1115 1115 + } 1116 1116 + 1117 1117 + abspath, err := filepath.Abs(path) 1118 1118 + if err != nil { 1119 1119 + t.Errorf("Abs(%q) error: %v", path, err) 1120 1120 + continue 1121 1121 + } 1122 1122 + absinfo, err := os.Stat(abspath) 1123 1123 + if err != nil || !os.SameFile(absinfo, info) { 1124 1124 + t.Errorf("Abs(%q)=%q, not the same file", path, abspath) 1125 1125 + } 1126 1126 + if !filepath.IsAbs(abspath) { 1127 1127 + t.Errorf("Abs(%q)=%q, not an absolute path", path, abspath) 1128 1128 + } 1129 1129 + if filepath.IsAbs(abspath) && abspath != filepath.Clean(abspath) { 1130 1130 + t.Errorf("Abs(%q)=%q, isn't clean", path, abspath) 1131 1131 + } 1132 1132 + } 1133 1133 + } 1134 1134 + 1135 1135 + // Empty path needs to be special-cased on Windows. See golang.org/issue/24441. 1136 1136 + // We test it separately from all other absTests because the empty string is not 1137 1137 + // a valid path, so it can't be used with os.Stat. 1138 1138 + func TestAbsEmptyString(t *testing.T) { 1139 1139 + root, err := ioutil.TempDir("", "TestAbsEmptyString") 1140 1140 + if err != nil { 1141 1141 + t.Fatal("TempDir failed: ", err) 1142 1142 + } 1143 1143 + defer os.RemoveAll(root) 1144 1144 + 1145 1145 + wd, err := os.Getwd() 1146 1146 + if err != nil { 1147 1147 + t.Fatal("getwd failed: ", err) 1148 1148 + } 1149 1149 + err = os.Chdir(root) 1150 1150 + if err != nil { 1151 1151 + t.Fatal("chdir failed: ", err) 1152 1152 + } 1153 1153 + defer os.Chdir(wd) 1154 1154 + 1155 1155 + info, err := os.Stat(root) 1156 1156 + if err != nil { 1157 1157 + t.Fatalf("%s: %s", root, err) 1158 1158 + } 1159 1159 + 1160 1160 + abspath, err := filepath.Abs("") 1161 1161 + if err != nil { 1162 1162 + t.Fatalf(`Abs("") error: %v`, err) 1163 1163 + } 1164 1164 + absinfo, err := os.Stat(abspath) 1165 1165 + if err != nil || !os.SameFile(absinfo, info) { 1166 1166 + t.Errorf(`Abs("")=%q, not the same file`, abspath) 1167 1167 + } 1168 1168 + if !filepath.IsAbs(abspath) { 1169 1169 + t.Errorf(`Abs("")=%q, not an absolute path`, abspath) 1170 1170 + } 1171 1171 + if filepath.IsAbs(abspath) && abspath != filepath.Clean(abspath) { 1172 1172 + t.Errorf(`Abs("")=%q, isn't clean`, abspath) 1173 1173 + } 1174 1174 + } 1175 1175 + 1176 1176 + type RelTests struct { 1177 1177 + root, path, want string 1178 1178 + } 1179 1179 + 1180 1180 + var reltests = []RelTests{ 1181 1181 + {"a/b", "a/b", "."}, 1182 1182 + {"a/b/.", "a/b", "."}, 1183 1183 + {"a/b", "a/b/.", "."}, 1184 1184 + {"./a/b", "a/b", "."}, 1185 1185 + {"a/b", "./a/b", "."}, 1186 1186 + {"ab/cd", "ab/cde", "../cde"}, 1187 1187 + {"ab/cd", "ab/c", "../c"}, 1188 1188 + {"a/b", "a/b/c/d", "c/d"}, 1189 1189 + {"a/b", "a/b/../c", "../c"}, 1190 1190 + {"a/b/../c", "a/b", "../b"}, 1191 1191 + {"a/b/c", "a/c/d", "../../c/d"}, 1192 1192 + {"a/b", "c/d", "../../c/d"}, 1193 1193 + {"a/b/c/d", "a/b", "../.."}, 1194 1194 + {"a/b/c/d", "a/b/", "../.."}, 1195 1195 + {"a/b/c/d/", "a/b", "../.."}, 1196 1196 + {"a/b/c/d/", "a/b/", "../.."}, 1197 1197 + {"../../a/b", "../../a/b/c/d", "c/d"}, 1198 1198 + {"/a/b", "/a/b", "."}, 1199 1199 + {"/a/b/.", "/a/b", "."}, 1200 1200 + {"/a/b", "/a/b/.", "."}, 1201 1201 + {"/ab/cd", "/ab/cde", "../cde"}, 1202 1202 + {"/ab/cd", "/ab/c", "../c"}, 1203 1203 + {"/a/b", "/a/b/c/d", "c/d"}, 1204 1204 + {"/a/b", "/a/b/../c", "../c"}, 1205 1205 + {"/a/b/../c", "/a/b", "../b"}, 1206 1206 + {"/a/b/c", "/a/c/d", "../../c/d"}, 1207 1207 + {"/a/b", "/c/d", "../../c/d"}, 1208 1208 + {"/a/b/c/d", "/a/b", "../.."}, 1209 1209 + {"/a/b/c/d", "/a/b/", "../.."}, 1210 1210 + {"/a/b/c/d/", "/a/b", "../.."}, 1211 1211 + {"/a/b/c/d/", "/a/b/", "../.."}, 1212 1212 + {"/../../a/b", "/../../a/b/c/d", "c/d"}, 1213 1213 + {".", "a/b", "a/b"}, 1214 1214 + {".", "..", ".."}, 1215 1215 + 1216 1216 + // can't do purely lexically 1217 1217 + {"..", ".", "err"}, 1218 1218 + {"..", "a", "err"}, 1219 1219 + {"../..", "..", "err"}, 1220 1220 + {"a", "/a", "err"}, 1221 1221 + {"/a", "a", "err"}, 1222 1222 + } 1223 1223 + 1224 1224 + var winreltests = []RelTests{ 1225 1225 + {`C:a\b\c`, `C:a/b/d`, `..\d`}, 1226 1226 + {`C:\`, `D:\`, `err`}, 1227 1227 + {`C:`, `D:`, `err`}, 1228 1228 + {`C:\Projects`, `c:\projects\src`, `src`}, 1229 1229 + {`C:\Projects`, `c:\projects`, `.`}, 1230 1230 + {`C:\Projects\a\..`, `c:\projects`, `.`}, 1231 1231 + } 1232 1232 + 1233 1233 + func TestRel(t *testing.T) { 1234 1234 + tests := append([]RelTests{}, reltests...) 1235 1235 + if runtime.GOOS == "windows" { 1236 1236 + for i := range tests { 1237 1237 + tests[i].want = filepath.FromSlash(tests[i].want) 1238 1238 + } 1239 1239 + tests = append(tests, winreltests...) 1240 1240 + } 1241 1241 + for _, test := range tests { 1242 1242 + got, err := filepath.Rel(test.root, test.path) 1243 1243 + if test.want == "err" { 1244 1244 + if err == nil { 1245 1245 + t.Errorf("Rel(%q, %q)=%q, want error", test.root, test.path, got) 1246 1246 + } 1247 1247 + continue 1248 1248 + } 1249 1249 + if err != nil { 1250 1250 + t.Errorf("Rel(%q, %q): want %q, got error: %s", test.root, test.path, test.want, err) 1251 1251 + } 1252 1252 + if got != test.want { 1253 1253 + t.Errorf("Rel(%q, %q)=%q, want %q", test.root, test.path, got, test.want) 1254 1254 + } 1255 1255 + } 1256 1256 + } 1257 1257 + 1258 1258 + type VolumeNameTest struct { 1259 1259 + path string 1260 1260 + vol string 1261 1261 + } 1262 1262 + 1263 1263 + var volumenametests = []VolumeNameTest{ 1264 1264 + {`c:/foo/bar`, `c:`}, 1265 1265 + {`c:`, `c:`}, 1266 1266 + {`2:`, ``}, 1267 1267 + {``, ``}, 1268 1268 + {`\\\host`, ``}, 1269 1269 + {`\\\host\`, ``}, 1270 1270 + {`\\\host\share`, ``}, 1271 1271 + {`\\\host\\share`, ``}, 1272 1272 + {`\\host`, ``}, 1273 1273 + {`//host`, ``}, 1274 1274 + {`\\host\`, ``}, 1275 1275 + {`//host/`, ``}, 1276 1276 + {`\\host\share`, `\\host\share`}, 1277 1277 + {`//host/share`, `//host/share`}, 1278 1278 + {`\\host\share\`, `\\host\share`}, 1279 1279 + {`//host/share/`, `//host/share`}, 1280 1280 + {`\\host\share\foo`, `\\host\share`}, 1281 1281 + {`//host/share/foo`, `//host/share`}, 1282 1282 + {`\\host\share\\foo\\\bar\\\\baz`, `\\host\share`}, 1283 1283 + {`//host/share//foo///bar////baz`, `//host/share`}, 1284 1284 + {`\\host\share\foo\..\bar`, `\\host\share`}, 1285 1285 + {`//host/share/foo/../bar`, `//host/share`}, 1286 1286 + } 1287 1287 + 1288 1288 + func TestVolumeName(t *testing.T) { 1289 1289 + if runtime.GOOS != "windows" { 1290 1290 + return 1291 1291 + } 1292 1292 + for _, v := range volumenametests { 1293 1293 + if vol := filepath.VolumeName(v.path); vol != v.vol { 1294 1294 + t.Errorf("VolumeName(%q)=%q, want %q", v.path, vol, v.vol) 1295 1295 + } 1296 1296 + } 1297 1297 + } 1298 1298 + 1299 1299 + func TestDriveLetterInEvalSymlinks(t *testing.T) { 1300 1300 + if runtime.GOOS != "windows" { 1301 1301 + return 1302 1302 + } 1303 1303 + wd, _ := os.Getwd() 1304 1304 + if len(wd) < 3 { 1305 1305 + t.Errorf("Current directory path %q is too short", wd) 1306 1306 + } 1307 1307 + lp := strings.ToLower(wd) 1308 1308 + up := strings.ToUpper(wd) 1309 1309 + flp, err := filepath.EvalSymlinks(lp) 1310 1310 + if err != nil { 1311 1311 + t.Fatalf("EvalSymlinks(%q) failed: %q", lp, err) 1312 1312 + } 1313 1313 + fup, err := filepath.EvalSymlinks(up) 1314 1314 + if err != nil { 1315 1315 + t.Fatalf("EvalSymlinks(%q) failed: %q", up, err) 1316 1316 + } 1317 1317 + if flp != fup { 1318 1318 + t.Errorf("Results of EvalSymlinks do not match: %q and %q", flp, fup) 1319 1319 + } 1320 1320 + } 1321 1321 + 1322 1322 + func TestBug3486(t *testing.T) { // https://golang.org/issue/3486 1323 1323 + if runtime.GOOS == "ios" { 1324 1324 + t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH) 1325 1325 + } 1326 1326 + root, err := filepath.EvalSymlinks(runtime.GOROOT() + "/test") 1327 1327 + if err != nil { 1328 1328 + t.Fatal(err) 1329 1329 + } 1330 1330 + bugs := filepath.Join(root, "fixedbugs") 1331 1331 + ken := filepath.Join(root, "ken") 1332 1332 + seenBugs := false 1333 1333 + seenKen := false 1334 1334 + err = filepath.Walk(root, func(pth string, info fs.FileInfo, err error) error { 1335 1335 + if err != nil { 1336 1336 + t.Fatal(err) 1337 1337 + } 1338 1338 + 1339 1339 + switch pth { 1340 1340 + case bugs: 1341 1341 + seenBugs = true 1342 1342 + return filepath.SkipDir 1343 1343 + case ken: 1344 1344 + if !seenBugs { 1345 1345 + t.Fatal("filepath.Walk out of order - ken before fixedbugs") 1346 1346 + } 1347 1347 + seenKen = true 1348 1348 + } 1349 1349 + return nil 1350 1350 + }) 1351 1351 + if err != nil { 1352 1352 + t.Fatal(err) 1353 1353 + } 1354 1354 + if !seenKen { 1355 1355 + t.Fatalf("%q not seen", ken) 1356 1356 + } 1357 1357 + } 1358 1358 + 1359 1359 + func testWalkSymlink(t *testing.T, mklink func(target, link string) error) { 1360 1360 + tmpdir, err := ioutil.TempDir("", "testWalkSymlink") 1361 1361 + if err != nil { 1362 1362 + t.Fatal(err) 1363 1363 + } 1364 1364 + defer os.RemoveAll(tmpdir) 1365 1365 + 1366 1366 + wd, err := os.Getwd() 1367 1367 + if err != nil { 1368 1368 + t.Fatal(err) 1369 1369 + } 1370 1370 + defer os.Chdir(wd) 1371 1371 + 1372 1372 + err = os.Chdir(tmpdir) 1373 1373 + if err != nil { 1374 1374 + t.Fatal(err) 1375 1375 + } 1376 1376 + 1377 1377 + err = mklink(tmpdir, "link") 1378 1378 + if err != nil { 1379 1379 + t.Fatal(err) 1380 1380 + } 1381 1381 + 1382 1382 + var visited []string 1383 1383 + err = filepath.Walk(tmpdir, func(path string, info fs.FileInfo, err error) error { 1384 1384 + if err != nil { 1385 1385 + t.Fatal(err) 1386 1386 + } 1387 1387 + rel, err := filepath.Rel(tmpdir, path) 1388 1388 + if err != nil { 1389 1389 + t.Fatal(err) 1390 1390 + } 1391 1391 + visited = append(visited, rel) 1392 1392 + return nil 1393 1393 + }) 1394 1394 + if err != nil { 1395 1395 + t.Fatal(err) 1396 1396 + } 1397 1397 + sort.Strings(visited) 1398 1398 + want := []string{".", "link"} 1399 1399 + if fmt.Sprintf("%q", visited) != fmt.Sprintf("%q", want) { 1400 1400 + t.Errorf("unexpected paths visited %q, want %q", visited, want) 1401 1401 + } 1402 1402 + } 1403 1403 + 1404 1404 + func TestWalkSymlink(t *testing.T) { 1405 1405 + testenv.MustHaveSymlink(t) 1406 1406 + testWalkSymlink(t, os.Symlink) 1407 1407 + } 1408 1408 + 1409 1409 + func TestIssue29372(t *testing.T) { 1410 1410 + tmpDir, err := ioutil.TempDir("", "TestIssue29372") 1411 1411 + if err != nil { 1412 1412 + t.Fatal(err) 1413 1413 + } 1414 1414 + defer os.RemoveAll(tmpDir) 1415 1415 + 1416 1416 + path := filepath.Join(tmpDir, "file.txt") 1417 1417 + err = ioutil.WriteFile(path, nil, 0644) 1418 1418 + if err != nil { 1419 1419 + t.Fatal(err) 1420 1420 + } 1421 1421 + 1422 1422 + pathSeparator := string(filepath.Separator) 1423 1423 + tests := []string{ 1424 1424 + path + strings.Repeat(pathSeparator, 1), 1425 1425 + path + strings.Repeat(pathSeparator, 2), 1426 1426 + path + strings.Repeat(pathSeparator, 1) + ".", 1427 1427 + path + strings.Repeat(pathSeparator, 2) + ".", 1428 1428 + path + strings.Repeat(pathSeparator, 1) + "..", 1429 1429 + path + strings.Repeat(pathSeparator, 2) + "..", 1430 1430 + } 1431 1431 + 1432 1432 + for i, test := range tests { 1433 1433 + _, err = filepath.EvalSymlinks(test) 1434 1434 + if err != syscall.ENOTDIR { 1435 1435 + t.Fatalf("test#%d: want %q, got %q", i, syscall.ENOTDIR, err) 1436 1436 + } 1437 1437 + } 1438 1438 + } 1439 1439 + 1440 1440 + // Issue 30520 part 1. 1441 1441 + func TestEvalSymlinksAboveRoot(t *testing.T) { 1442 1442 + testenv.MustHaveSymlink(t) 1443 1443 + 1444 1444 + t.Parallel() 1445 1445 + 1446 1446 + tmpDir, err := ioutil.TempDir("", "TestEvalSymlinksAboveRoot") 1447 1447 + if err != nil { 1448 1448 + t.Fatal(err) 1449 1449 + } 1450 1450 + defer os.RemoveAll(tmpDir) 1451 1451 + 1452 1452 + evalTmpDir, err := filepath.EvalSymlinks(tmpDir) 1453 1453 + if err != nil { 1454 1454 + t.Fatal(err) 1455 1455 + } 1456 1456 + 1457 1457 + if err := os.Mkdir(filepath.Join(evalTmpDir, "a"), 0777); err != nil { 1458 1458 + t.Fatal(err) 1459 1459 + } 1460 1460 + if err := os.Symlink(filepath.Join(evalTmpDir, "a"), filepath.Join(evalTmpDir, "b")); err != nil { 1461 1461 + t.Fatal(err) 1462 1462 + } 1463 1463 + if err := ioutil.WriteFile(filepath.Join(evalTmpDir, "a", "file"), nil, 0666); err != nil { 1464 1464 + t.Fatal(err) 1465 1465 + } 1466 1466 + 1467 1467 + // Count the number of ".." elements to get to the root directory. 1468 1468 + vol := filepath.VolumeName(evalTmpDir) 1469 1469 + c := strings.Count(evalTmpDir[len(vol):], string(os.PathSeparator)) 1470 1470 + var dd []string 1471 1471 + for i := 0; i < c+2; i++ { 1472 1472 + dd = append(dd, "..") 1473 1473 + } 1474 1474 + 1475 1475 + wantSuffix := strings.Join([]string{"a", "file"}, string(os.PathSeparator)) 1476 1476 + 1477 1477 + // Try different numbers of "..". 1478 1478 + for _, i := range []int{c, c + 1, c + 2} { 1479 1479 + check := strings.Join([]string{evalTmpDir, strings.Join(dd[:i], string(os.PathSeparator)), evalTmpDir[len(vol)+1:], "b", "file"}, string(os.PathSeparator)) 1480 1480 + if resolved, err := filepath.EvalSymlinks(check); err != nil { 1481 1481 + t.Errorf("EvalSymlinks(%q) failed: %v", check, err) 1482 1482 + } else if !strings.HasSuffix(resolved, wantSuffix) { 1483 1483 + t.Errorf("EvalSymlinks(%q) = %q does not end with %q", check, resolved, wantSuffix) 1484 1484 + } else { 1485 1485 + t.Logf("EvalSymlinks(%q) = %q", check, resolved) 1486 1486 + } 1487 1487 + } 1488 1488 + } 1489 1489 + 1490 1490 + // Issue 30520 part 2. 1491 1491 + func TestEvalSymlinksAboveRootChdir(t *testing.T) { 1492 1492 + testenv.MustHaveSymlink(t) 1493 1493 + 1494 1494 + tmpDir, err := ioutil.TempDir("", "TestEvalSymlinksAboveRootChdir") 1495 1495 + if err != nil { 1496 1496 + t.Fatal(err) 1497 1497 + } 1498 1498 + defer os.RemoveAll(tmpDir) 1499 1499 + 1500 1500 + wd, err := os.Getwd() 1501 1501 + if err != nil { 1502 1502 + t.Fatal(err) 1503 1503 + } 1504 1504 + defer os.Chdir(wd) 1505 1505 + 1506 1506 + if err := os.Chdir(tmpDir); err != nil { 1507 1507 + t.Fatal(err) 1508 1508 + } 1509 1509 + 1510 1510 + subdir := filepath.Join("a", "b") 1511 1511 + if err := os.MkdirAll(subdir, 0777); err != nil { 1512 1512 + t.Fatal(err) 1513 1513 + } 1514 1514 + if err := os.Symlink(subdir, "c"); err != nil { 1515 1515 + t.Fatal(err) 1516 1516 + } 1517 1517 + if err := ioutil.WriteFile(filepath.Join(subdir, "file"), nil, 0666); err != nil { 1518 1518 + t.Fatal(err) 1519 1519 + } 1520 1520 + 1521 1521 + subdir = filepath.Join("d", "e", "f") 1522 1522 + if err := os.MkdirAll(subdir, 0777); err != nil { 1523 1523 + t.Fatal(err) 1524 1524 + } 1525 1525 + if err := os.Chdir(subdir); err != nil { 1526 1526 + t.Fatal(err) 1527 1527 + } 1528 1528 + 1529 1529 + check := filepath.Join("..", "..", "..", "c", "file") 1530 1530 + wantSuffix := filepath.Join("a", "b", "file") 1531 1531 + if resolved, err := filepath.EvalSymlinks(check); err != nil { 1532 1532 + t.Errorf("EvalSymlinks(%q) failed: %v", check, err) 1533 1533 + } else if !strings.HasSuffix(resolved, wantSuffix) { 1534 1534 + t.Errorf("EvalSymlinks(%q) = %q does not end with %q", check, resolved, wantSuffix) 1535 1535 + } else { 1536 1536 + t.Logf("EvalSymlinks(%q) = %q", check, resolved) 1537 1537 + } 1538 1538 + }

+53

pkg/path/testdata/path_unix.go

reviewed

··· 1 1 + // Copyright 2010 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris 6 6 + 7 7 + package filepath 8 8 + 9 9 + import "strings" 10 10 + 11 11 + // IsAbs reports whether the path is absolute. 12 12 + func IsAbs(path string) bool { 13 13 + return strings.HasPrefix(path, "/") 14 14 + } 15 15 + 16 16 + // volumeNameLen returns length of the leading volume name on Windows. 17 17 + // It returns 0 elsewhere. 18 18 + func volumeNameLen(path string) int { 19 19 + return 0 20 20 + } 21 21 + 22 22 + // HasPrefix exists for historical compatibility and should not be used. 23 23 + // 24 24 + // Deprecated: HasPrefix does not respect path boundaries and 25 25 + // does not ignore case when required. 26 26 + func HasPrefix(p, prefix string) bool { 27 27 + return strings.HasPrefix(p, prefix) 28 28 + } 29 29 + 30 30 + func splitList(path string) []string { 31 31 + if path == "" { 32 32 + return []string{} 33 33 + } 34 34 + return strings.Split(path, string(ListSeparator)) 35 35 + } 36 36 + 37 37 + func abs(path string) (string, error) { 38 38 + return unixAbs(path) 39 39 + } 40 40 + 41 41 + func join(elem []string) string { 42 42 + // If there's a bug here, fix the logic in ./path_plan9.go too. 43 43 + for i, e := range elem { 44 44 + if e != "" { 45 45 + return Clean(strings.Join(elem[i:], string(Separator))) 46 46 + } 47 47 + } 48 48 + return "" 49 49 + } 50 50 + 51 51 + func sameWord(a, b string) bool { 52 52 + return a == b 53 53 + }

+200

pkg/path/testdata/path_windows.go

reviewed

··· 1 1 + // Copyright 2010 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + import ( 8 8 + "strings" 9 9 + "syscall" 10 10 + ) 11 11 + 12 12 + func isSlash(c uint8) bool { 13 13 + return c == '\\' || c == '/' 14 14 + } 15 15 + 16 16 + // reservedNames lists reserved Windows names. Search for PRN in 17 17 + // https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file 18 18 + // for details. 19 19 + var reservedNames = []string{ 20 20 + "CON", "PRN", "AUX", "NUL", 21 21 + "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", 22 22 + "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", 23 23 + } 24 24 + 25 25 + // isReservedName returns true, if path is Windows reserved name. 26 26 + // See reservedNames for the full list. 27 27 + func isReservedName(path string) bool { 28 28 + if len(path) == 0 { 29 29 + return false 30 30 + } 31 31 + for _, reserved := range reservedNames { 32 32 + if strings.EqualFold(path, reserved) { 33 33 + return true 34 34 + } 35 35 + } 36 36 + return false 37 37 + } 38 38 + 39 39 + // IsAbs reports whether the path is absolute. 40 40 + func IsAbs(path string) (b bool) { 41 41 + if isReservedName(path) { 42 42 + return true 43 43 + } 44 44 + l := volumeNameLen(path) 45 45 + if l == 0 { 46 46 + return false 47 47 + } 48 48 + path = path[l:] 49 49 + if path == "" { 50 50 + return false 51 51 + } 52 52 + return isSlash(path[0]) 53 53 + } 54 54 + 55 55 + // volumeNameLen returns length of the leading volume name on Windows. 56 56 + // It returns 0 elsewhere. 57 57 + func volumeNameLen(path string) int { 58 58 + if len(path) < 2 { 59 59 + return 0 60 60 + } 61 61 + // with drive letter 62 62 + c := path[0] 63 63 + if path[1] == ':' && ('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') { 64 64 + return 2 65 65 + } 66 66 + // is it UNC? https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx 67 67 + if l := len(path); l >= 5 && isSlash(path[0]) && isSlash(path[1]) && 68 68 + !isSlash(path[2]) && path[2] != '.' { 69 69 + // first, leading `\\` and next shouldn't be `\`. its server name. 70 70 + for n := 3; n < l-1; n++ { 71 71 + // second, next '\' shouldn't be repeated. 72 72 + if isSlash(path[n]) { 73 73 + n++ 74 74 + // third, following something characters. its share name. 75 75 + if !isSlash(path[n]) { 76 76 + if path[n] == '.' { 77 77 + break 78 78 + } 79 79 + for ; n < l; n++ { 80 80 + if isSlash(path[n]) { 81 81 + break 82 82 + } 83 83 + } 84 84 + return n 85 85 + } 86 86 + break 87 87 + } 88 88 + } 89 89 + } 90 90 + return 0 91 91 + } 92 92 + 93 93 + // HasPrefix exists for historical compatibility and should not be used. 94 94 + // 95 95 + // Deprecated: HasPrefix does not respect path boundaries and 96 96 + // does not ignore case when required. 97 97 + func HasPrefix(p, prefix string) bool { 98 98 + if strings.HasPrefix(p, prefix) { 99 99 + return true 100 100 + } 101 101 + return strings.HasPrefix(strings.ToLower(p), strings.ToLower(prefix)) 102 102 + } 103 103 + 104 104 + func splitList(path string) []string { 105 105 + // The same implementation is used in LookPath in os/exec; 106 106 + // consider changing os/exec when changing this. 107 107 + 108 108 + if path == "" { 109 109 + return []string{} 110 110 + } 111 111 + 112 112 + // Split path, respecting but preserving quotes. 113 113 + list := []string{} 114 114 + start := 0 115 115 + quo := false 116 116 + for i := 0; i < len(path); i++ { 117 117 + switch c := path[i]; { 118 118 + case c == '"': 119 119 + quo = !quo 120 120 + case c == ListSeparator && !quo: 121 121 + list = append(list, path[start:i]) 122 122 + start = i + 1 123 123 + } 124 124 + } 125 125 + list = append(list, path[start:]) 126 126 + 127 127 + // Remove quotes. 128 128 + for i, s := range list { 129 129 + list[i] = strings.ReplaceAll(s, `"`, ``) 130 130 + } 131 131 + 132 132 + return list 133 133 + } 134 134 + 135 135 + func abs(path string) (string, error) { 136 136 + if path == "" { 137 137 + // syscall.FullPath returns an error on empty path, because it's not a valid path. 138 138 + // To implement Abs behavior of returning working directory on empty string input, 139 139 + // special-case empty path by changing it to "." path. See golang.org/issue/24441. 140 140 + path = "." 141 141 + } 142 142 + fullPath, err := syscall.FullPath(path) 143 143 + if err != nil { 144 144 + return "", err 145 145 + } 146 146 + return Clean(fullPath), nil 147 147 + } 148 148 + 149 149 + func join(elem []string) string { 150 150 + for i, e := range elem { 151 151 + if e != "" { 152 152 + return joinNonEmpty(elem[i:]) 153 153 + } 154 154 + } 155 155 + return "" 156 156 + } 157 157 + 158 158 + // joinNonEmpty is like join, but it assumes that the first element is non-empty. 159 159 + func joinNonEmpty(elem []string) string { 160 160 + if len(elem[0]) == 2 && elem[0][1] == ':' { 161 161 + // First element is drive letter without terminating slash. 162 162 + // Keep path relative to current directory on that drive. 163 163 + // Skip empty elements. 164 164 + i := 1 165 165 + for ; i < len(elem); i++ { 166 166 + if elem[i] != "" { 167 167 + break 168 168 + } 169 169 + } 170 170 + return Clean(elem[0] + strings.Join(elem[i:], string(Separator))) 171 171 + } 172 172 + // The following logic prevents Join from inadvertently creating a 173 173 + // UNC path on Windows. Unless the first element is a UNC path, Join 174 174 + // shouldn't create a UNC path. See golang.org/issue/9167. 175 175 + p := Clean(strings.Join(elem, string(Separator))) 176 176 + if !isUNC(p) { 177 177 + return p 178 178 + } 179 179 + // p == UNC only allowed when the first element is a UNC path. 180 180 + head := Clean(elem[0]) 181 181 + if isUNC(head) { 182 182 + return p 183 183 + } 184 184 + // head + tail == UNC, but joining two non-UNC paths should not result 185 185 + // in a UNC path. Undo creation of UNC path. 186 186 + tail := Clean(strings.Join(elem[1:], string(Separator))) 187 187 + if head[len(head)-1] == Separator { 188 188 + return head + tail 189 189 + } 190 190 + return head + string(Separator) + tail 191 191 + } 192 192 + 193 193 + // isUNC reports whether path is a UNC path. 194 194 + func isUNC(path string) bool { 195 195 + return volumeNameLen(path) > 2 196 196 + } 197 197 + 198 198 + func sameWord(a, b string) bool { 199 199 + return strings.EqualFold(a, b) 200 200 + }

+587

pkg/path/testdata/path_windows_test.go

reviewed

··· 1 1 + // Copyright 2013 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath_test 6 6 + 7 7 + import ( 8 8 + "flag" 9 9 + "fmt" 10 10 + "internal/testenv" 11 11 + "io/fs" 12 12 + "io/ioutil" 13 13 + "os" 14 14 + "os/exec" 15 15 + "path/filepath" 16 16 + "reflect" 17 17 + "runtime/debug" 18 18 + "strings" 19 19 + "testing" 20 20 + ) 21 21 + 22 22 + func TestWinSplitListTestsAreValid(t *testing.T) { 23 23 + comspec := os.Getenv("ComSpec") 24 24 + if comspec == "" { 25 25 + t.Fatal("%ComSpec% must be set") 26 26 + } 27 27 + 28 28 + for ti, tt := range winsplitlisttests { 29 29 + testWinSplitListTestIsValid(t, ti, tt, comspec) 30 30 + } 31 31 + } 32 32 + 33 33 + func testWinSplitListTestIsValid(t *testing.T, ti int, tt SplitListTest, 34 34 + comspec string) { 35 35 + 36 36 + const ( 37 37 + cmdfile = `printdir.cmd` 38 38 + perm fs.FileMode = 0700 39 39 + ) 40 40 + 41 41 + tmp, err := ioutil.TempDir("", "testWinSplitListTestIsValid") 42 42 + if err != nil { 43 43 + t.Fatalf("TempDir failed: %v", err) 44 44 + } 45 45 + defer os.RemoveAll(tmp) 46 46 + 47 47 + for i, d := range tt.result { 48 48 + if d == "" { 49 49 + continue 50 50 + } 51 51 + if cd := filepath.Clean(d); filepath.VolumeName(cd) != "" || 52 52 + cd[0] == '\\' || cd == ".." || (len(cd) >= 3 && cd[0:3] == `..\`) { 53 53 + t.Errorf("%d,%d: %#q refers outside working directory", ti, i, d) 54 54 + return 55 55 + } 56 56 + dd := filepath.Join(tmp, d) 57 57 + if _, err := os.Stat(dd); err == nil { 58 58 + t.Errorf("%d,%d: %#q already exists", ti, i, d) 59 59 + return 60 60 + } 61 61 + if err = os.MkdirAll(dd, perm); err != nil { 62 62 + t.Errorf("%d,%d: MkdirAll(%#q) failed: %v", ti, i, dd, err) 63 63 + return 64 64 + } 65 65 + fn, data := filepath.Join(dd, cmdfile), []byte("@echo "+d+"\r\n") 66 66 + if err = ioutil.WriteFile(fn, data, perm); err != nil { 67 67 + t.Errorf("%d,%d: WriteFile(%#q) failed: %v", ti, i, fn, err) 68 68 + return 69 69 + } 70 70 + } 71 71 + 72 72 + // on some systems, SystemRoot is required for cmd to work 73 73 + systemRoot := os.Getenv("SystemRoot") 74 74 + 75 75 + for i, d := range tt.result { 76 76 + if d == "" { 77 77 + continue 78 78 + } 79 79 + exp := []byte(d + "\r\n") 80 80 + cmd := &exec.Cmd{ 81 81 + Path: comspec, 82 82 + Args: []string{`/c`, cmdfile}, 83 83 + Env: []string{`Path=` + systemRoot + "/System32;" + tt.list, `SystemRoot=` + systemRoot}, 84 84 + Dir: tmp, 85 85 + } 86 86 + out, err := cmd.CombinedOutput() 87 87 + switch { 88 88 + case err != nil: 89 89 + t.Errorf("%d,%d: execution error %v\n%q", ti, i, err, out) 90 90 + return 91 91 + case !reflect.DeepEqual(out, exp): 92 92 + t.Errorf("%d,%d: expected %#q, got %#q", ti, i, exp, out) 93 93 + return 94 94 + default: 95 95 + // unshadow cmdfile in next directory 96 96 + err = os.Remove(filepath.Join(tmp, d, cmdfile)) 97 97 + if err != nil { 98 98 + t.Fatalf("Remove test command failed: %v", err) 99 99 + } 100 100 + } 101 101 + } 102 102 + } 103 103 + 104 104 + func TestWindowsEvalSymlinks(t *testing.T) { 105 105 + testenv.MustHaveSymlink(t) 106 106 + 107 107 + tmpDir, err := ioutil.TempDir("", "TestWindowsEvalSymlinks") 108 108 + if err != nil { 109 109 + t.Fatal(err) 110 110 + } 111 111 + defer os.RemoveAll(tmpDir) 112 112 + 113 113 + // /tmp may itself be a symlink! Avoid the confusion, although 114 114 + // it means trusting the thing we're testing. 115 115 + tmpDir, err = filepath.EvalSymlinks(tmpDir) 116 116 + if err != nil { 117 117 + t.Fatal(err) 118 118 + } 119 119 + 120 120 + if len(tmpDir) < 3 { 121 121 + t.Fatalf("tmpDir path %q is too short", tmpDir) 122 122 + } 123 123 + if tmpDir[1] != ':' { 124 124 + t.Fatalf("tmpDir path %q must have drive letter in it", tmpDir) 125 125 + } 126 126 + test := EvalSymlinksTest{"test/linkabswin", tmpDir[:3]} 127 127 + 128 128 + // Create the symlink farm using relative paths. 129 129 + testdirs := append(EvalSymlinksTestDirs, test) 130 130 + for _, d := range testdirs { 131 131 + var err error 132 132 + path := simpleJoin(tmpDir, d.path) 133 133 + if d.dest == "" { 134 134 + err = os.Mkdir(path, 0755) 135 135 + } else { 136 136 + err = os.Symlink(d.dest, path) 137 137 + } 138 138 + if err != nil { 139 139 + t.Fatal(err) 140 140 + } 141 141 + } 142 142 + 143 143 + path := simpleJoin(tmpDir, test.path) 144 144 + 145 145 + testEvalSymlinks(t, path, test.dest) 146 146 + 147 147 + testEvalSymlinksAfterChdir(t, path, ".", test.dest) 148 148 + 149 149 + testEvalSymlinksAfterChdir(t, 150 150 + path, 151 151 + filepath.VolumeName(tmpDir)+".", 152 152 + test.dest) 153 153 + 154 154 + testEvalSymlinksAfterChdir(t, 155 155 + simpleJoin(tmpDir, "test"), 156 156 + simpleJoin("..", test.path), 157 157 + test.dest) 158 158 + 159 159 + testEvalSymlinksAfterChdir(t, tmpDir, test.path, test.dest) 160 160 + } 161 161 + 162 162 + // TestEvalSymlinksCanonicalNames verify that EvalSymlinks 163 163 + // returns "canonical" path names on windows. 164 164 + func TestEvalSymlinksCanonicalNames(t *testing.T) { 165 165 + tmp, err := ioutil.TempDir("", "evalsymlinkcanonical") 166 166 + if err != nil { 167 167 + t.Fatal("creating temp dir:", err) 168 168 + } 169 169 + defer os.RemoveAll(tmp) 170 170 + 171 171 + // ioutil.TempDir might return "non-canonical" name. 172 172 + cTmpName, err := filepath.EvalSymlinks(tmp) 173 173 + if err != nil { 174 174 + t.Errorf("EvalSymlinks(%q) error: %v", tmp, err) 175 175 + } 176 176 + 177 177 + dirs := []string{ 178 178 + "test", 179 179 + "test/dir", 180 180 + "testing_long_dir", 181 181 + "TEST2", 182 182 + } 183 183 + 184 184 + for _, d := range dirs { 185 185 + dir := filepath.Join(cTmpName, d) 186 186 + err := os.Mkdir(dir, 0755) 187 187 + if err != nil { 188 188 + t.Fatal(err) 189 189 + } 190 190 + cname, err := filepath.EvalSymlinks(dir) 191 191 + if err != nil { 192 192 + t.Errorf("EvalSymlinks(%q) error: %v", dir, err) 193 193 + continue 194 194 + } 195 195 + if dir != cname { 196 196 + t.Errorf("EvalSymlinks(%q) returns %q, but should return %q", dir, cname, dir) 197 197 + continue 198 198 + } 199 199 + // test non-canonical names 200 200 + test := strings.ToUpper(dir) 201 201 + p, err := filepath.EvalSymlinks(test) 202 202 + if err != nil { 203 203 + t.Errorf("EvalSymlinks(%q) error: %v", test, err) 204 204 + continue 205 205 + } 206 206 + if p != cname { 207 207 + t.Errorf("EvalSymlinks(%q) returns %q, but should return %q", test, p, cname) 208 208 + continue 209 209 + } 210 210 + // another test 211 211 + test = strings.ToLower(dir) 212 212 + p, err = filepath.EvalSymlinks(test) 213 213 + if err != nil { 214 214 + t.Errorf("EvalSymlinks(%q) error: %v", test, err) 215 215 + continue 216 216 + } 217 217 + if p != cname { 218 218 + t.Errorf("EvalSymlinks(%q) returns %q, but should return %q", test, p, cname) 219 219 + continue 220 220 + } 221 221 + } 222 222 + } 223 223 + 224 224 + // checkVolume8dot3Setting runs "fsutil 8dot3name query c:" command 225 225 + // (where c: is vol parameter) to discover "8dot3 name creation state". 226 226 + // The state is combination of 2 flags. The global flag controls if it 227 227 + // is per volume or global setting: 228 228 + // 0 - Enable 8dot3 name creation on all volumes on the system 229 229 + // 1 - Disable 8dot3 name creation on all volumes on the system 230 230 + // 2 - Set 8dot3 name creation on a per volume basis 231 231 + // 3 - Disable 8dot3 name creation on all volumes except the system volume 232 232 + // If global flag is set to 2, then per-volume flag needs to be examined: 233 233 + // 0 - Enable 8dot3 name creation on this volume 234 234 + // 1 - Disable 8dot3 name creation on this volume 235 235 + // checkVolume8dot3Setting verifies that "8dot3 name creation" flags 236 236 + // are set to 2 and 0, if enabled parameter is true, or 2 and 1, if enabled 237 237 + // is false. Otherwise checkVolume8dot3Setting returns error. 238 238 + func checkVolume8dot3Setting(vol string, enabled bool) error { 239 239 + // It appears, on some systems "fsutil 8dot3name query ..." command always 240 240 + // exits with error. Ignore exit code, and look at fsutil output instead. 241 241 + out, _ := exec.Command("fsutil", "8dot3name", "query", vol).CombinedOutput() 242 242 + // Check that system has "Volume level setting" set. 243 243 + expected := "The registry state of NtfsDisable8dot3NameCreation is 2, the default (Volume level setting)" 244 244 + if !strings.Contains(string(out), expected) { 245 245 + // Windows 10 version of fsutil has different output message. 246 246 + expectedWindow10 := "The registry state is: 2 (Per volume setting - the default)" 247 247 + if !strings.Contains(string(out), expectedWindow10) { 248 248 + return fmt.Errorf("fsutil output should contain %q, but is %q", expected, string(out)) 249 249 + } 250 250 + } 251 251 + // Now check the volume setting. 252 252 + expected = "Based on the above two settings, 8dot3 name creation is %s on %s" 253 253 + if enabled { 254 254 + expected = fmt.Sprintf(expected, "enabled", vol) 255 255 + } else { 256 256 + expected = fmt.Sprintf(expected, "disabled", vol) 257 257 + } 258 258 + if !strings.Contains(string(out), expected) { 259 259 + return fmt.Errorf("unexpected fsutil output: %q", string(out)) 260 260 + } 261 261 + return nil 262 262 + } 263 263 + 264 264 + func setVolume8dot3Setting(vol string, enabled bool) error { 265 265 + cmd := []string{"fsutil", "8dot3name", "set", vol} 266 266 + if enabled { 267 267 + cmd = append(cmd, "0") 268 268 + } else { 269 269 + cmd = append(cmd, "1") 270 270 + } 271 271 + // It appears, on some systems "fsutil 8dot3name set ..." command always 272 272 + // exits with error. Ignore exit code, and look at fsutil output instead. 273 273 + out, _ := exec.Command(cmd[0], cmd[1:]...).CombinedOutput() 274 274 + if string(out) != "\r\nSuccessfully set 8dot3name behavior.\r\n" { 275 275 + // Windows 10 version of fsutil has different output message. 276 276 + expectedWindow10 := "Successfully %s 8dot3name generation on %s\r\n" 277 277 + if enabled { 278 278 + expectedWindow10 = fmt.Sprintf(expectedWindow10, "enabled", vol) 279 279 + } else { 280 280 + expectedWindow10 = fmt.Sprintf(expectedWindow10, "disabled", vol) 281 281 + } 282 282 + if string(out) != expectedWindow10 { 283 283 + return fmt.Errorf("%v command failed: %q", cmd, string(out)) 284 284 + } 285 285 + } 286 286 + return nil 287 287 + } 288 288 + 289 289 + var runFSModifyTests = flag.Bool("run_fs_modify_tests", false, "run tests which modify filesystem parameters") 290 290 + 291 291 + // This test assumes registry state of NtfsDisable8dot3NameCreation is 2, 292 292 + // the default (Volume level setting). 293 293 + func TestEvalSymlinksCanonicalNamesWith8dot3Disabled(t *testing.T) { 294 294 + if !*runFSModifyTests { 295 295 + t.Skip("skipping test that modifies file system setting; enable with -run_fs_modify_tests") 296 296 + } 297 297 + tempVol := filepath.VolumeName(os.TempDir()) 298 298 + if len(tempVol) != 2 { 299 299 + t.Fatalf("unexpected temp volume name %q", tempVol) 300 300 + } 301 301 + 302 302 + err := checkVolume8dot3Setting(tempVol, true) 303 303 + if err != nil { 304 304 + t.Fatal(err) 305 305 + } 306 306 + err = setVolume8dot3Setting(tempVol, false) 307 307 + if err != nil { 308 308 + t.Fatal(err) 309 309 + } 310 310 + defer func() { 311 311 + err := setVolume8dot3Setting(tempVol, true) 312 312 + if err != nil { 313 313 + t.Fatal(err) 314 314 + } 315 315 + err = checkVolume8dot3Setting(tempVol, true) 316 316 + if err != nil { 317 317 + t.Fatal(err) 318 318 + } 319 319 + }() 320 320 + err = checkVolume8dot3Setting(tempVol, false) 321 321 + if err != nil { 322 322 + t.Fatal(err) 323 323 + } 324 324 + TestEvalSymlinksCanonicalNames(t) 325 325 + } 326 326 + 327 327 + func TestToNorm(t *testing.T) { 328 328 + stubBase := func(path string) (string, error) { 329 329 + vol := filepath.VolumeName(path) 330 330 + path = path[len(vol):] 331 331 + 332 332 + if strings.Contains(path, "/") { 333 333 + return "", fmt.Errorf("invalid path is given to base: %s", vol+path) 334 334 + } 335 335 + 336 336 + if path == "" || path == "." || path == `\` { 337 337 + return "", fmt.Errorf("invalid path is given to base: %s", vol+path) 338 338 + } 339 339 + 340 340 + i := strings.LastIndexByte(path, filepath.Separator) 341 341 + if i == len(path)-1 { // trailing '\' is invalid 342 342 + return "", fmt.Errorf("invalid path is given to base: %s", vol+path) 343 343 + } 344 344 + if i == -1 { 345 345 + return strings.ToUpper(path), nil 346 346 + } 347 347 + 348 348 + return strings.ToUpper(path[i+1:]), nil 349 349 + } 350 350 + 351 351 + // On this test, toNorm should be same as string.ToUpper(filepath.Clean(path)) except empty string. 352 352 + tests := []struct { 353 353 + arg string 354 354 + want string 355 355 + }{ 356 356 + {"", ""}, 357 357 + {".", "."}, 358 358 + {"./foo/bar", `FOO\BAR`}, 359 359 + {"/", `\`}, 360 360 + {"/foo/bar", `\FOO\BAR`}, 361 361 + {"/foo/bar/baz/qux", `\FOO\BAR\BAZ\QUX`}, 362 362 + {"foo/bar", `FOO\BAR`}, 363 363 + {"C:/foo/bar", `C:\FOO\BAR`}, 364 364 + {"C:foo/bar", `C:FOO\BAR`}, 365 365 + {"c:/foo/bar", `C:\FOO\BAR`}, 366 366 + {"C:/foo/bar", `C:\FOO\BAR`}, 367 367 + {"C:/foo/bar/", `C:\FOO\BAR`}, 368 368 + {`C:\foo\bar`, `C:\FOO\BAR`}, 369 369 + {`C:\foo/bar\`, `C:\FOO\BAR`}, 370 370 + {"C:/ふー/バー", `C:\ふー\バー`}, 371 371 + } 372 372 + 373 373 + for _, test := range tests { 374 374 + got, err := filepath.ToNorm(test.arg, stubBase) 375 375 + if err != nil { 376 376 + t.Errorf("toNorm(%s) failed: %v\n", test.arg, err) 377 377 + } else if got != test.want { 378 378 + t.Errorf("toNorm(%s) returns %s, but %s expected\n", test.arg, got, test.want) 379 379 + } 380 380 + } 381 381 + 382 382 + testPath := `{{tmp}}\test\foo\bar` 383 383 + 384 384 + testsDir := []struct { 385 385 + wd string 386 386 + arg string 387 387 + want string 388 388 + }{ 389 389 + // test absolute paths 390 390 + {".", `{{tmp}}\test\foo\bar`, `{{tmp}}\test\foo\bar`}, 391 391 + {".", `{{tmp}}\.\test/foo\bar`, `{{tmp}}\test\foo\bar`}, 392 392 + {".", `{{tmp}}\test\..\test\foo\bar`, `{{tmp}}\test\foo\bar`}, 393 393 + {".", `{{tmp}}\TEST\FOO\BAR`, `{{tmp}}\test\foo\bar`}, 394 394 + 395 395 + // test relative paths begin with drive letter 396 396 + {`{{tmp}}\test`, `{{tmpvol}}.`, `{{tmpvol}}.`}, 397 397 + {`{{tmp}}\test`, `{{tmpvol}}..`, `{{tmpvol}}..`}, 398 398 + {`{{tmp}}\test`, `{{tmpvol}}foo\bar`, `{{tmpvol}}foo\bar`}, 399 399 + {`{{tmp}}\test`, `{{tmpvol}}.\foo\bar`, `{{tmpvol}}foo\bar`}, 400 400 + {`{{tmp}}\test`, `{{tmpvol}}foo\..\foo\bar`, `{{tmpvol}}foo\bar`}, 401 401 + {`{{tmp}}\test`, `{{tmpvol}}FOO\BAR`, `{{tmpvol}}foo\bar`}, 402 402 + 403 403 + // test relative paths begin with '\' 404 404 + {"{{tmp}}", `{{tmpnovol}}\test\foo\bar`, `{{tmpnovol}}\test\foo\bar`}, 405 405 + {"{{tmp}}", `{{tmpnovol}}\.\test\foo\bar`, `{{tmpnovol}}\test\foo\bar`}, 406 406 + {"{{tmp}}", `{{tmpnovol}}\test\..\test\foo\bar`, `{{tmpnovol}}\test\foo\bar`}, 407 407 + {"{{tmp}}", `{{tmpnovol}}\TEST\FOO\BAR`, `{{tmpnovol}}\test\foo\bar`}, 408 408 + 409 409 + // test relative paths begin without '\' 410 410 + {`{{tmp}}\test`, ".", `.`}, 411 411 + {`{{tmp}}\test`, "..", `..`}, 412 412 + {`{{tmp}}\test`, `foo\bar`, `foo\bar`}, 413 413 + {`{{tmp}}\test`, `.\foo\bar`, `foo\bar`}, 414 414 + {`{{tmp}}\test`, `foo\..\foo\bar`, `foo\bar`}, 415 415 + {`{{tmp}}\test`, `FOO\BAR`, `foo\bar`}, 416 416 + 417 417 + // test UNC paths 418 418 + {".", `\\localhost\c$`, `\\localhost\c$`}, 419 419 + } 420 420 + 421 421 + tmp, err := ioutil.TempDir("", "testToNorm") 422 422 + if err != nil { 423 423 + t.Fatal(err) 424 424 + } 425 425 + defer func() { 426 426 + err := os.RemoveAll(tmp) 427 427 + if err != nil { 428 428 + t.Fatal(err) 429 429 + } 430 430 + }() 431 431 + 432 432 + // ioutil.TempDir might return "non-canonical" name. 433 433 + ctmp, err := filepath.EvalSymlinks(tmp) 434 434 + if err != nil { 435 435 + t.Fatal(err) 436 436 + } 437 437 + 438 438 + err = os.MkdirAll(strings.ReplaceAll(testPath, "{{tmp}}", ctmp), 0777) 439 439 + if err != nil { 440 440 + t.Fatal(err) 441 441 + } 442 442 + 443 443 + cwd, err := os.Getwd() 444 444 + if err != nil { 445 445 + t.Fatal(err) 446 446 + } 447 447 + defer func() { 448 448 + err := os.Chdir(cwd) 449 449 + if err != nil { 450 450 + t.Fatal(err) 451 451 + } 452 452 + }() 453 453 + 454 454 + tmpVol := filepath.VolumeName(ctmp) 455 455 + if len(tmpVol) != 2 { 456 456 + t.Fatalf("unexpected temp volume name %q", tmpVol) 457 457 + } 458 458 + 459 459 + tmpNoVol := ctmp[len(tmpVol):] 460 460 + 461 461 + replacer := strings.NewReplacer("{{tmp}}", ctmp, "{{tmpvol}}", tmpVol, "{{tmpnovol}}", tmpNoVol) 462 462 + 463 463 + for _, test := range testsDir { 464 464 + wd := replacer.Replace(test.wd) 465 465 + arg := replacer.Replace(test.arg) 466 466 + want := replacer.Replace(test.want) 467 467 + 468 468 + if test.wd == "." { 469 469 + err := os.Chdir(cwd) 470 470 + if err != nil { 471 471 + t.Error(err) 472 472 + 473 473 + continue 474 474 + } 475 475 + } else { 476 476 + err := os.Chdir(wd) 477 477 + if err != nil { 478 478 + t.Error(err) 479 479 + 480 480 + continue 481 481 + } 482 482 + } 483 483 + 484 484 + got, err := filepath.ToNorm(arg, filepath.NormBase) 485 485 + if err != nil { 486 486 + t.Errorf("toNorm(%s) failed: %v (wd=%s)\n", arg, err, wd) 487 487 + } else if got != want { 488 488 + t.Errorf("toNorm(%s) returns %s, but %s expected (wd=%s)\n", arg, got, want, wd) 489 489 + } 490 490 + } 491 491 + } 492 492 + 493 493 + func TestUNC(t *testing.T) { 494 494 + // Test that this doesn't go into an infinite recursion. 495 495 + // See golang.org/issue/15879. 496 496 + defer debug.SetMaxStack(debug.SetMaxStack(1e6)) 497 497 + filepath.Glob(`\\?\c:\*`) 498 498 + } 499 499 + 500 500 + func testWalkMklink(t *testing.T, linktype string) { 501 501 + output, _ := exec.Command("cmd", "/c", "mklink", "/?").Output() 502 502 + if !strings.Contains(string(output), fmt.Sprintf(" /%s ", linktype)) { 503 503 + t.Skipf(`skipping test; mklink does not supports /%s parameter`, linktype) 504 504 + } 505 505 + testWalkSymlink(t, func(target, link string) error { 506 506 + output, err := exec.Command("cmd", "/c", "mklink", "/"+linktype, link, target).CombinedOutput() 507 507 + if err != nil { 508 508 + return fmt.Errorf(`"mklink /%s %v %v" command failed: %v\n%v`, linktype, link, target, err, string(output)) 509 509 + } 510 510 + return nil 511 511 + }) 512 512 + } 513 513 + 514 514 + func TestWalkDirectoryJunction(t *testing.T) { 515 515 + testenv.MustHaveSymlink(t) 516 516 + testWalkMklink(t, "J") 517 517 + } 518 518 + 519 519 + func TestWalkDirectorySymlink(t *testing.T) { 520 520 + testenv.MustHaveSymlink(t) 521 521 + testWalkMklink(t, "D") 522 522 + } 523 523 + 524 524 + func TestNTNamespaceSymlink(t *testing.T) { 525 525 + output, _ := exec.Command("cmd", "/c", "mklink", "/?").Output() 526 526 + if !strings.Contains(string(output), " /J ") { 527 527 + t.Skip("skipping test because mklink command does not support junctions") 528 528 + } 529 529 + 530 530 + tmpdir, err := ioutil.TempDir("", "TestNTNamespaceSymlink") 531 531 + if err != nil { 532 532 + t.Fatal(err) 533 533 + } 534 534 + defer os.RemoveAll(tmpdir) 535 535 + 536 536 + // Make sure tmpdir is not a symlink, otherwise tests will fail. 537 537 + tmpdir, err = filepath.EvalSymlinks(tmpdir) 538 538 + if err != nil { 539 539 + t.Fatal(err) 540 540 + } 541 541 + 542 542 + vol := filepath.VolumeName(tmpdir) 543 543 + output, err = exec.Command("cmd", "/c", "mountvol", vol, "/L").CombinedOutput() 544 544 + if err != nil { 545 545 + t.Fatalf("failed to run mountvol %v /L: %v %q", vol, err, output) 546 546 + } 547 547 + target := strings.Trim(string(output), " \n\r") 548 548 + 549 549 + dirlink := filepath.Join(tmpdir, "dirlink") 550 550 + output, err = exec.Command("cmd", "/c", "mklink", "/J", dirlink, target).CombinedOutput() 551 551 + if err != nil { 552 552 + t.Fatalf("failed to run mklink %v %v: %v %q", dirlink, target, err, output) 553 553 + } 554 554 + 555 555 + got, err := filepath.EvalSymlinks(dirlink) 556 556 + if err != nil { 557 557 + t.Fatal(err) 558 558 + } 559 559 + if want := vol + `\`; got != want { 560 560 + t.Errorf(`EvalSymlinks(%q): got %q, want %q`, dirlink, got, want) 561 561 + } 562 562 + 563 563 + // Make sure we have sufficient privilege to run mklink command. 564 564 + testenv.MustHaveSymlink(t) 565 565 + 566 566 + file := filepath.Join(tmpdir, "file") 567 567 + err = ioutil.WriteFile(file, []byte(""), 0666) 568 568 + if err != nil { 569 569 + t.Fatal(err) 570 570 + } 571 571 + 572 572 + target += file[len(filepath.VolumeName(file)):] 573 573 + 574 574 + filelink := filepath.Join(tmpdir, "filelink") 575 575 + output, err = exec.Command("cmd", "/c", "mklink", filelink, target).CombinedOutput() 576 576 + if err != nil { 577 577 + t.Fatalf("failed to run mklink %v %v: %v %q", filelink, target, err, output) 578 578 + } 579 579 + 580 580 + got, err = filepath.EvalSymlinks(filelink) 581 581 + if err != nil { 582 582 + t.Fatal(err) 583 583 + } 584 584 + if want := file; got != want { 585 585 + t.Errorf(`EvalSymlinks(%q): got %q, want %q`, filelink, got, want) 586 586 + } 587 587 + }

+147

pkg/path/testdata/symlink.go

reviewed

··· 1 1 + // Copyright 2012 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + import ( 8 8 + "errors" 9 9 + "io/fs" 10 10 + "os" 11 11 + "runtime" 12 12 + "syscall" 13 13 + ) 14 14 + 15 15 + func walkSymlinks(path string) (string, error) { 16 16 + volLen := volumeNameLen(path) 17 17 + pathSeparator := string(os.PathSeparator) 18 18 + 19 19 + if volLen < len(path) && os.IsPathSeparator(path[volLen]) { 20 20 + volLen++ 21 21 + } 22 22 + vol := path[:volLen] 23 23 + dest := vol 24 24 + linksWalked := 0 25 25 + for start, end := volLen, volLen; start < len(path); start = end { 26 26 + for start < len(path) && os.IsPathSeparator(path[start]) { 27 27 + start++ 28 28 + } 29 29 + end = start 30 30 + for end < len(path) && !os.IsPathSeparator(path[end]) { 31 31 + end++ 32 32 + } 33 33 + 34 34 + // On Windows, "." can be a symlink. 35 35 + // We look it up, and use the value if it is absolute. 36 36 + // If not, we just return ".". 37 37 + isWindowsDot := runtime.GOOS == "windows" && path[volumeNameLen(path):] == "." 38 38 + 39 39 + // The next path component is in path[start:end]. 40 40 + if end == start { 41 41 + // No more path components. 42 42 + break 43 43 + } else if path[start:end] == "." && !isWindowsDot { 44 44 + // Ignore path component ".". 45 45 + continue 46 46 + } else if path[start:end] == ".." { 47 47 + // Back up to previous component if possible. 48 48 + // Note that volLen includes any leading slash. 49 49 + 50 50 + // Set r to the index of the last slash in dest, 51 51 + // after the volume. 52 52 + var r int 53 53 + for r = len(dest) - 1; r >= volLen; r-- { 54 54 + if os.IsPathSeparator(dest[r]) { 55 55 + break 56 56 + } 57 57 + } 58 58 + if r < volLen || dest[r+1:] == ".." { 59 59 + // Either path has no slashes 60 60 + // (it's empty or just "C:") 61 61 + // or it ends in a ".." we had to keep. 62 62 + // Either way, keep this "..". 63 63 + if len(dest) > volLen { 64 64 + dest += pathSeparator 65 65 + } 66 66 + dest += ".." 67 67 + } else { 68 68 + // Discard everything since the last slash. 69 69 + dest = dest[:r] 70 70 + } 71 71 + continue 72 72 + } 73 73 + 74 74 + // Ordinary path component. Add it to result. 75 75 + 76 76 + if len(dest) > volumeNameLen(dest) && !os.IsPathSeparator(dest[len(dest)-1]) { 77 77 + dest += pathSeparator 78 78 + } 79 79 + 80 80 + dest += path[start:end] 81 81 + 82 82 + // Resolve symlink. 83 83 + 84 84 + fi, err := os.Lstat(dest) 85 85 + if err != nil { 86 86 + return "", err 87 87 + } 88 88 + 89 89 + if fi.Mode()&fs.ModeSymlink == 0 { 90 90 + if !fi.Mode().IsDir() && end < len(path) { 91 91 + return "", syscall.ENOTDIR 92 92 + } 93 93 + continue 94 94 + } 95 95 + 96 96 + // Found symlink. 97 97 + 98 98 + linksWalked++ 99 99 + if linksWalked > 255 { 100 100 + return "", errors.New("EvalSymlinks: too many links") 101 101 + } 102 102 + 103 103 + link, err := os.Readlink(dest) 104 104 + if err != nil { 105 105 + return "", err 106 106 + } 107 107 + 108 108 + if isWindowsDot && !IsAbs(link) { 109 109 + // On Windows, if "." is a relative symlink, 110 110 + // just return ".". 111 111 + break 112 112 + } 113 113 + 114 114 + path = link + path[end:] 115 115 + 116 116 + v := volumeNameLen(link) 117 117 + if v > 0 { 118 118 + // Symlink to drive name is an absolute path. 119 119 + if v < len(link) && os.IsPathSeparator(link[v]) { 120 120 + v++ 121 121 + } 122 122 + vol = link[:v] 123 123 + dest = vol 124 124 + end = len(vol) 125 125 + } else if len(link) > 0 && os.IsPathSeparator(link[0]) { 126 126 + // Symlink to absolute path. 127 127 + dest = link[:1] 128 128 + end = 1 129 129 + } else { 130 130 + // Symlink to relative path; replace last 131 131 + // path component in dest. 132 132 + var r int 133 133 + for r = len(dest) - 1; r >= volLen; r-- { 134 134 + if os.IsPathSeparator(dest[r]) { 135 135 + break 136 136 + } 137 137 + } 138 138 + if r < volLen { 139 139 + dest = vol 140 140 + } else { 141 141 + dest = dest[:r] 142 142 + } 143 143 + end = 0 144 144 + } 145 145 + } 146 146 + return Clean(dest), nil 147 147 + }

+7

pkg/path/testdata/symlink_unix.go

reviewed

··· 1 1 + // +build !windows 2 2 + 3 3 + package filepath 4 4 + 5 5 + func evalSymlinks(path string) (string, error) { 6 6 + return walkSymlinks(path) 7 7 + }

+119

pkg/path/testdata/symlink_windows.go

reviewed

··· 1 1 + // Copyright 2012 The Go Authors. All rights reserved. 2 2 + // Use of this source code is governed by a BSD-style 3 3 + // license that can be found in the LICENSE file. 4 4 + 5 5 + package filepath 6 6 + 7 7 + import ( 8 8 + "strings" 9 9 + "syscall" 10 10 + ) 11 11 + 12 12 + // normVolumeName is like VolumeName, but makes drive letter upper case. 13 13 + // result of EvalSymlinks must be unique, so we have 14 14 + // EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`). 15 15 + func normVolumeName(path string) string { 16 16 + volume := VolumeName(path) 17 17 + 18 18 + if len(volume) > 2 { // isUNC 19 19 + return volume 20 20 + } 21 21 + 22 22 + return strings.ToUpper(volume) 23 23 + } 24 24 + 25 25 + // normBase returns the last element of path with correct case. 26 26 + func normBase(path string) (string, error) { 27 27 + p, err := syscall.UTF16PtrFromString(path) 28 28 + if err != nil { 29 29 + return "", err 30 30 + } 31 31 + 32 32 + var data syscall.Win32finddata 33 33 + 34 34 + h, err := syscall.FindFirstFile(p, &data) 35 35 + if err != nil { 36 36 + return "", err 37 37 + } 38 38 + syscall.FindClose(h) 39 39 + 40 40 + return syscall.UTF16ToString(data.FileName[:]), nil 41 41 + } 42 42 + 43 43 + // baseIsDotDot reports whether the last element of path is "..". 44 44 + // The given path should be 'Clean'-ed in advance. 45 45 + func baseIsDotDot(path string) bool { 46 46 + i := strings.LastIndexByte(path, Separator) 47 47 + return path[i+1:] == ".." 48 48 + } 49 49 + 50 50 + // toNorm returns the normalized path that is guaranteed to be unique. 51 51 + // It should accept the following formats: 52 52 + // * UNC paths (e.g \\server\share\foo\bar) 53 53 + // * absolute paths (e.g C:\foo\bar) 54 54 + // * relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.) 55 55 + // * relative paths begin with '\' (e.g \foo\bar) 56 56 + // * relative paths begin without '\' (e.g foo\bar, ..\foo\bar, .., .) 57 57 + // The returned normalized path will be in the same form (of 5 listed above) as the input path. 58 58 + // If two paths A and B are indicating the same file with the same format, toNorm(A) should be equal to toNorm(B). 59 59 + // The normBase parameter should be equal to the normBase func, except for in tests. See docs on the normBase func. 60 60 + func toNorm(path string, normBase func(string) (string, error)) (string, error) { 61 61 + if path == "" { 62 62 + return path, nil 63 63 + } 64 64 + 65 65 + path = Clean(path) 66 66 + 67 67 + volume := normVolumeName(path) 68 68 + path = path[len(volume):] 69 69 + 70 70 + // skip special cases 71 71 + if path == "" || path == "." || path == `\` { 72 72 + return volume + path, nil 73 73 + } 74 74 + 75 75 + var normPath string 76 76 + 77 77 + for { 78 78 + if baseIsDotDot(path) { 79 79 + normPath = path + `\` + normPath 80 80 + 81 81 + break 82 82 + } 83 83 + 84 84 + name, err := normBase(volume + path) 85 85 + if err != nil { 86 86 + return "", err 87 87 + } 88 88 + 89 89 + normPath = name + `\` + normPath 90 90 + 91 91 + i := strings.LastIndexByte(path, Separator) 92 92 + if i == -1 { 93 93 + break 94 94 + } 95 95 + if i == 0 { // `\Go` or `C:\Go` 96 96 + normPath = `\` + normPath 97 97 + 98 98 + break 99 99 + } 100 100 + 101 101 + path = path[:i] 102 102 + } 103 103 + 104 104 + normPath = normPath[:len(normPath)-1] // remove trailing '\' 105 105 + 106 106 + return volume + normPath, nil 107 107 + } 108 108 + 109 109 + func evalSymlinks(path string) (string, error) { 110 110 + newpath, err := walkSymlinks(path) 111 111 + if err != nil { 112 112 + return "", err 113 113 + } 114 114 + newpath, err = toNorm(newpath, normBase) 115 115 + if err != nil { 116 116 + return "", err 117 117 + } 118 118 + return newpath, nil 119 119 + }