src/path/filepath/path_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package filepath_test
   6
   7 import (
   8         "errors"
   9         "fmt"
  10         "internal/testenv"
  11         "io/fs"
  12         "os"
  13         "path/filepath"
  14         "reflect"
  15         "runtime"
  16         "slices"
  17         "sort"
  18         "strings"
  19         "syscall"
  20         "testing"
  21 )
  22
  23 type PathTest struct {
  24         path, result string
  25 }
  26
  27 var cleantests = []PathTest{
  28         // Already clean
  29         {"abc", "abc"},
  30         {"abc/def", "abc/def"},
  31         {"a/b/c", "a/b/c"},
  32         {".", "."},
  33         {"..", ".."},
  34         {"../..", "../.."},
  35         {"../../abc", "../../abc"},
  36         {"/abc", "/abc"},
  37         {"/", "/"},
  38
  39         // Empty is current dir
  40         {"", "."},
  41
  42         // Remove trailing slash
  43         {"abc/", "abc"},
  44         {"abc/def/", "abc/def"},
  45         {"a/b/c/", "a/b/c"},
  46         {"./", "."},
  47         {"../", ".."},
  48         {"../../", "../.."},
  49         {"/abc/", "/abc"},
  50
  51         // Remove doubled slash
  52         {"abc//def//ghi", "abc/def/ghi"},
  53         {"abc//", "abc"},
  54
  55         // Remove . elements
  56         {"abc/./def", "abc/def"},
  57         {"/./abc/def", "/abc/def"},
  58         {"abc/.", "abc"},
  59
  60         // Remove .. elements
  61         {"abc/def/ghi/../jkl", "abc/def/jkl"},
  62         {"abc/def/../ghi/../jkl", "abc/jkl"},
  63         {"abc/def/..", "abc"},
  64         {"abc/def/../..", "."},
  65         {"/abc/def/../..", "/"},
  66         {"abc/def/../../..", ".."},
  67         {"/abc/def/../../..", "/"},
  68         {"abc/def/../../../ghi/jkl/../../../mno", "../../mno"},
  69         {"/../abc", "/abc"},
  70         {"a/../b:/../../c", `../c`},
  71
  72         // Combinations
  73         {"abc/./../def", "def"},
  74         {"abc//./../def", "def"},
  75         {"abc/../../././../def", "../../def"},
  76 }
  77
  78 var nonwincleantests = []PathTest{
  79         // Remove leading doubled slash
  80         {"//abc", "/abc"},
  81         {"///abc", "/abc"},
  82         {"//abc//", "/abc"},
  83 }
  84
  85 var wincleantests = []PathTest{
  86         {`c:`, `c:.`},
  87         {`c:\`, `c:\`},
  88         {`c:\abc`, `c:\abc`},
  89         {`c:abc\..\..\.\.\..\def`, `c:..\..\def`},
  90         {`c:\abc\def\..\..`, `c:\`},
  91         {`c:\..\abc`, `c:\abc`},
  92         {`c:..\abc`, `c:..\abc`},
  93         {`c:\b:\..\..\..\d`, `c:\d`},
  94         {`\`, `\`},
  95         {`/`, `\`},
  96         {`\\i\..\c$`, `\\i\..\c$`},
  97         {`\\i\..\i\c$`, `\\i\..\i\c$`},
  98         {`\\i\..\I\c$`, `\\i\..\I\c$`},
  99         {`\\host\share\foo\..\bar`, `\\host\share\bar`},
 100         {`//host/share/foo/../baz`, `\\host\share\baz`},
 101         {`\\host\share\foo\..\..\..\..\bar`, `\\host\share\bar`},
 102         {`\\.\C:\a\..\..\..\..\bar`, `\\.\C:\bar`},
 103         {`\\.\C:\\\\a`, `\\.\C:\a`},
 104         {`\\a\b\..\c`, `\\a\b\c`},
 105         {`\\a\b`, `\\a\b`},
 106         {`.\c:`, `.\c:`},
 107         {`.\c:\foo`, `.\c:\foo`},
 108         {`.\c:foo`, `.\c:foo`},
 109         {`//abc`, `\\abc`},
 110         {`///abc`, `\\\abc`},
 111         {`//abc//`, `\\abc\\`},
 112         {`\\?\C:\`, `\\?\C:\`},
 113         {`\\?\C:\a`, `\\?\C:\a`},
 114
 115         // Don't allow cleaning to move an element with a colon to the start of the path.
 116         {`a/../c:`, `.\c:`},
 117         {`a\..\c:`, `.\c:`},
 118         {`a/../c:/a`, `.\c:\a`},
 119         {`a/../../c:`, `..\c:`},
 120         {`foo:bar`, `foo:bar`},
 121
 122         // Don't allow cleaning to create a Root Local Device path like \??\a.
 123         {`/a/../??/a`, `\.\??\a`},
 124 }
 125
 126 func TestClean(t *testing.T) {
 127         tests := cleantests
 128         if runtime.GOOS == "windows" {
 129                 for i := range tests {
 130                         tests[i].result = filepath.FromSlash(tests[i].result)
 131                 }
 132                 tests = append(tests, wincleantests...)
 133         } else {
 134                 tests = append(tests, nonwincleantests...)
 135         }
 136         for _, test := range tests {
 137                 if s := filepath.Clean(test.path); s != test.result {
 138                         t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
 139                 }
 140                 if s := filepath.Clean(test.result); s != test.result {
 141                         t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
 142                 }
 143         }
 144
 145         if testing.Short() {
 146                 t.Skip("skipping malloc count in short mode")
 147         }
 148         if runtime.GOMAXPROCS(0) > 1 {
 149                 t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
 150                 return
 151         }
 152
 153         for _, test := range tests {
 154                 allocs := testing.AllocsPerRun(100, func() { filepath.Clean(test.result) })
 155                 if allocs > 0 {
 156                         t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs)
 157                 }
 158         }
 159 }
 160
 161 type IsLocalTest struct {
 162         path    string
 163         isLocal bool
 164 }
 165
 166 var islocaltests = []IsLocalTest{
 167         {"", false},
 168         {".", true},
 169         {"..", false},
 170         {"../a", false},
 171         {"/", false},
 172         {"/a", false},
 173         {"/a/../..", false},
 174         {"a", true},
 175         {"a/../a", true},
 176         {"a/", true},
 177         {"a/.", true},
 178         {"a/./b/./c", true},
 179         {`a/../b:/../../c`, false},
 180 }
 181
 182 var winislocaltests = []IsLocalTest{
 183         {"NUL", false},
 184         {"nul", false},
 185         {"nul ", false},
 186         {"nul.", false},
 187         {"a/nul:", false},
 188         {"a/nul : a", false},
 189         {"com0", true},
 190         {"com1", false},
 191         {"com2", false},
 192         {"com3", false},
 193         {"com4", false},
 194         {"com5", false},
 195         {"com6", false},
 196         {"com7", false},
 197         {"com8", false},
 198         {"com9", false},
 199         {"com¹", false},
 200         {"com²", false},
 201         {"com³", false},
 202         {"com¹ : a", false},
 203         {"cOm1", false},
 204         {"lpt1", false},
 205         {"LPT1", false},
 206         {"lpt³", false},
 207         {"./nul", false},
 208         {`\`, false},
 209         {`\a`, false},
 210         {`C:`, false},
 211         {`C:\a`, false},
 212         {`..\a`, false},
 213         {`a/../c:`, false},
 214         {`CONIN$`, false},
 215         {`conin$`, false},
 216         {`CONOUT$`, false},
 217         {`conout$`, false},
 218         {`dollar$`, true}, // not a special file name
 219 }
 220
 221 var plan9islocaltests = []IsLocalTest{
 222         {"#a", false},
 223 }
 224
 225 func TestIsLocal(t *testing.T) {
 226         tests := islocaltests
 227         if runtime.GOOS == "windows" {
 228                 tests = append(tests, winislocaltests...)
 229         }
 230         if runtime.GOOS == "plan9" {
 231                 tests = append(tests, plan9islocaltests...)
 232         }
 233         for _, test := range tests {
 234                 if got := filepath.IsLocal(test.path); got != test.isLocal {
 235                         t.Errorf("IsLocal(%q) = %v, want %v", test.path, got, test.isLocal)
 236                 }
 237         }
 238 }
 239
 240 const sep = filepath.Separator
 241
 242 var slashtests = []PathTest{
 243         {"", ""},
 244         {"/", string(sep)},
 245         {"/a/b", string([]byte{sep, 'a', sep, 'b'})},
 246         {"a//b", string([]byte{'a', sep, sep, 'b'})},
 247 }
 248
 249 func TestFromAndToSlash(t *testing.T) {
 250         for _, test := range slashtests {
 251                 if s := filepath.FromSlash(test.path); s != test.result {
 252                         t.Errorf("FromSlash(%q) = %q, want %q", test.path, s, test.result)
 253                 }
 254                 if s := filepath.ToSlash(test.result); s != test.path {
 255                         t.Errorf("ToSlash(%q) = %q, want %q", test.result, s, test.path)
 256                 }
 257         }
 258 }
 259
 260 type SplitListTest struct {
 261         list   string
 262         result []string
 263 }
 264
 265 const lsep = filepath.ListSeparator
 266
 267 var splitlisttests = []SplitListTest{
 268         {"", []string{}},
 269         {string([]byte{'a', lsep, 'b'}), []string{"a", "b"}},
 270         {string([]byte{lsep, 'a', lsep, 'b'}), []string{"", "a", "b"}},
 271 }
 272
 273 var winsplitlisttests = []SplitListTest{
 274         // quoted
 275         {`"a"`, []string{`a`}},
 276
 277         // semicolon
 278         {`";"`, []string{`;`}},
 279         {`"a;b"`, []string{`a;b`}},
 280         {`";";`, []string{`;`, ``}},
 281         {`;";"`, []string{``, `;`}},
 282
 283         // partially quoted
 284         {`a";"b`, []string{`a;b`}},
 285         {`a; ""b`, []string{`a`, ` b`}},
 286         {`"a;b`, []string{`a;b`}},
 287         {`""a;b`, []string{`a`, `b`}},
 288         {`"""a;b`, []string{`a;b`}},
 289         {`""""a;b`, []string{`a`, `b`}},
 290         {`a";b`, []string{`a;b`}},
 291         {`a;b";c`, []string{`a`, `b;c`}},
 292         {`"a";b";c`, []string{`a`, `b;c`}},
 293 }
 294
 295 func TestSplitList(t *testing.T) {
 296         tests := splitlisttests
 297         if runtime.GOOS == "windows" {
 298                 tests = append(tests, winsplitlisttests...)
 299         }
 300         for _, test := range tests {
 301                 if l := filepath.SplitList(test.list); !reflect.DeepEqual(l, test.result) {
 302                         t.Errorf("SplitList(%#q) = %#q, want %#q", test.list, l, test.result)
 303                 }
 304         }
 305 }
 306
 307 type SplitTest struct {
 308         path, dir, file string
 309 }
 310
 311 var unixsplittests = []SplitTest{
 312         {"a/b", "a/", "b"},
 313         {"a/b/", "a/b/", ""},
 314         {"a/", "a/", ""},
 315         {"a", "", "a"},
 316         {"/", "/", ""},
 317 }
 318
 319 var winsplittests = []SplitTest{
 320         {`c:`, `c:`, ``},
 321         {`c:/`, `c:/`, ``},
 322         {`c:/foo`, `c:/`, `foo`},
 323         {`c:/foo/bar`, `c:/foo/`, `bar`},
 324         {`//host/share`, `//host/share`, ``},
 325         {`//host/share/`, `//host/share/`, ``},
 326         {`//host/share/foo`, `//host/share/`, `foo`},
 327         {`\\host\share`, `\\host\share`, ``},
 328         {`\\host\share\`, `\\host\share\`, ``},
 329         {`\\host\share\foo`, `\\host\share\`, `foo`},
 330 }
 331
 332 func TestSplit(t *testing.T) {
 333         var splittests []SplitTest
 334         splittests = unixsplittests
 335         if runtime.GOOS == "windows" {
 336                 splittests = append(splittests, winsplittests...)
 337         }
 338         for _, test := range splittests {
 339                 if d, f := filepath.Split(test.path); d != test.dir || f != test.file {
 340                         t.Errorf("Split(%q) = %q, %q, want %q, %q", test.path, d, f, test.dir, test.file)
 341                 }
 342         }
 343 }
 344
 345 type JoinTest struct {
 346         elem []string
 347         path string
 348 }
 349
 350 var jointests = []JoinTest{
 351         // zero parameters
 352         {[]string{}, ""},
 353
 354         // one parameter
 355         {[]string{""}, ""},
 356         {[]string{"/"}, "/"},
 357         {[]string{"a"}, "a"},
 358
 359         // two parameters
 360         {[]string{"a", "b"}, "a/b"},
 361         {[]string{"a", ""}, "a"},
 362         {[]string{"", "b"}, "b"},
 363         {[]string{"/", "a"}, "/a"},
 364         {[]string{"/", "a/b"}, "/a/b"},
 365         {[]string{"/", ""}, "/"},
 366         {[]string{"/a", "b"}, "/a/b"},
 367         {[]string{"a", "/b"}, "a/b"},
 368         {[]string{"/a", "/b"}, "/a/b"},
 369         {[]string{"a/", "b"}, "a/b"},
 370         {[]string{"a/", ""}, "a"},
 371         {[]string{"", ""}, ""},
 372
 373         // three parameters
 374         {[]string{"/", "a", "b"}, "/a/b"},
 375 }
 376
 377 var nonwinjointests = []JoinTest{
 378         {[]string{"//", "a"}, "/a"},
 379 }
 380
 381 var winjointests = []JoinTest{
 382         {[]string{`directory`, `file`}, `directory\file`},
 383         {[]string{`C:\Windows\`, `System32`}, `C:\Windows\System32`},
 384         {[]string{`C:\Windows\`, ``}, `C:\Windows`},
 385         {[]string{`C:\`, `Windows`}, `C:\Windows`},
 386         {[]string{`C:`, `a`}, `C:a`},
 387         {[]string{`C:`, `a\b`}, `C:a\b`},
 388         {[]string{`C:`, `a`, `b`}, `C:a\b`},
 389         {[]string{`C:`, ``, `b`}, `C:b`},
 390         {[]string{`C:`, ``, ``, `b`}, `C:b`},
 391         {[]string{`C:`, ``}, `C:.`},
 392         {[]string{`C:`, ``, ``}, `C:.`},
 393         {[]string{`C:`, `\a`}, `C:\a`},
 394         {[]string{`C:`, ``, `\a`}, `C:\a`},
 395         {[]string{`C:.`, `a`}, `C:a`},
 396         {[]string{`C:a`, `b`}, `C:a\b`},
 397         {[]string{`C:a`, `b`, `d`}, `C:a\b\d`},
 398         {[]string{`\\host\share`, `foo`}, `\\host\share\foo`},
 399         {[]string{`\\host\share\foo`}, `\\host\share\foo`},
 400         {[]string{`//host/share`, `foo/bar`}, `\\host\share\foo\bar`},
 401         {[]string{`\`}, `\`},
 402         {[]string{`\`, ``}, `\`},
 403         {[]string{`\`, `a`}, `\a`},
 404         {[]string{`\\`, `a`}, `\\a`},
 405         {[]string{`\`, `a`, `b`}, `\a\b`},
 406         {[]string{`\\`, `a`, `b`}, `\\a\b`},
 407         {[]string{`\`, `\\a\b`, `c`}, `\a\b\c`},
 408         {[]string{`\\a`, `b`, `c`}, `\\a\b\c`},
 409         {[]string{`\\a\`, `b`, `c`}, `\\a\b\c`},
 410         {[]string{`//`, `a`}, `\\a`},
 411         {[]string{`a:\b\c`, `x\..\y:\..\..\z`}, `a:\b\z`},
 412         {[]string{`\`, `??\a`}, `\.\??\a`},
 413 }
 414
 415 func TestJoin(t *testing.T) {
 416         if runtime.GOOS == "windows" {
 417                 jointests = append(jointests, winjointests...)
 418         } else {
 419                 jointests = append(jointests, nonwinjointests...)
 420         }
 421         for _, test := range jointests {
 422                 expected := filepath.FromSlash(test.path)
 423                 if p := filepath.Join(test.elem...); p != expected {
 424                         t.Errorf("join(%q) = %q, want %q", test.elem, p, expected)
 425                 }
 426         }
 427 }
 428
 429 type ExtTest struct {
 430         path, ext string
 431 }
 432
 433 var exttests = []ExtTest{
 434         {"path.go", ".go"},
 435         {"path.pb.go", ".go"},
 436         {"a.dir/b", ""},
 437         {"a.dir/b.go", ".go"},
 438         {"a.dir/", ""},
 439 }
 440
 441 func TestExt(t *testing.T) {
 442         for _, test := range exttests {
 443                 if x := filepath.Ext(test.path); x != test.ext {
 444                         t.Errorf("Ext(%q) = %q, want %q", test.path, x, test.ext)
 445                 }
 446         }
 447 }
 448
 449 type Node struct {
 450         name    string
 451         entries []*Node // nil if the entry is a file
 452         mark    int
 453 }
 454
 455 var tree = &Node{
 456         "testdata",
 457         []*Node{
 458                 {"a", nil, 0},
 459                 {"b", []*Node{}, 0},
 460                 {"c", nil, 0},
 461                 {
 462                         "d",
 463                         []*Node{
 464                                 {"x", nil, 0},
 465                                 {"y", []*Node{}, 0},
 466                                 {
 467                                         "z",
 468                                         []*Node{
 469                                                 {"u", nil, 0},
 470                                                 {"v", nil, 0},
 471                                         },
 472                                         0,
 473                                 },
 474                         },
 475                         0,
 476                 },
 477         },
 478         0,
 479 }
 480
 481 func walkTree(n *Node, path string, f func(path string, n *Node)) {
 482         f(path, n)
 483         for _, e := range n.entries {
 484                 walkTree(e, filepath.Join(path, e.name), f)
 485         }
 486 }
 487
 488 func makeTree(t *testing.T) {
 489         walkTree(tree, tree.name, func(path string, n *Node) {
 490                 if n.entries == nil {
 491                         fd, err := os.Create(path)
 492                         if err != nil {
 493                                 t.Errorf("makeTree: %v", err)
 494                                 return
 495                         }
 496                         fd.Close()
 497                 } else {
 498                         os.Mkdir(path, 0770)
 499                 }
 500         })
 501 }
 502
 503 func markTree(n *Node) { walkTree(n, "", func(path string, n *Node) { n.mark++ }) }
 504
 505 func checkMarks(t *testing.T, report bool) {
 506         walkTree(tree, tree.name, func(path string, n *Node) {
 507                 if n.mark != 1 && report {
 508                         t.Errorf("node %s mark = %d; expected 1", path, n.mark)
 509                 }
 510                 n.mark = 0
 511         })
 512 }
 513
 514 // Assumes that each node name is unique. Good enough for a test.
 515 // If clear is true, any incoming error is cleared before return. The errors
 516 // are always accumulated, though.
 517 func mark(d fs.DirEntry, err error, errors *[]error, clear bool) error {
 518         name := d.Name()
 519         walkTree(tree, tree.name, func(path string, n *Node) {
 520                 if n.name == name {
 521                         n.mark++
 522                 }
 523         })
 524         if err != nil {
 525                 *errors = append(*errors, err)
 526                 if clear {
 527                         return nil
 528                 }
 529                 return err
 530         }
 531         return nil
 532 }
 533
 534 // chdir changes the current working directory to the named directory,
 535 // and then restore the original working directory at the end of the test.
 536 func chdir(t *testing.T, dir string) {
 537         olddir, err := os.Getwd()
 538         if err != nil {
 539                 t.Fatalf("getwd %s: %v", dir, err)
 540         }
 541         if err := os.Chdir(dir); err != nil {
 542                 t.Fatalf("chdir %s: %v", dir, err)
 543         }
 544
 545         t.Cleanup(func() {
 546                 if err := os.Chdir(olddir); err != nil {
 547                         t.Errorf("restore original working directory %s: %v", olddir, err)
 548                         os.Exit(1)
 549                 }
 550         })
 551 }
 552
 553 func chtmpdir(t *testing.T) (restore func()) {
 554         oldwd, err := os.Getwd()
 555         if err != nil {
 556                 t.Fatalf("chtmpdir: %v", err)
 557         }
 558         d, err := os.MkdirTemp("", "test")
 559         if err != nil {
 560                 t.Fatalf("chtmpdir: %v", err)
 561         }
 562         if err := os.Chdir(d); err != nil {
 563                 t.Fatalf("chtmpdir: %v", err)
 564         }
 565         return func() {
 566                 if err := os.Chdir(oldwd); err != nil {
 567                         t.Fatalf("chtmpdir: %v", err)
 568                 }
 569                 os.RemoveAll(d)
 570         }
 571 }
 572
 573 // tempDirCanonical returns a temporary directory for the test to use, ensuring
 574 // that the returned path does not contain symlinks.
 575 func tempDirCanonical(t *testing.T) string {
 576         dir := t.TempDir()
 577
 578         cdir, err := filepath.EvalSymlinks(dir)
 579         if err != nil {
 580                 t.Errorf("tempDirCanonical: %v", err)
 581         }
 582
 583         return cdir
 584 }
 585
 586 func TestWalk(t *testing.T) {
 587         walk := func(root string, fn fs.WalkDirFunc) error {
 588                 return filepath.Walk(root, func(path string, info fs.FileInfo, err error) error {
 589                         return fn(path, fs.FileInfoToDirEntry(info), err)
 590                 })
 591         }
 592         testWalk(t, walk, 1)
 593 }
 594
 595 func TestWalkDir(t *testing.T) {
 596         testWalk(t, filepath.WalkDir, 2)
 597 }
 598
 599 func testWalk(t *testing.T, walk func(string, fs.WalkDirFunc) error, errVisit int) {
 600         if runtime.GOOS == "ios" {
 601                 restore := chtmpdir(t)
 602                 defer restore()
 603         }
 604
 605         tmpDir := t.TempDir()
 606
 607         origDir, err := os.Getwd()
 608         if err != nil {
 609                 t.Fatal("finding working dir:", err)
 610         }
 611         if err = os.Chdir(tmpDir); err != nil {
 612                 t.Fatal("entering temp dir:", err)
 613         }
 614         defer os.Chdir(origDir)
 615
 616         makeTree(t)
 617         errors := make([]error, 0, 10)
 618         clear := true
 619         markFn := func(path string, d fs.DirEntry, err error) error {
 620                 return mark(d, err, &errors, clear)
 621         }
 622         // Expect no errors.
 623         err = walk(tree.name, markFn)
 624         if err != nil {
 625                 t.Fatalf("no error expected, found: %s", err)
 626         }
 627         if len(errors) != 0 {
 628                 t.Fatalf("unexpected errors: %s", errors)
 629         }
 630         checkMarks(t, true)
 631         errors = errors[0:0]
 632
 633         t.Run("PermErr", func(t *testing.T) {
 634                 // Test permission errors. Only possible if we're not root
 635                 // and only on some file systems (AFS, FAT).  To avoid errors during
 636                 // all.bash on those file systems, skip during go test -short.
 637                 // Chmod is not supported on wasip1.
 638                 if runtime.GOOS == "windows" || runtime.GOOS == "wasip1" {
 639                         t.Skip("skipping on " + runtime.GOOS)
 640                 }
 641                 if os.Getuid() == 0 {
 642                         t.Skip("skipping as root")
 643                 }
 644                 if testing.Short() {
 645                         t.Skip("skipping in short mode")
 646                 }
 647
 648                 // introduce 2 errors: chmod top-level directories to 0
 649                 os.Chmod(filepath.Join(tree.name, tree.entries[1].name), 0)
 650                 os.Chmod(filepath.Join(tree.name, tree.entries[3].name), 0)
 651
 652                 // 3) capture errors, expect two.
 653                 // mark respective subtrees manually
 654                 markTree(tree.entries[1])
 655                 markTree(tree.entries[3])
 656                 // correct double-marking of directory itself
 657                 tree.entries[1].mark -= errVisit
 658                 tree.entries[3].mark -= errVisit
 659                 err := walk(tree.name, markFn)
 660                 if err != nil {
 661                         t.Fatalf("expected no error return from Walk, got %s", err)
 662                 }
 663                 if len(errors) != 2 {
 664                         t.Errorf("expected 2 errors, got %d: %s", len(errors), errors)
 665                 }
 666                 // the inaccessible subtrees were marked manually
 667                 checkMarks(t, true)
 668                 errors = errors[0:0]
 669
 670                 // 4) capture errors, stop after first error.
 671                 // mark respective subtrees manually
 672                 markTree(tree.entries[1])
 673                 markTree(tree.entries[3])
 674                 // correct double-marking of directory itself
 675                 tree.entries[1].mark -= errVisit
 676                 tree.entries[3].mark -= errVisit
 677                 clear = false // error will stop processing
 678                 err = walk(tree.name, markFn)
 679                 if err == nil {
 680                         t.Fatalf("expected error return from Walk")
 681                 }
 682                 if len(errors) != 1 {
 683                         t.Errorf("expected 1 error, got %d: %s", len(errors), errors)
 684                 }
 685                 // the inaccessible subtrees were marked manually
 686                 checkMarks(t, false)
 687                 errors = errors[0:0]
 688
 689                 // restore permissions
 690                 os.Chmod(filepath.Join(tree.name, tree.entries[1].name), 0770)
 691                 os.Chmod(filepath.Join(tree.name, tree.entries[3].name), 0770)
 692         })
 693 }
 694
 695 func touch(t *testing.T, name string) {
 696         f, err := os.Create(name)
 697         if err != nil {
 698                 t.Fatal(err)
 699         }
 700         if err := f.Close(); err != nil {
 701                 t.Fatal(err)
 702         }
 703 }
 704
 705 func TestWalkSkipDirOnFile(t *testing.T) {
 706         td := t.TempDir()
 707
 708         if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil {
 709                 t.Fatal(err)
 710         }
 711         touch(t, filepath.Join(td, "dir/foo1"))
 712         touch(t, filepath.Join(td, "dir/foo2"))
 713
 714         sawFoo2 := false
 715         walker := func(path string) error {
 716                 if strings.HasSuffix(path, "foo2") {
 717                         sawFoo2 = true
 718                 }
 719                 if strings.HasSuffix(path, "foo1") {
 720                         return filepath.SkipDir
 721                 }
 722                 return nil
 723         }
 724         walkFn := func(path string, _ fs.FileInfo, _ error) error { return walker(path) }
 725         walkDirFn := func(path string, _ fs.DirEntry, _ error) error { return walker(path) }
 726
 727         check := func(t *testing.T, walk func(root string) error, root string) {
 728                 t.Helper()
 729                 sawFoo2 = false
 730                 err := walk(root)
 731                 if err != nil {
 732                         t.Fatal(err)
 733                 }
 734                 if sawFoo2 {
 735                         t.Errorf("SkipDir on file foo1 did not block processing of foo2")
 736                 }
 737         }
 738
 739         t.Run("Walk", func(t *testing.T) {
 740                 Walk := func(root string) error { return filepath.Walk(td, walkFn) }
 741                 check(t, Walk, td)
 742                 check(t, Walk, filepath.Join(td, "dir"))
 743         })
 744         t.Run("WalkDir", func(t *testing.T) {
 745                 WalkDir := func(root string) error { return filepath.WalkDir(td, walkDirFn) }
 746                 check(t, WalkDir, td)
 747                 check(t, WalkDir, filepath.Join(td, "dir"))
 748         })
 749 }
 750
 751 func TestWalkSkipAllOnFile(t *testing.T) {
 752         td := t.TempDir()
 753
 754         if err := os.MkdirAll(filepath.Join(td, "dir", "subdir"), 0755); err != nil {
 755                 t.Fatal(err)
 756         }
 757         if err := os.MkdirAll(filepath.Join(td, "dir2"), 0755); err != nil {
 758                 t.Fatal(err)
 759         }
 760
 761         touch(t, filepath.Join(td, "dir", "foo1"))
 762         touch(t, filepath.Join(td, "dir", "foo2"))
 763         touch(t, filepath.Join(td, "dir", "subdir", "foo3"))
 764         touch(t, filepath.Join(td, "dir", "foo4"))
 765         touch(t, filepath.Join(td, "dir2", "bar"))
 766         touch(t, filepath.Join(td, "last"))
 767
 768         remainingWereSkipped := true
 769         walker := func(path string) error {
 770                 if strings.HasSuffix(path, "foo2") {
 771                         return filepath.SkipAll
 772                 }
 773
 774                 if strings.HasSuffix(path, "foo3") ||
 775                         strings.HasSuffix(path, "foo4") ||
 776                         strings.HasSuffix(path, "bar") ||
 777                         strings.HasSuffix(path, "last") {
 778                         remainingWereSkipped = false
 779                 }
 780                 return nil
 781         }
 782
 783         walkFn := func(path string, _ fs.FileInfo, _ error) error { return walker(path) }
 784         walkDirFn := func(path string, _ fs.DirEntry, _ error) error { return walker(path) }
 785
 786         check := func(t *testing.T, walk func(root string) error, root string) {
 787                 t.Helper()
 788                 remainingWereSkipped = true
 789                 if err := walk(root); err != nil {
 790                         t.Fatal(err)
 791                 }
 792                 if !remainingWereSkipped {
 793                         t.Errorf("SkipAll on file foo2 did not block processing of remaining files and directories")
 794                 }
 795         }
 796
 797         t.Run("Walk", func(t *testing.T) {
 798                 Walk := func(_ string) error { return filepath.Walk(td, walkFn) }
 799                 check(t, Walk, td)
 800                 check(t, Walk, filepath.Join(td, "dir"))
 801         })
 802         t.Run("WalkDir", func(t *testing.T) {
 803                 WalkDir := func(_ string) error { return filepath.WalkDir(td, walkDirFn) }
 804                 check(t, WalkDir, td)
 805                 check(t, WalkDir, filepath.Join(td, "dir"))
 806         })
 807 }
 808
 809 func TestWalkFileError(t *testing.T) {
 810         td := t.TempDir()
 811
 812         touch(t, filepath.Join(td, "foo"))
 813         touch(t, filepath.Join(td, "bar"))
 814         dir := filepath.Join(td, "dir")
 815         if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil {
 816                 t.Fatal(err)
 817         }
 818         touch(t, filepath.Join(dir, "baz"))
 819         touch(t, filepath.Join(dir, "stat-error"))
 820         defer func() {
 821                 *filepath.LstatP = os.Lstat
 822         }()
 823         statErr := errors.New("some stat error")
 824         *filepath.LstatP = func(path string) (fs.FileInfo, error) {
 825                 if strings.HasSuffix(path, "stat-error") {
 826                         return nil, statErr
 827                 }
 828                 return os.Lstat(path)
 829         }
 830         got := map[string]error{}
 831         err := filepath.Walk(td, func(path string, fi fs.FileInfo, err error) error {
 832                 rel, _ := filepath.Rel(td, path)
 833                 got[filepath.ToSlash(rel)] = err
 834                 return nil
 835         })
 836         if err != nil {
 837                 t.Errorf("Walk error: %v", err)
 838         }
 839         want := map[string]error{
 840                 ".":              nil,
 841                 "foo":            nil,
 842                 "bar":            nil,
 843                 "dir":            nil,
 844                 "dir/baz":        nil,
 845                 "dir/stat-error": statErr,
 846         }
 847         if !reflect.DeepEqual(got, want) {
 848                 t.Errorf("Walked %#v; want %#v", got, want)
 849         }
 850 }
 851
 852 func TestWalkSymlinkRoot(t *testing.T) {
 853         testenv.MustHaveSymlink(t)
 854
 855         td := t.TempDir()
 856         dir := filepath.Join(td, "dir")
 857         if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil {
 858                 t.Fatal(err)
 859         }
 860         touch(t, filepath.Join(dir, "foo"))
 861
 862         link := filepath.Join(td, "link")
 863         if err := os.Symlink("dir", link); err != nil {
 864                 t.Fatal(err)
 865         }
 866
 867         abslink := filepath.Join(td, "abslink")
 868         if err := os.Symlink(dir, abslink); err != nil {
 869                 t.Fatal(err)
 870         }
 871
 872         linklink := filepath.Join(td, "linklink")
 873         if err := os.Symlink("link", linklink); err != nil {
 874                 t.Fatal(err)
 875         }
 876
 877         // Per https://pubs.opengroup.org/onlinepubs/9699919799.2013edition/basedefs/V1_chap04.html#tag_04_12:
 878         // “A pathname that contains at least one non- <slash> character and that ends
 879         // with one or more trailing <slash> characters shall not be resolved
 880         // successfully unless the last pathname component before the trailing <slash>
 881         // characters names an existing directory [...].”
 882         //
 883         // Since Walk does not traverse symlinks itself, its behavior should depend on
 884         // whether the path passed to Walk ends in a slash: if it does not end in a slash,
 885         // Walk should report the symlink itself (since it is the last pathname component);
 886         // but if it does end in a slash, Walk should walk the directory to which the symlink
 887         // refers (since it must be fully resolved before walking).
 888         for _, tt := range []struct {
 889                 desc      string
 890                 root      string
 891                 want      []string
 892                 buggyGOOS []string
 893         }{
 894                 {
 895                         desc: "no slash",
 896                         root: link,
 897                         want: []string{link},
 898                 },
 899                 {
 900                         desc: "slash",
 901                         root: link + string(filepath.Separator),
 902                         want: []string{link, filepath.Join(link, "foo")},
 903                 },
 904                 {
 905                         desc: "abs no slash",
 906                         root: abslink,
 907                         want: []string{abslink},
 908                 },
 909                 {
 910                         desc: "abs with slash",
 911                         root: abslink + string(filepath.Separator),
 912                         want: []string{abslink, filepath.Join(abslink, "foo")},
 913                 },
 914                 {
 915                         desc: "double link no slash",
 916                         root: linklink,
 917                         want: []string{linklink},
 918                 },
 919                 {
 920                         desc:      "double link with slash",
 921                         root:      linklink + string(filepath.Separator),
 922                         want:      []string{linklink, filepath.Join(linklink, "foo")},
 923                         buggyGOOS: []string{"darwin", "ios"}, // https://go.dev/issue/59586
 924                 },
 925         } {
 926                 tt := tt
 927                 t.Run(tt.desc, func(t *testing.T) {
 928                         var walked []string
 929                         err := filepath.Walk(tt.root, func(path string, info fs.FileInfo, err error) error {
 930                                 if err != nil {
 931                                         return err
 932                                 }
 933                                 t.Logf("%#q: %v", path, info.Mode())
 934                                 walked = append(walked, filepath.Clean(path))
 935                                 return nil
 936                         })
 937                         if err != nil {
 938                                 t.Fatal(err)
 939                         }
 940
 941                         if !reflect.DeepEqual(walked, tt.want) {
 942                                 t.Logf("Walk(%#q) visited %#q; want %#q", tt.root, walked, tt.want)
 943                                 if slices.Contains(tt.buggyGOOS, runtime.GOOS) {
 944                                         t.Logf("(ignoring known bug on %v)", runtime.GOOS)
 945                                 } else {
 946                                         t.Fail()
 947                                 }
 948                         }
 949                 })
 950         }
 951 }
 952
 953 var basetests = []PathTest{
 954         {"", "."},
 955         {".", "."},
 956         {"/.", "."},
 957         {"/", "/"},
 958         {"////", "/"},
 959         {"x/", "x"},
 960         {"abc", "abc"},
 961         {"abc/def", "def"},
 962         {"a/b/.x", ".x"},
 963         {"a/b/c.", "c."},
 964         {"a/b/c.x", "c.x"},
 965 }
 966
 967 var winbasetests = []PathTest{
 968         {`c:\`, `\`},
 969         {`c:.`, `.`},
 970         {`c:\a\b`, `b`},
 971         {`c:a\b`, `b`},
 972         {`c:a\b\c`, `c`},
 973         {`\\host\share\`, `\`},
 974         {`\\host\share\a`, `a`},
 975         {`\\host\share\a\b`, `b`},
 976 }
 977
 978 func TestBase(t *testing.T) {
 979         tests := basetests
 980         if runtime.GOOS == "windows" {
 981                 // make unix tests work on windows
 982                 for i := range tests {
 983                         tests[i].result = filepath.Clean(tests[i].result)
 984                 }
 985                 // add windows specific tests
 986                 tests = append(tests, winbasetests...)
 987         }
 988         for _, test := range tests {
 989                 if s := filepath.Base(test.path); s != test.result {
 990                         t.Errorf("Base(%q) = %q, want %q", test.path, s, test.result)
 991                 }
 992         }
 993 }
 994
 995 var dirtests = []PathTest{
 996         {"", "."},
 997         {".", "."},
 998         {"/.", "/"},
 999         {"/", "/"},
1000         {"/foo", "/"},
1001         {"x/", "x"},
1002         {"abc", "."},
1003         {"abc/def", "abc"},
1004         {"a/b/.x", "a/b"},
1005         {"a/b/c.", "a/b"},
1006         {"a/b/c.x", "a/b"},
1007 }
1008
1009 var nonwindirtests = []PathTest{
1010         {"////", "/"},
1011 }
1012
1013 var windirtests = []PathTest{
1014         {`c:\`, `c:\`},
1015         {`c:.`, `c:.`},
1016         {`c:\a\b`, `c:\a`},
1017         {`c:a\b`, `c:a`},
1018         {`c:a\b\c`, `c:a\b`},
1019         {`\\host\share`, `\\host\share`},
1020         {`\\host\share\`, `\\host\share\`},
1021         {`\\host\share\a`, `\\host\share\`},
1022         {`\\host\share\a\b`, `\\host\share\a`},
1023         {`\\\\`, `\\\\`},
1024 }
1025
1026 func TestDir(t *testing.T) {
1027         tests := dirtests
1028         if runtime.GOOS == "windows" {
1029                 // make unix tests work on windows
1030                 for i := range tests {
1031                         tests[i].result = filepath.Clean(tests[i].result)
1032                 }
1033                 // add windows specific tests
1034                 tests = append(tests, windirtests...)
1035         } else {
1036                 tests = append(tests, nonwindirtests...)
1037         }
1038         for _, test := range tests {
1039                 if s := filepath.Dir(test.path); s != test.result {
1040                         t.Errorf("Dir(%q) = %q, want %q", test.path, s, test.result)
1041                 }
1042         }
1043 }
1044
1045 type IsAbsTest struct {
1046         path  string
1047         isAbs bool
1048 }
1049
1050 var isabstests = []IsAbsTest{
1051         {"", false},
1052         {"/", true},
1053         {"/usr/bin/gcc", true},
1054         {"..", false},
1055         {"/a/../bb", true},
1056         {".", false},
1057         {"./", false},
1058         {"lala", false},
1059 }
1060
1061 var winisabstests = []IsAbsTest{
1062         {`C:\`, true},
1063         {`c\`, false},
1064         {`c::`, false},
1065         {`c:`, false},
1066         {`/`, false},
1067         {`\`, false},
1068         {`\Windows`, false},
1069         {`c:a\b`, false},
1070         {`c:\a\b`, true},
1071         {`c:/a/b`, true},
1072         {`\\host\share`, true},
1073         {`\\host\share\`, true},
1074         {`\\host\share\foo`, true},
1075         {`//host/share/foo/bar`, true},
1076         {`\\?\a\b\c`, true},
1077         {`\??\a\b\c`, true},
1078 }
1079
1080 func TestIsAbs(t *testing.T) {
1081         var tests []IsAbsTest
1082         if runtime.GOOS == "windows" {
1083                 tests = append(tests, winisabstests...)
1084                 // All non-windows tests should fail, because they have no volume letter.
1085                 for _, test := range isabstests {
1086                         tests = append(tests, IsAbsTest{test.path, false})
1087                 }
1088                 // All non-windows test should work as intended if prefixed with volume letter.
1089                 for _, test := range isabstests {
1090                         tests = append(tests, IsAbsTest{"c:" + test.path, test.isAbs})
1091                 }
1092         } else {
1093                 tests = isabstests
1094         }
1095
1096         for _, test := range tests {
1097                 if r := filepath.IsAbs(test.path); r != test.isAbs {
1098                         t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs)
1099                 }
1100         }
1101 }
1102
1103 type EvalSymlinksTest struct {
1104         // If dest is empty, the path is created; otherwise the dest is symlinked to the path.
1105         path, dest string
1106 }
1107
1108 var EvalSymlinksTestDirs = []EvalSymlinksTest{
1109         {"test", ""},
1110         {"test/dir", ""},
1111         {"test/dir/link3", "../../"},
1112         {"test/link1", "../test"},
1113         {"test/link2", "dir"},
1114         {"test/linkabs", "/"},
1115         {"test/link4", "../test2"},
1116         {"test2", "test/dir"},
1117         // Issue 23444.
1118         {"src", ""},
1119         {"src/pool", ""},
1120         {"src/pool/test", ""},
1121         {"src/versions", ""},
1122         {"src/versions/current", "../../version"},
1123         {"src/versions/v1", ""},
1124         {"src/versions/v1/modules", ""},
1125         {"src/versions/v1/modules/test", "../../../pool/test"},
1126         {"version", "src/versions/v1"},
1127 }
1128
1129 var EvalSymlinksTests = []EvalSymlinksTest{
1130         {"test", "test"},
1131         {"test/dir", "test/dir"},
1132         {"test/dir/../..", "."},
1133         {"test/link1", "test"},
1134         {"test/link2", "test/dir"},
1135         {"test/link1/dir", "test/dir"},
1136         {"test/link2/..", "test"},
1137         {"test/dir/link3", "."},
1138         {"test/link2/link3/test", "test"},
1139         {"test/linkabs", "/"},
1140         {"test/link4/..", "test"},
1141         {"src/versions/current/modules/test", "src/pool/test"},
1142 }
1143
1144 // simpleJoin builds a file name from the directory and path.
1145 // It does not use Join because we don't want ".." to be evaluated.
1146 func simpleJoin(dir, path string) string {
1147         return dir + string(filepath.Separator) + path
1148 }
1149
1150 func testEvalSymlinks(t *testing.T, path, want string) {
1151         have, err := filepath.EvalSymlinks(path)
1152         if err != nil {
1153                 t.Errorf("EvalSymlinks(%q) error: %v", path, err)
1154                 return
1155         }
1156         if filepath.Clean(have) != filepath.Clean(want) {
1157                 t.Errorf("EvalSymlinks(%q) returns %q, want %q", path, have, want)
1158         }
1159 }
1160
1161 func testEvalSymlinksAfterChdir(t *testing.T, wd, path, want string) {
1162         cwd, err := os.Getwd()
1163         if err != nil {
1164                 t.Fatal(err)
1165         }
1166         defer func() {
1167                 err := os.Chdir(cwd)
1168                 if err != nil {
1169                         t.Fatal(err)
1170                 }
1171         }()
1172
1173         err = os.Chdir(wd)
1174         if err != nil {
1175                 t.Fatal(err)
1176         }
1177
1178         have, err := filepath.EvalSymlinks(path)
1179         if err != nil {
1180                 t.Errorf("EvalSymlinks(%q) in %q directory error: %v", path, wd, err)
1181                 return
1182         }
1183         if filepath.Clean(have) != filepath.Clean(want) {
1184                 t.Errorf("EvalSymlinks(%q) in %q directory returns %q, want %q", path, wd, have, want)
1185         }
1186 }
1187
1188 func TestEvalSymlinks(t *testing.T) {
1189         testenv.MustHaveSymlink(t)
1190
1191         tmpDir := t.TempDir()
1192
1193         // /tmp may itself be a symlink! Avoid the confusion, although
1194         // it means trusting the thing we're testing.
1195         var err error
1196         tmpDir, err = filepath.EvalSymlinks(tmpDir)
1197         if err != nil {
1198                 t.Fatal("eval symlink for tmp dir:", err)
1199         }
1200
1201         // Create the symlink farm using relative paths.
1202         for _, d := range EvalSymlinksTestDirs {
1203                 var err error
1204                 path := simpleJoin(tmpDir, d.path)
1205                 if d.dest == "" {
1206                         err = os.Mkdir(path, 0755)
1207                 } else {
1208                         err = os.Symlink(d.dest, path)
1209                 }
1210                 if err != nil {
1211                         t.Fatal(err)
1212                 }
1213         }
1214
1215         // Evaluate the symlink farm.
1216         for _, test := range EvalSymlinksTests {
1217                 path := simpleJoin(tmpDir, test.path)
1218
1219                 dest := simpleJoin(tmpDir, test.dest)
1220                 if filepath.IsAbs(test.dest) || os.IsPathSeparator(test.dest[0]) {
1221                         dest = test.dest
1222                 }
1223                 testEvalSymlinks(t, path, dest)
1224
1225                 // test EvalSymlinks(".")
1226                 testEvalSymlinksAfterChdir(t, path, ".", ".")
1227
1228                 // test EvalSymlinks("C:.") on Windows
1229                 if runtime.GOOS == "windows" {
1230                         volDot := filepath.VolumeName(tmpDir) + "."
1231                         testEvalSymlinksAfterChdir(t, path, volDot, volDot)
1232                 }
1233
1234                 // test EvalSymlinks(".."+path)
1235                 dotdotPath := simpleJoin("..", test.dest)
1236                 if filepath.IsAbs(test.dest) || os.IsPathSeparator(test.dest[0]) {
1237                         dotdotPath = test.dest
1238                 }
1239                 testEvalSymlinksAfterChdir(t,
1240                         simpleJoin(tmpDir, "test"),
1241                         simpleJoin("..", test.path),
1242                         dotdotPath)
1243
1244                 // test EvalSymlinks(p) where p is relative path
1245                 testEvalSymlinksAfterChdir(t, tmpDir, test.path, test.dest)
1246         }
1247 }
1248
1249 func TestEvalSymlinksIsNotExist(t *testing.T) {
1250         testenv.MustHaveSymlink(t)
1251
1252         defer chtmpdir(t)()
1253
1254         _, err := filepath.EvalSymlinks("notexist")
1255         if !os.IsNotExist(err) {
1256                 t.Errorf("expected the file is not found, got %v\n", err)
1257         }
1258
1259         err = os.Symlink("notexist", "link")
1260         if err != nil {
1261                 t.Fatal(err)
1262         }
1263         defer os.Remove("link")
1264
1265         _, err = filepath.EvalSymlinks("link")
1266         if !os.IsNotExist(err) {
1267                 t.Errorf("expected the file is not found, got %v\n", err)
1268         }
1269 }
1270
1271 func TestIssue13582(t *testing.T) {
1272         testenv.MustHaveSymlink(t)
1273
1274         tmpDir := t.TempDir()
1275
1276         dir := filepath.Join(tmpDir, "dir")
1277         err := os.Mkdir(dir, 0755)
1278         if err != nil {
1279                 t.Fatal(err)
1280         }
1281         linkToDir := filepath.Join(tmpDir, "link_to_dir")
1282         err = os.Symlink(dir, linkToDir)
1283         if err != nil {
1284                 t.Fatal(err)
1285         }
1286         file := filepath.Join(linkToDir, "file")
1287         err = os.WriteFile(file, nil, 0644)
1288         if err != nil {
1289                 t.Fatal(err)
1290         }
1291         link1 := filepath.Join(linkToDir, "link1")
1292         err = os.Symlink(file, link1)
1293         if err != nil {
1294                 t.Fatal(err)
1295         }
1296         link2 := filepath.Join(linkToDir, "link2")
1297         err = os.Symlink(link1, link2)
1298         if err != nil {
1299                 t.Fatal(err)
1300         }
1301
1302         // /tmp may itself be a symlink!
1303         realTmpDir, err := filepath.EvalSymlinks(tmpDir)
1304         if err != nil {
1305                 t.Fatal(err)
1306         }
1307         realDir := filepath.Join(realTmpDir, "dir")
1308         realFile := filepath.Join(realDir, "file")
1309
1310         tests := []struct {
1311                 path, want string
1312         }{
1313                 {dir, realDir},
1314                 {linkToDir, realDir},
1315                 {file, realFile},
1316                 {link1, realFile},
1317                 {link2, realFile},
1318         }
1319         for i, test := range tests {
1320                 have, err := filepath.EvalSymlinks(test.path)
1321                 if err != nil {
1322                         t.Fatal(err)
1323                 }
1324                 if have != test.want {
1325                         t.Errorf("test#%d: EvalSymlinks(%q) returns %q, want %q", i, test.path, have, test.want)
1326                 }
1327         }
1328 }
1329
1330 // Issue 57905.
1331 func TestRelativeSymlinkToAbsolute(t *testing.T) {
1332         testenv.MustHaveSymlink(t)
1333         // Not parallel: uses os.Chdir.
1334
1335         tmpDir := t.TempDir()
1336         chdir(t, tmpDir)
1337
1338         // Create "link" in the current working directory as a symlink to an arbitrary
1339         // absolute path. On macOS, this path is likely to begin with a symlink
1340         // itself: generally either in /var (symlinked to "private/var") or /tmp
1341         // (symlinked to "private/tmp").
1342         if err := os.Symlink(tmpDir, "link"); err != nil {
1343                 t.Fatal(err)
1344         }
1345         t.Logf(`os.Symlink(%q, "link")`, tmpDir)
1346
1347         p, err := filepath.EvalSymlinks("link")
1348         if err != nil {
1349                 t.Fatalf(`EvalSymlinks("link"): %v`, err)
1350         }
1351         want, err := filepath.EvalSymlinks(tmpDir)
1352         if err != nil {
1353                 t.Fatalf(`EvalSymlinks(%q): %v`, tmpDir, err)
1354         }
1355         if p != want {
1356                 t.Errorf(`EvalSymlinks("link") = %q; want %q`, p, want)
1357         }
1358         t.Logf(`EvalSymlinks("link") = %q`, p)
1359 }
1360
1361 // Test directories relative to temporary directory.
1362 // The tests are run in absTestDirs[0].
1363 var absTestDirs = []string{
1364         "a",
1365         "a/b",
1366         "a/b/c",
1367 }
1368
1369 // Test paths relative to temporary directory. $ expands to the directory.
1370 // The tests are run in absTestDirs[0].
1371 // We create absTestDirs first.
1372 var absTests = []string{
1373         ".",
1374         "b",
1375         "b/",
1376         "../a",
1377         "../a/b",
1378         "../a/b/./c/../../.././a",
1379         "../a/b/./c/../../.././a/",
1380         "$",
1381         "$/.",
1382         "$/a/../a/b",
1383         "$/a/b/c/../../.././a",
1384         "$/a/b/c/../../.././a/",
1385 }
1386
1387 func TestAbs(t *testing.T) {
1388         root := t.TempDir()
1389         wd, err := os.Getwd()
1390         if err != nil {
1391                 t.Fatal("getwd failed: ", err)
1392         }
1393         err = os.Chdir(root)
1394         if err != nil {
1395                 t.Fatal("chdir failed: ", err)
1396         }
1397         defer os.Chdir(wd)
1398
1399         for _, dir := range absTestDirs {
1400                 err = os.Mkdir(dir, 0777)
1401                 if err != nil {
1402                         t.Fatal("Mkdir failed: ", err)
1403                 }
1404         }
1405
1406         if runtime.GOOS == "windows" {
1407                 vol := filepath.VolumeName(root)
1408                 var extra []string
1409                 for _, path := range absTests {
1410                         if strings.Contains(path, "$") {
1411                                 continue
1412                         }
1413                         path = vol + path
1414                         extra = append(extra, path)
1415                 }
1416                 absTests = append(absTests, extra...)
1417         }
1418
1419         err = os.Chdir(absTestDirs[0])
1420         if err != nil {
1421                 t.Fatal("chdir failed: ", err)
1422         }
1423
1424         for _, path := range absTests {
1425                 path = strings.ReplaceAll(path, "$", root)
1426                 info, err := os.Stat(path)
1427                 if err != nil {
1428                         t.Errorf("%s: %s", path, err)
1429                         continue
1430                 }
1431
1432                 abspath, err := filepath.Abs(path)
1433                 if err != nil {
1434                         t.Errorf("Abs(%q) error: %v", path, err)
1435                         continue
1436                 }
1437                 absinfo, err := os.Stat(abspath)
1438                 if err != nil || !os.SameFile(absinfo, info) {
1439                         t.Errorf("Abs(%q)=%q, not the same file", path, abspath)
1440                 }
1441                 if !filepath.IsAbs(abspath) {
1442                         t.Errorf("Abs(%q)=%q, not an absolute path", path, abspath)
1443                 }
1444                 if filepath.IsAbs(abspath) && abspath != filepath.Clean(abspath) {
1445                         t.Errorf("Abs(%q)=%q, isn't clean", path, abspath)
1446                 }
1447         }
1448 }
1449
1450 // Empty path needs to be special-cased on Windows. See golang.org/issue/24441.
1451 // We test it separately from all other absTests because the empty string is not
1452 // a valid path, so it can't be used with os.Stat.
1453 func TestAbsEmptyString(t *testing.T) {
1454         root := t.TempDir()
1455
1456         wd, err := os.Getwd()
1457         if err != nil {
1458                 t.Fatal("getwd failed: ", err)
1459         }
1460         err = os.Chdir(root)
1461         if err != nil {
1462                 t.Fatal("chdir failed: ", err)
1463         }
1464         defer os.Chdir(wd)
1465
1466         info, err := os.Stat(root)
1467         if err != nil {
1468                 t.Fatalf("%s: %s", root, err)
1469         }
1470
1471         abspath, err := filepath.Abs("")
1472         if err != nil {
1473                 t.Fatalf(`Abs("") error: %v`, err)
1474         }
1475         absinfo, err := os.Stat(abspath)
1476         if err != nil || !os.SameFile(absinfo, info) {
1477                 t.Errorf(`Abs("")=%q, not the same file`, abspath)
1478         }
1479         if !filepath.IsAbs(abspath) {
1480                 t.Errorf(`Abs("")=%q, not an absolute path`, abspath)
1481         }
1482         if filepath.IsAbs(abspath) && abspath != filepath.Clean(abspath) {
1483                 t.Errorf(`Abs("")=%q, isn't clean`, abspath)
1484         }
1485 }
1486
1487 type RelTests struct {
1488         root, path, want string
1489 }
1490
1491 var reltests = []RelTests{
1492         {"a/b", "a/b", "."},
1493         {"a/b/.", "a/b", "."},
1494         {"a/b", "a/b/.", "."},
1495         {"./a/b", "a/b", "."},
1496         {"a/b", "./a/b", "."},
1497         {"ab/cd", "ab/cde", "../cde"},
1498         {"ab/cd", "ab/c", "../c"},
1499         {"a/b", "a/b/c/d", "c/d"},
1500         {"a/b", "a/b/../c", "../c"},
1501         {"a/b/../c", "a/b", "../b"},
1502         {"a/b/c", "a/c/d", "../../c/d"},
1503         {"a/b", "c/d", "../../c/d"},
1504         {"a/b/c/d", "a/b", "../.."},
1505         {"a/b/c/d", "a/b/", "../.."},
1506         {"a/b/c/d/", "a/b", "../.."},
1507         {"a/b/c/d/", "a/b/", "../.."},
1508         {"../../a/b", "../../a/b/c/d", "c/d"},
1509         {"/a/b", "/a/b", "."},
1510         {"/a/b/.", "/a/b", "."},
1511         {"/a/b", "/a/b/.", "."},
1512         {"/ab/cd", "/ab/cde", "../cde"},
1513         {"/ab/cd", "/ab/c", "../c"},
1514         {"/a/b", "/a/b/c/d", "c/d"},
1515         {"/a/b", "/a/b/../c", "../c"},
1516         {"/a/b/../c", "/a/b", "../b"},
1517         {"/a/b/c", "/a/c/d", "../../c/d"},
1518         {"/a/b", "/c/d", "../../c/d"},
1519         {"/a/b/c/d", "/a/b", "../.."},
1520         {"/a/b/c/d", "/a/b/", "../.."},
1521         {"/a/b/c/d/", "/a/b", "../.."},
1522         {"/a/b/c/d/", "/a/b/", "../.."},
1523         {"/../../a/b", "/../../a/b/c/d", "c/d"},
1524         {".", "a/b", "a/b"},
1525         {".", "..", ".."},
1526
1527         // can't do purely lexically
1528         {"..", ".", "err"},
1529         {"..", "a", "err"},
1530         {"../..", "..", "err"},
1531         {"a", "/a", "err"},
1532         {"/a", "a", "err"},
1533 }
1534
1535 var winreltests = []RelTests{
1536         {`C:a\b\c`, `C:a/b/d`, `..\d`},
1537         {`C:\`, `D:\`, `err`},
1538         {`C:`, `D:`, `err`},
1539         {`C:\Projects`, `c:\projects\src`, `src`},
1540         {`C:\Projects`, `c:\projects`, `.`},
1541         {`C:\Projects\a\..`, `c:\projects`, `.`},
1542         {`\\host\share`, `\\host\share\file.txt`, `file.txt`},
1543 }
1544
1545 func TestRel(t *testing.T) {
1546         tests := append([]RelTests{}, reltests...)
1547         if runtime.GOOS == "windows" {
1548                 for i := range tests {
1549                         tests[i].want = filepath.FromSlash(tests[i].want)
1550                 }
1551                 tests = append(tests, winreltests...)
1552         }
1553         for _, test := range tests {
1554                 got, err := filepath.Rel(test.root, test.path)
1555                 if test.want == "err" {
1556                         if err == nil {
1557                                 t.Errorf("Rel(%q, %q)=%q, want error", test.root, test.path, got)
1558                         }
1559                         continue
1560                 }
1561                 if err != nil {
1562                         t.Errorf("Rel(%q, %q): want %q, got error: %s", test.root, test.path, test.want, err)
1563                 }
1564                 if got != test.want {
1565                         t.Errorf("Rel(%q, %q)=%q, want %q", test.root, test.path, got, test.want)
1566                 }
1567         }
1568 }
1569
1570 type VolumeNameTest struct {
1571         path string
1572         vol  string
1573 }
1574
1575 var volumenametests = []VolumeNameTest{
1576         {`c:/foo/bar`, `c:`},
1577         {`c:`, `c:`},
1578         {`c:\`, `c:`},
1579         {`2:`, `2:`},
1580         {``, ``},
1581         {`\\\host`, `\\\host`},
1582         {`\\\host\`, `\\\host`},
1583         {`\\\host\share`, `\\\host`},
1584         {`\\\host\\share`, `\\\host`},
1585         {`\\host`, `\\host`},
1586         {`//host`, `\\host`},
1587         {`\\host\`, `\\host\`},
1588         {`//host/`, `\\host\`},
1589         {`\\host\share`, `\\host\share`},
1590         {`//host/share`, `\\host\share`},
1591         {`\\host\share\`, `\\host\share`},
1592         {`//host/share/`, `\\host\share`},
1593         {`\\host\share\foo`, `\\host\share`},
1594         {`//host/share/foo`, `\\host\share`},
1595         {`\\host\share\\foo\\\bar\\\\baz`, `\\host\share`},
1596         {`//host/share//foo///bar////baz`, `\\host\share`},
1597         {`\\host\share\foo\..\bar`, `\\host\share`},
1598         {`//host/share/foo/../bar`, `\\host\share`},
1599         {`//.`, `\\.`},
1600         {`//./`, `\\.\`},
1601         {`//./NUL`, `\\.\NUL`},
1602         {`//?`, `\\?`},
1603         {`//?/`, `\\?\`},
1604         {`//?/NUL`, `\\?\NUL`},
1605         {`/??`, `\??`},
1606         {`/??/`, `\??\`},
1607         {`/??/NUL`, `\??\NUL`},
1608         {`//./a/b`, `\\.\a`},
1609         {`//./C:`, `\\.\C:`},
1610         {`//./C:/`, `\\.\C:`},
1611         {`//./C:/a/b/c`, `\\.\C:`},
1612         {`//./UNC/host/share/a/b/c`, `\\.\UNC\host\share`},
1613         {`//./UNC/host`, `\\.\UNC\host`},
1614         {`//./UNC/host\`, `\\.\UNC\host\`},
1615         {`//./UNC`, `\\.\UNC`},
1616         {`//./UNC/`, `\\.\UNC\`},
1617         {`\\?\x`, `\\?\x`},
1618         {`\??\x`, `\??\x`},
1619 }
1620
1621 func TestVolumeName(t *testing.T) {
1622         if runtime.GOOS != "windows" {
1623                 return
1624         }
1625         for _, v := range volumenametests {
1626                 if vol := filepath.VolumeName(v.path); vol != v.vol {
1627                         t.Errorf("VolumeName(%q)=%q, want %q", v.path, vol, v.vol)
1628                 }
1629         }
1630 }
1631
1632 func TestDriveLetterInEvalSymlinks(t *testing.T) {
1633         if runtime.GOOS != "windows" {
1634                 return
1635         }
1636         wd, _ := os.Getwd()
1637         if len(wd) < 3 {
1638                 t.Errorf("Current directory path %q is too short", wd)
1639         }
1640         lp := strings.ToLower(wd)
1641         up := strings.ToUpper(wd)
1642         flp, err := filepath.EvalSymlinks(lp)
1643         if err != nil {
1644                 t.Fatalf("EvalSymlinks(%q) failed: %q", lp, err)
1645         }
1646         fup, err := filepath.EvalSymlinks(up)
1647         if err != nil {
1648                 t.Fatalf("EvalSymlinks(%q) failed: %q", up, err)
1649         }
1650         if flp != fup {
1651                 t.Errorf("Results of EvalSymlinks do not match: %q and %q", flp, fup)
1652         }
1653 }
1654
1655 func TestBug3486(t *testing.T) { // https://golang.org/issue/3486
1656         if runtime.GOOS == "ios" {
1657                 t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
1658         }
1659         root := filepath.Join(testenv.GOROOT(t), "src", "unicode")
1660         utf16 := filepath.Join(root, "utf16")
1661         utf8 := filepath.Join(root, "utf8")
1662         seenUTF16 := false
1663         seenUTF8 := false
1664         err := filepath.Walk(root, func(pth string, info fs.FileInfo, err error) error {
1665                 if err != nil {
1666                         t.Fatal(err)
1667                 }
1668
1669                 switch pth {
1670                 case utf16:
1671                         seenUTF16 = true
1672                         return filepath.SkipDir
1673                 case utf8:
1674                         if !seenUTF16 {
1675                                 t.Fatal("filepath.Walk out of order - utf8 before utf16")
1676                         }
1677                         seenUTF8 = true
1678                 }
1679                 return nil
1680         })
1681         if err != nil {
1682                 t.Fatal(err)
1683         }
1684         if !seenUTF8 {
1685                 t.Fatalf("%q not seen", utf8)
1686         }
1687 }
1688
1689 func testWalkSymlink(t *testing.T, mklink func(target, link string) error) {
1690         tmpdir := t.TempDir()
1691
1692         wd, err := os.Getwd()
1693         if err != nil {
1694                 t.Fatal(err)
1695         }
1696         defer os.Chdir(wd)
1697
1698         err = os.Chdir(tmpdir)
1699         if err != nil {
1700                 t.Fatal(err)
1701         }
1702
1703         err = mklink(tmpdir, "link")
1704         if err != nil {
1705                 t.Fatal(err)
1706         }
1707
1708         var visited []string
1709         err = filepath.Walk(tmpdir, func(path string, info fs.FileInfo, err error) error {
1710                 if err != nil {
1711                         t.Fatal(err)
1712                 }
1713                 rel, err := filepath.Rel(tmpdir, path)
1714                 if err != nil {
1715                         t.Fatal(err)
1716                 }
1717                 visited = append(visited, rel)
1718                 return nil
1719         })
1720         if err != nil {
1721                 t.Fatal(err)
1722         }
1723         sort.Strings(visited)
1724         want := []string{".", "link"}
1725         if fmt.Sprintf("%q", visited) != fmt.Sprintf("%q", want) {
1726                 t.Errorf("unexpected paths visited %q, want %q", visited, want)
1727         }
1728 }
1729
1730 func TestWalkSymlink(t *testing.T) {
1731         testenv.MustHaveSymlink(t)
1732         testWalkSymlink(t, os.Symlink)
1733 }
1734
1735 func TestIssue29372(t *testing.T) {
1736         tmpDir := t.TempDir()
1737
1738         path := filepath.Join(tmpDir, "file.txt")
1739         err := os.WriteFile(path, nil, 0644)
1740         if err != nil {
1741                 t.Fatal(err)
1742         }
1743
1744         pathSeparator := string(filepath.Separator)
1745         tests := []string{
1746                 path + strings.Repeat(pathSeparator, 1),
1747                 path + strings.Repeat(pathSeparator, 2),
1748                 path + strings.Repeat(pathSeparator, 1) + ".",
1749                 path + strings.Repeat(pathSeparator, 2) + ".",
1750                 path + strings.Repeat(pathSeparator, 1) + "..",
1751                 path + strings.Repeat(pathSeparator, 2) + "..",
1752         }
1753
1754         for i, test := range tests {
1755                 _, err = filepath.EvalSymlinks(test)
1756                 if err != syscall.ENOTDIR {
1757                         t.Fatalf("test#%d: want %q, got %q", i, syscall.ENOTDIR, err)
1758                 }
1759         }
1760 }
1761
1762 // Issue 30520 part 1.
1763 func TestEvalSymlinksAboveRoot(t *testing.T) {
1764         testenv.MustHaveSymlink(t)
1765
1766         t.Parallel()
1767
1768         tmpDir := t.TempDir()
1769
1770         evalTmpDir, err := filepath.EvalSymlinks(tmpDir)
1771         if err != nil {
1772                 t.Fatal(err)
1773         }
1774
1775         if err := os.Mkdir(filepath.Join(evalTmpDir, "a"), 0777); err != nil {
1776                 t.Fatal(err)
1777         }
1778         if err := os.Symlink(filepath.Join(evalTmpDir, "a"), filepath.Join(evalTmpDir, "b")); err != nil {
1779                 t.Fatal(err)
1780         }
1781         if err := os.WriteFile(filepath.Join(evalTmpDir, "a", "file"), nil, 0666); err != nil {
1782                 t.Fatal(err)
1783         }
1784
1785         // Count the number of ".." elements to get to the root directory.
1786         vol := filepath.VolumeName(evalTmpDir)
1787         c := strings.Count(evalTmpDir[len(vol):], string(os.PathSeparator))
1788         var dd []string
1789         for i := 0; i < c+2; i++ {
1790                 dd = append(dd, "..")
1791         }
1792
1793         wantSuffix := strings.Join([]string{"a", "file"}, string(os.PathSeparator))
1794
1795         // Try different numbers of "..".
1796         for _, i := range []int{c, c + 1, c + 2} {
1797                 check := strings.Join([]string{evalTmpDir, strings.Join(dd[:i], string(os.PathSeparator)), evalTmpDir[len(vol)+1:], "b", "file"}, string(os.PathSeparator))
1798                 resolved, err := filepath.EvalSymlinks(check)
1799                 switch {
1800                 case runtime.GOOS == "darwin" && errors.Is(err, fs.ErrNotExist):
1801                         // On darwin, the temp dir is sometimes cleaned up mid-test (issue 37910).
1802                         testenv.SkipFlaky(t, 37910)
1803                 case err != nil:
1804                         t.Errorf("EvalSymlinks(%q) failed: %v", check, err)
1805                 case !strings.HasSuffix(resolved, wantSuffix):
1806                         t.Errorf("EvalSymlinks(%q) = %q does not end with %q", check, resolved, wantSuffix)
1807                 default:
1808                         t.Logf("EvalSymlinks(%q) = %q", check, resolved)
1809                 }
1810         }
1811 }
1812
1813 // Issue 30520 part 2.
1814 func TestEvalSymlinksAboveRootChdir(t *testing.T) {
1815         testenv.MustHaveSymlink(t)
1816
1817         tmpDir, err := os.MkdirTemp("", "TestEvalSymlinksAboveRootChdir")
1818         if err != nil {
1819                 t.Fatal(err)
1820         }
1821         defer os.RemoveAll(tmpDir)
1822         chdir(t, tmpDir)
1823
1824         subdir := filepath.Join("a", "b")
1825         if err := os.MkdirAll(subdir, 0777); err != nil {
1826                 t.Fatal(err)
1827         }
1828         if err := os.Symlink(subdir, "c"); err != nil {
1829                 t.Fatal(err)
1830         }
1831         if err := os.WriteFile(filepath.Join(subdir, "file"), nil, 0666); err != nil {
1832                 t.Fatal(err)
1833         }
1834
1835         subdir = filepath.Join("d", "e", "f")
1836         if err := os.MkdirAll(subdir, 0777); err != nil {
1837                 t.Fatal(err)
1838         }
1839         if err := os.Chdir(subdir); err != nil {
1840                 t.Fatal(err)
1841         }
1842
1843         check := filepath.Join("..", "..", "..", "c", "file")
1844         wantSuffix := filepath.Join("a", "b", "file")
1845         if resolved, err := filepath.EvalSymlinks(check); err != nil {
1846                 t.Errorf("EvalSymlinks(%q) failed: %v", check, err)
1847         } else if !strings.HasSuffix(resolved, wantSuffix) {
1848                 t.Errorf("EvalSymlinks(%q) = %q does not end with %q", check, resolved, wantSuffix)
1849         } else {
1850                 t.Logf("EvalSymlinks(%q) = %q", check, resolved)
1851         }
1852 }
1853
1854 func TestIssue51617(t *testing.T) {
1855         dir := t.TempDir()
1856         for _, sub := range []string{"a", filepath.Join("a", "bad"), filepath.Join("a", "next")} {
1857                 if err := os.Mkdir(filepath.Join(dir, sub), 0755); err != nil {
1858                         t.Fatal(err)
1859                 }
1860         }
1861         bad := filepath.Join(dir, "a", "bad")
1862         if err := os.Chmod(bad, 0); err != nil {
1863                 t.Fatal(err)
1864         }
1865         defer os.Chmod(bad, 0700) // avoid errors on cleanup
1866         var saw []string
1867         err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
1868                 if err != nil {
1869                         return filepath.SkipDir
1870                 }
1871                 if d.IsDir() {
1872                         rel, err := filepath.Rel(dir, path)
1873                         if err != nil {
1874                                 t.Fatal(err)
1875                         }
1876                         saw = append(saw, rel)
1877                 }
1878                 return nil
1879         })
1880         if err != nil {
1881                 t.Fatal(err)
1882         }
1883         want := []string{".", "a", filepath.Join("a", "bad"), filepath.Join("a", "next")}
1884         if !reflect.DeepEqual(saw, want) {
1885                 t.Errorf("got directories %v, want %v", saw, want)
1886         }
1887 }
1888
1889 func TestEscaping(t *testing.T) {
1890         dir1 := t.TempDir()
1891         dir2 := t.TempDir()
1892         chdir(t, dir1)
1893
1894         for _, p := range []string{
1895                 filepath.Join(dir2, "x"),
1896         } {
1897                 if !filepath.IsLocal(p) {
1898                         continue
1899                 }
1900                 f, err := os.Create(p)
1901                 if err != nil {
1902                         f.Close()
1903                 }
1904                 ents, err := os.ReadDir(dir2)
1905                 if err != nil {
1906                         t.Fatal(err)
1907                 }
1908                 for _, e := range ents {
1909                         t.Fatalf("found: %v", e.Name())
1910                 }
1911         }
1912 }