github.com/twelsh-aw/go/src@v0.0.0-20230516233729-a56fe86a7c81/os/error_test.go (about) 1 // Copyright 2012 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 os_test 6 7 import ( 8 "errors" 9 "fmt" 10 "io/fs" 11 "os" 12 "path/filepath" 13 "testing" 14 ) 15 16 func TestErrIsExist(t *testing.T) { 17 t.Parallel() 18 19 f, err := os.CreateTemp("", "_Go_ErrIsExist") 20 if err != nil { 21 t.Fatalf("open ErrIsExist tempfile: %s", err) 22 return 23 } 24 defer os.Remove(f.Name()) 25 defer f.Close() 26 f2, err := os.OpenFile(f.Name(), os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600) 27 if err == nil { 28 f2.Close() 29 t.Fatal("Open should have failed") 30 return 31 } 32 if s := checkErrorPredicate("os.IsExist", os.IsExist, err, fs.ErrExist); s != "" { 33 t.Fatal(s) 34 return 35 } 36 } 37 38 func testErrNotExist(t *testing.T, name string) string { 39 originalWD, err := os.Getwd() 40 if err != nil { 41 t.Fatal(err) 42 } 43 44 f, err := os.Open(name) 45 if err == nil { 46 f.Close() 47 return "Open should have failed" 48 } 49 if s := checkErrorPredicate("os.IsNotExist", os.IsNotExist, err, fs.ErrNotExist); s != "" { 50 return s 51 } 52 53 err = os.Chdir(name) 54 if err == nil { 55 if err := os.Chdir(originalWD); err != nil { 56 t.Fatalf("Chdir should have failed, failed to restore original working directory: %v", err) 57 } 58 return "Chdir should have failed, restored original working directory" 59 } 60 if s := checkErrorPredicate("os.IsNotExist", os.IsNotExist, err, fs.ErrNotExist); s != "" { 61 return s 62 } 63 return "" 64 } 65 66 func TestErrIsNotExist(t *testing.T) { 67 tmpDir := t.TempDir() 68 name := filepath.Join(tmpDir, "NotExists") 69 if s := testErrNotExist(t, name); s != "" { 70 t.Fatal(s) 71 return 72 } 73 74 name = filepath.Join(name, "NotExists2") 75 if s := testErrNotExist(t, name); s != "" { 76 t.Fatal(s) 77 return 78 } 79 } 80 81 func checkErrorPredicate(predName string, pred func(error) bool, err, target error) string { 82 if !pred(err) { 83 return fmt.Sprintf("%s does not work as expected for %#v", predName, err) 84 } 85 if !errors.Is(err, target) { 86 return fmt.Sprintf("errors.Is(%#v, %#v) = false, want true", err, target) 87 } 88 return "" 89 } 90 91 type isExistTest struct { 92 err error 93 is bool 94 isnot bool 95 } 96 97 var isExistTests = []isExistTest{ 98 {&fs.PathError{Err: fs.ErrInvalid}, false, false}, 99 {&fs.PathError{Err: fs.ErrPermission}, false, false}, 100 {&fs.PathError{Err: fs.ErrExist}, true, false}, 101 {&fs.PathError{Err: fs.ErrNotExist}, false, true}, 102 {&fs.PathError{Err: fs.ErrClosed}, false, false}, 103 {&os.LinkError{Err: fs.ErrInvalid}, false, false}, 104 {&os.LinkError{Err: fs.ErrPermission}, false, false}, 105 {&os.LinkError{Err: fs.ErrExist}, true, false}, 106 {&os.LinkError{Err: fs.ErrNotExist}, false, true}, 107 {&os.LinkError{Err: fs.ErrClosed}, false, false}, 108 {&os.SyscallError{Err: fs.ErrNotExist}, false, true}, 109 {&os.SyscallError{Err: fs.ErrExist}, true, false}, 110 {nil, false, false}, 111 } 112 113 func TestIsExist(t *testing.T) { 114 for _, tt := range isExistTests { 115 if is := os.IsExist(tt.err); is != tt.is { 116 t.Errorf("os.IsExist(%T %v) = %v, want %v", tt.err, tt.err, is, tt.is) 117 } 118 if is := errors.Is(tt.err, fs.ErrExist); is != tt.is { 119 t.Errorf("errors.Is(%T %v, fs.ErrExist) = %v, want %v", tt.err, tt.err, is, tt.is) 120 } 121 if isnot := os.IsNotExist(tt.err); isnot != tt.isnot { 122 t.Errorf("os.IsNotExist(%T %v) = %v, want %v", tt.err, tt.err, isnot, tt.isnot) 123 } 124 if isnot := errors.Is(tt.err, fs.ErrNotExist); isnot != tt.isnot { 125 t.Errorf("errors.Is(%T %v, fs.ErrNotExist) = %v, want %v", tt.err, tt.err, isnot, tt.isnot) 126 } 127 } 128 } 129 130 type isPermissionTest struct { 131 err error 132 want bool 133 } 134 135 var isPermissionTests = []isPermissionTest{ 136 {nil, false}, 137 {&fs.PathError{Err: fs.ErrPermission}, true}, 138 {&os.SyscallError{Err: fs.ErrPermission}, true}, 139 } 140 141 func TestIsPermission(t *testing.T) { 142 for _, tt := range isPermissionTests { 143 if got := os.IsPermission(tt.err); got != tt.want { 144 t.Errorf("os.IsPermission(%#v) = %v; want %v", tt.err, got, tt.want) 145 } 146 if got := errors.Is(tt.err, fs.ErrPermission); got != tt.want { 147 t.Errorf("errors.Is(%#v, fs.ErrPermission) = %v; want %v", tt.err, got, tt.want) 148 } 149 } 150 } 151 152 func TestErrPathNUL(t *testing.T) { 153 t.Parallel() 154 155 f, err := os.CreateTemp("", "_Go_ErrPathNUL\x00") 156 if err == nil { 157 f.Close() 158 t.Fatal("TempFile should have failed") 159 } 160 f, err = os.CreateTemp("", "_Go_ErrPathNUL") 161 if err != nil { 162 t.Fatalf("open ErrPathNUL tempfile: %s", err) 163 } 164 defer os.Remove(f.Name()) 165 defer f.Close() 166 f2, err := os.OpenFile(f.Name(), os.O_RDWR, 0600) 167 if err != nil { 168 t.Fatalf("open ErrPathNUL: %s", err) 169 } 170 f2.Close() 171 f2, err = os.OpenFile(f.Name()+"\x00", os.O_RDWR, 0600) 172 if err == nil { 173 f2.Close() 174 t.Fatal("Open should have failed") 175 } 176 } 177 178 func TestPathErrorUnwrap(t *testing.T) { 179 pe := &fs.PathError{Err: fs.ErrInvalid} 180 if !errors.Is(pe, fs.ErrInvalid) { 181 t.Error("errors.Is failed, wanted success") 182 } 183 } 184 185 type myErrorIs struct{ error } 186 187 func (e myErrorIs) Is(target error) bool { return target == e.error } 188 189 func TestErrorIsMethods(t *testing.T) { 190 if os.IsPermission(myErrorIs{fs.ErrPermission}) { 191 t.Error("os.IsPermission(err) = true when err.Is(fs.ErrPermission), wanted false") 192 } 193 }