ronnie
2022-10-14 1504bb53e29d3d46222c0b3ea994fc494b48e153
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
// Copyright 2009 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 os_test
 
import (
   "internal/testenv"
   "io/ioutil"
   . "os"
   "path/filepath"
   "runtime"
   "syscall"
   "testing"
)
 
var isReadonlyError = func(error) bool { return false }
 
func TestMkdirAll(t *testing.T) {
   tmpDir := TempDir()
   path := tmpDir + "/_TestMkdirAll_/dir/./dir2"
   err := MkdirAll(path, 0777)
   if err != nil {
       t.Fatalf("MkdirAll %q: %s", path, err)
   }
   defer RemoveAll(tmpDir + "/_TestMkdirAll_")
 
   // Already exists, should succeed.
   err = MkdirAll(path, 0777)
   if err != nil {
       t.Fatalf("MkdirAll %q (second time): %s", path, err)
   }
 
   // Make file.
   fpath := path + "/file"
   f, err := Create(fpath)
   if err != nil {
       t.Fatalf("create %q: %s", fpath, err)
   }
   defer f.Close()
 
   // Can't make directory named after file.
   err = MkdirAll(fpath, 0777)
   if err == nil {
       t.Fatalf("MkdirAll %q: no error", fpath)
   }
   perr, ok := err.(*PathError)
   if !ok {
       t.Fatalf("MkdirAll %q returned %T, not *PathError", fpath, err)
   }
   if filepath.Clean(perr.Path) != filepath.Clean(fpath) {
       t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", fpath, filepath.Clean(perr.Path), filepath.Clean(fpath))
   }
 
   // Can't make subdirectory of file.
   ffpath := fpath + "/subdir"
   err = MkdirAll(ffpath, 0777)
   if err == nil {
       t.Fatalf("MkdirAll %q: no error", ffpath)
   }
   perr, ok = err.(*PathError)
   if !ok {
       t.Fatalf("MkdirAll %q returned %T, not *PathError", ffpath, err)
   }
   if filepath.Clean(perr.Path) != filepath.Clean(fpath) {
       t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", ffpath, filepath.Clean(perr.Path), filepath.Clean(fpath))
   }
 
   if runtime.GOOS == "windows" {
       path := tmpDir + `\_TestMkdirAll_\dir\.\dir2\`
       err := MkdirAll(path, 0777)
       if err != nil {
           t.Fatalf("MkdirAll %q: %s", path, err)
       }
   }
}
 
func TestMkdirAllWithSymlink(t *testing.T) {
   testenv.MustHaveSymlink(t)
 
   tmpDir, err := ioutil.TempDir("", "TestMkdirAllWithSymlink-")
   if err != nil {
       t.Fatal(err)
   }
   defer RemoveAll(tmpDir)
 
   dir := tmpDir + "/dir"
   err = Mkdir(dir, 0755)
   if err != nil {
       t.Fatalf("Mkdir %s: %s", dir, err)
   }
 
   link := tmpDir + "/link"
   err = Symlink("dir", link)
   if err != nil {
       t.Fatalf("Symlink %s: %s", link, err)
   }
 
   path := link + "/foo"
   err = MkdirAll(path, 0755)
   if err != nil {
       t.Errorf("MkdirAll %q: %s", path, err)
   }
}
 
func TestMkdirAllAtSlash(t *testing.T) {
   switch runtime.GOOS {
   case "android", "plan9", "windows":
       t.Skipf("skipping on %s", runtime.GOOS)
   case "darwin":
       switch runtime.GOARCH {
       case "arm", "arm64":
           t.Skipf("skipping on darwin/%s, mkdir returns EPERM", runtime.GOARCH)
       }
   }
   RemoveAll("/_go_os_test")
   const dir = "/_go_os_test/dir"
   err := MkdirAll(dir, 0777)
   if err != nil {
       pathErr, ok := err.(*PathError)
       // common for users not to be able to write to /
       if ok && (pathErr.Err == syscall.EACCES || isReadonlyError(pathErr.Err)) {
           t.Skipf("could not create %v: %v", dir, err)
       }
       t.Fatalf(`MkdirAll "/_go_os_test/dir": %v, %s`, err, pathErr.Err)
   }
   RemoveAll("/_go_os_test")
}