1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package fs_test
import (
. "io/fs"
"os"
pathpkg "path"
"path/filepath"
"reflect"
"testing"
"testing/fstest"
)
type Node struct {
name string
entries []*Node // nil if the entry is a file
mark int
}
var tree = &Node{
"testdata",
[]*Node{
{"a", nil, 0},
{"b", []*Node{}, 0},
{"c", nil, 0},
{
"d",
[]*Node{
{"x", nil, 0},
{"y", []*Node{}, 0},
{
"z",
[]*Node{
{"u", nil, 0},
{"v", nil, 0},
},
0,
},
},
0,
},
},
0,
}
func walkTree(n *Node, path string, f func(path string, n *Node)) {
f(path, n)
for _, e := range n.entries {
walkTree(e, pathpkg.Join(path, e.name), f)
}
}
func makeTree() FS {
fsys := fstest.MapFS{}
walkTree(tree, tree.name, func(path string, n *Node) {
if n.entries == nil {
fsys[path] = &fstest.MapFile{}
} else {
fsys[path] = &fstest.MapFile{Mode: ModeDir}
}
})
return fsys
}
// Assumes that each node name is unique. Good enough for a test.
// If clear is true, any incoming error is cleared before return. The errors
// are always accumulated, though.
func mark(entry DirEntry, err error, errors *[]error, clear bool) error {
name := entry.Name()
walkTree(tree, tree.name, func(path string, n *Node) {
if n.name == name {
n.mark++
}
})
if err != nil {
*errors = append(*errors, err)
if clear {
return nil
}
return err
}
return nil
}
func TestWalkDir(t *testing.T) {
tmpDir := t.TempDir()
origDir, err := os.Getwd()
if err != nil {
t.Fatal("finding working dir:", err)
}
if err = os.Chdir(tmpDir); err != nil {
t.Fatal("entering temp dir:", err)
}
defer os.Chdir(origDir)
fsys := makeTree()
errors := make([]error, 0, 10)
clear := true
markFn := func(path string, entry DirEntry, err error) error {
return mark(entry, err, &errors, clear)
}
// Expect no errors.
err = WalkDir(fsys, ".", markFn)
if err != nil {
t.Fatalf("no error expected, found: %s", err)
}
if len(errors) != 0 {
t.Fatalf("unexpected errors: %s", errors)
}
walkTree(tree, tree.name, func(path string, n *Node) {
if n.mark != 1 {
t.Errorf("node %s mark = %d; expected 1", path, n.mark)
}
n.mark = 0
})
}
func TestIssue51617(t *testing.T) {
dir := t.TempDir()
for _, sub := range []string{"a", filepath.Join("a", "bad"), filepath.Join("a", "next")} {
if err := os.Mkdir(filepath.Join(dir, sub), 0755); err != nil {
t.Fatal(err)
}
}
bad := filepath.Join(dir, "a", "bad")
if err := os.Chmod(bad, 0); err != nil {
t.Fatal(err)
}
defer os.Chmod(bad, 0700) // avoid errors on cleanup
var saw []string
err := WalkDir(os.DirFS(dir), ".", func(path string, d DirEntry, err error) error {
if err != nil {
return filepath.SkipDir
}
if d.IsDir() {
saw = append(saw, path)
}
return nil
})
if err != nil {
t.Fatal(err)
}
want := []string{".", "a", "a/bad", "a/next"}
if !reflect.DeepEqual(saw, want) {
t.Errorf("got directories %v, want %v", saw, want)
}
}
|
