libgo/go/os/removeall_test.go

   1 // Copyright 2018 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         "fmt"
   9         "os"
  10         . "os"
  11         "path/filepath"
  12         "runtime"
  13         "strings"
  14         "testing"
  15 )
  16
  17 func TestRemoveAll(t *testing.T) {
  18         tmpDir := t.TempDir()
  19         if err := RemoveAll(""); err != nil {
  20                 t.Errorf("RemoveAll(\"\"): %v; want nil", err)
  21         }
  22
  23         file := filepath.Join(tmpDir, "file")
  24         path := filepath.Join(tmpDir, "_TestRemoveAll_")
  25         fpath := filepath.Join(path, "file")
  26         dpath := filepath.Join(path, "dir")
  27
  28         // Make a regular file and remove
  29         fd, err := Create(file)
  30         if err != nil {
  31                 t.Fatalf("create %q: %s", file, err)
  32         }
  33         fd.Close()
  34         if err = RemoveAll(file); err != nil {
  35                 t.Fatalf("RemoveAll %q (first): %s", file, err)
  36         }
  37         if _, err = Lstat(file); err == nil {
  38                 t.Fatalf("Lstat %q succeeded after RemoveAll (first)", file)
  39         }
  40
  41         // Make directory with 1 file and remove.
  42         if err := MkdirAll(path, 0777); err != nil {
  43                 t.Fatalf("MkdirAll %q: %s", path, err)
  44         }
  45         fd, err = Create(fpath)
  46         if err != nil {
  47                 t.Fatalf("create %q: %s", fpath, err)
  48         }
  49         fd.Close()
  50         if err = RemoveAll(path); err != nil {
  51                 t.Fatalf("RemoveAll %q (second): %s", path, err)
  52         }
  53         if _, err = Lstat(path); err == nil {
  54                 t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path)
  55         }
  56
  57         // Make directory with file and subdirectory and remove.
  58         if err = MkdirAll(dpath, 0777); err != nil {
  59                 t.Fatalf("MkdirAll %q: %s", dpath, err)
  60         }
  61         fd, err = Create(fpath)
  62         if err != nil {
  63                 t.Fatalf("create %q: %s", fpath, err)
  64         }
  65         fd.Close()
  66         fd, err = Create(dpath + "/file")
  67         if err != nil {
  68                 t.Fatalf("create %q: %s", fpath, err)
  69         }
  70         fd.Close()
  71         if err = RemoveAll(path); err != nil {
  72                 t.Fatalf("RemoveAll %q (third): %s", path, err)
  73         }
  74         if _, err := Lstat(path); err == nil {
  75                 t.Fatalf("Lstat %q succeeded after RemoveAll (third)", path)
  76         }
  77
  78         // Chmod is not supported under Windows and test fails as root.
  79         if runtime.GOOS != "windows" && Getuid() != 0 {
  80                 // Make directory with file and subdirectory and trigger error.
  81                 if err = MkdirAll(dpath, 0777); err != nil {
  82                         t.Fatalf("MkdirAll %q: %s", dpath, err)
  83                 }
  84
  85                 for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
  86                         fd, err = Create(s)
  87                         if err != nil {
  88                                 t.Fatalf("create %q: %s", s, err)
  89                         }
  90                         fd.Close()
  91                 }
  92                 if err = Chmod(dpath, 0); err != nil {
  93                         t.Fatalf("Chmod %q 0: %s", dpath, err)
  94                 }
  95
  96                 // No error checking here: either RemoveAll
  97                 // will or won't be able to remove dpath;
  98                 // either way we want to see if it removes fpath
  99                 // and path/zzz. Reasons why RemoveAll might
 100                 // succeed in removing dpath as well include:
 101                 //      * running as root
 102                 //      * running on a file system without permissions (FAT)
 103                 RemoveAll(path)
 104                 Chmod(dpath, 0777)
 105
 106                 for _, s := range []string{fpath, path + "/zzz"} {
 107                         if _, err = Lstat(s); err == nil {
 108                                 t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
 109                         }
 110                 }
 111         }
 112         if err = RemoveAll(path); err != nil {
 113                 t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err)
 114         }
 115         if _, err = Lstat(path); err == nil {
 116                 t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path)
 117         }
 118 }
 119
 120 // Test RemoveAll on a large directory.
 121 func TestRemoveAllLarge(t *testing.T) {
 122         if testing.Short() {
 123                 t.Skip("skipping in short mode")
 124         }
 125
 126         tmpDir := t.TempDir()
 127         path := filepath.Join(tmpDir, "_TestRemoveAllLarge_")
 128
 129         // Make directory with 1000 files and remove.
 130         if err := MkdirAll(path, 0777); err != nil {
 131                 t.Fatalf("MkdirAll %q: %s", path, err)
 132         }
 133         for i := 0; i < 1000; i++ {
 134                 fpath := fmt.Sprintf("%s/file%d", path, i)
 135                 fd, err := Create(fpath)
 136                 if err != nil {
 137                         t.Fatalf("create %q: %s", fpath, err)
 138                 }
 139                 fd.Close()
 140         }
 141         if err := RemoveAll(path); err != nil {
 142                 t.Fatalf("RemoveAll %q: %s", path, err)
 143         }
 144         if _, err := Lstat(path); err == nil {
 145                 t.Fatalf("Lstat %q succeeded after RemoveAll", path)
 146         }
 147 }
 148
 149 func TestRemoveAllLongPath(t *testing.T) {
 150         switch runtime.GOOS {
 151         case "aix", "darwin", "ios", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "illumos", "solaris":
 152                 break
 153         default:
 154                 t.Skip("skipping for not implemented platforms")
 155         }
 156
 157         prevDir, err := Getwd()
 158         if err != nil {
 159                 t.Fatalf("Could not get wd: %s", err)
 160         }
 161
 162         startPath, err := os.MkdirTemp("", "TestRemoveAllLongPath-")
 163         if err != nil {
 164                 t.Fatalf("Could not create TempDir: %s", err)
 165         }
 166         defer RemoveAll(startPath)
 167
 168         err = Chdir(startPath)
 169         if err != nil {
 170                 t.Fatalf("Could not chdir %s: %s", startPath, err)
 171         }
 172
 173         // Removing paths with over 4096 chars commonly fails
 174         for i := 0; i < 41; i++ {
 175                 name := strings.Repeat("a", 100)
 176
 177                 err = Mkdir(name, 0755)
 178                 if err != nil {
 179                         t.Fatalf("Could not mkdir %s: %s", name, err)
 180                 }
 181
 182                 err = Chdir(name)
 183                 if err != nil {
 184                         t.Fatalf("Could not chdir %s: %s", name, err)
 185                 }
 186         }
 187
 188         err = Chdir(prevDir)
 189         if err != nil {
 190                 t.Fatalf("Could not chdir %s: %s", prevDir, err)
 191         }
 192
 193         err = RemoveAll(startPath)
 194         if err != nil {
 195                 t.Errorf("RemoveAll could not remove long file path %s: %s", startPath, err)
 196         }
 197 }
 198
 199 func TestRemoveAllDot(t *testing.T) {
 200         prevDir, err := Getwd()
 201         if err != nil {
 202                 t.Fatalf("Could not get wd: %s", err)
 203         }
 204         tempDir, err := os.MkdirTemp("", "TestRemoveAllDot-")
 205         if err != nil {
 206                 t.Fatalf("Could not create TempDir: %s", err)
 207         }
 208         defer RemoveAll(tempDir)
 209
 210         err = Chdir(tempDir)
 211         if err != nil {
 212                 t.Fatalf("Could not chdir to tempdir: %s", err)
 213         }
 214
 215         err = RemoveAll(".")
 216         if err == nil {
 217                 t.Errorf("RemoveAll succeed to remove .")
 218         }
 219
 220         err = Chdir(prevDir)
 221         if err != nil {
 222                 t.Fatalf("Could not chdir %s: %s", prevDir, err)
 223         }
 224 }
 225
 226 func TestRemoveAllDotDot(t *testing.T) {
 227         t.Parallel()
 228
 229         tempDir := t.TempDir()
 230         subdir := filepath.Join(tempDir, "x")
 231         subsubdir := filepath.Join(subdir, "y")
 232         if err := MkdirAll(subsubdir, 0777); err != nil {
 233                 t.Fatal(err)
 234         }
 235         if err := RemoveAll(filepath.Join(subsubdir, "..")); err != nil {
 236                 t.Error(err)
 237         }
 238         for _, dir := range []string{subsubdir, subdir} {
 239                 if _, err := Stat(dir); err == nil {
 240                         t.Errorf("%s: exists after RemoveAll", dir)
 241                 }
 242         }
 243 }
 244
 245 // Issue #29178.
 246 func TestRemoveReadOnlyDir(t *testing.T) {
 247         t.Parallel()
 248
 249         tempDir := t.TempDir()
 250         subdir := filepath.Join(tempDir, "x")
 251         if err := Mkdir(subdir, 0); err != nil {
 252                 t.Fatal(err)
 253         }
 254
 255         // If an error occurs make it more likely that removing the
 256         // temporary directory will succeed.
 257         defer Chmod(subdir, 0777)
 258
 259         if err := RemoveAll(subdir); err != nil {
 260                 t.Fatal(err)
 261         }
 262
 263         if _, err := Stat(subdir); err == nil {
 264                 t.Error("subdirectory was not removed")
 265         }
 266 }
 267
 268 // Issue #29983.
 269 func TestRemoveAllButReadOnlyAndPathError(t *testing.T) {
 270         switch runtime.GOOS {
 271         case "js", "windows":
 272                 t.Skipf("skipping test on %s", runtime.GOOS)
 273         }
 274
 275         if Getuid() == 0 {
 276                 t.Skip("skipping test when running as root")
 277         }
 278
 279         t.Parallel()
 280
 281         tempDir := t.TempDir()
 282         dirs := []string{
 283                 "a",
 284                 "a/x",
 285                 "a/x/1",
 286                 "b",
 287                 "b/y",
 288                 "b/y/2",
 289                 "c",
 290                 "c/z",
 291                 "c/z/3",
 292         }
 293         readonly := []string{
 294                 "b",
 295         }
 296         inReadonly := func(d string) bool {
 297                 for _, ro := range readonly {
 298                         if d == ro {
 299                                 return true
 300                         }
 301                         dd, _ := filepath.Split(d)
 302                         if filepath.Clean(dd) == ro {
 303                                 return true
 304                         }
 305                 }
 306                 return false
 307         }
 308
 309         for _, dir := range dirs {
 310                 if err := Mkdir(filepath.Join(tempDir, dir), 0777); err != nil {
 311                         t.Fatal(err)
 312                 }
 313         }
 314         for _, dir := range readonly {
 315                 d := filepath.Join(tempDir, dir)
 316                 if err := Chmod(d, 0555); err != nil {
 317                         t.Fatal(err)
 318                 }
 319
 320                 // Defer changing the mode back so that the deferred
 321                 // RemoveAll(tempDir) can succeed.
 322                 defer Chmod(d, 0777)
 323         }
 324
 325         err := RemoveAll(tempDir)
 326         if err == nil {
 327                 t.Fatal("RemoveAll succeeded unexpectedly")
 328         }
 329
 330         // The error should be of type *PathError.
 331         // see issue 30491 for details.
 332         if pathErr, ok := err.(*PathError); ok {
 333                 want := filepath.Join(tempDir, "b", "y")
 334                 if pathErr.Path != want {
 335                         t.Errorf("RemoveAll(%q): err.Path=%q, want %q", tempDir, pathErr.Path, want)
 336                 }
 337         } else {
 338                 t.Errorf("RemoveAll(%q): error has type %T, want *fs.PathError", tempDir, err)
 339         }
 340
 341         for _, dir := range dirs {
 342                 _, err := Stat(filepath.Join(tempDir, dir))
 343                 if inReadonly(dir) {
 344                         if err != nil {
 345                                 t.Errorf("file %q was deleted but should still exist", dir)
 346                         }
 347                 } else {
 348                         if err == nil {
 349                                 t.Errorf("file %q still exists but should have been deleted", dir)
 350                         }
 351                 }
 352         }
 353 }
 354
 355 func TestRemoveUnreadableDir(t *testing.T) {
 356         switch runtime.GOOS {
 357         case "js":
 358                 t.Skipf("skipping test on %s", runtime.GOOS)
 359         }
 360
 361         if Getuid() == 0 {
 362                 t.Skip("skipping test when running as root")
 363         }
 364
 365         t.Parallel()
 366
 367         tempDir := t.TempDir()
 368         target := filepath.Join(tempDir, "d0", "d1", "d2")
 369         if err := MkdirAll(target, 0755); err != nil {
 370                 t.Fatal(err)
 371         }
 372         if err := Chmod(target, 0300); err != nil {
 373                 t.Fatal(err)
 374         }
 375         if err := RemoveAll(filepath.Join(tempDir, "d0")); err != nil {
 376                 t.Fatal(err)
 377         }
 378 }
 379
 380 // Issue 29921
 381 func TestRemoveAllWithMoreErrorThanReqSize(t *testing.T) {
 382         if testing.Short() {
 383                 t.Skip("skipping in short mode")
 384         }
 385
 386         tmpDir := t.TempDir()
 387         path := filepath.Join(tmpDir, "_TestRemoveAllWithMoreErrorThanReqSize_")
 388
 389         // Make directory with 1025 read-only files.
 390         if err := MkdirAll(path, 0777); err != nil {
 391                 t.Fatalf("MkdirAll %q: %s", path, err)
 392         }
 393         for i := 0; i < 1025; i++ {
 394                 fpath := filepath.Join(path, fmt.Sprintf("file%d", i))
 395                 fd, err := Create(fpath)
 396                 if err != nil {
 397                         t.Fatalf("create %q: %s", fpath, err)
 398                 }
 399                 fd.Close()
 400         }
 401
 402         // Make the parent directory read-only. On some platforms, this is what
 403         // prevents os.Remove from removing the files within that directory.
 404         if err := Chmod(path, 0555); err != nil {
 405                 t.Fatal(err)
 406         }
 407         defer Chmod(path, 0755)
 408
 409         // This call should not hang, even on a platform that disallows file deletion
 410         // from read-only directories.
 411         err := RemoveAll(path)
 412
 413         if Getuid() == 0 {
 414                 // On many platforms, root can remove files from read-only directories.
 415                 return
 416         }
 417         if err == nil {
 418                 if runtime.GOOS == "windows" {
 419                         // Marking a directory as read-only in Windows does not prevent the RemoveAll
 420                         // from creating or removing files within it.
 421                         return
 422                 }
 423                 t.Fatal("RemoveAll(<read-only directory>) = nil; want error")
 424         }
 425
 426         dir, err := Open(path)
 427         if err != nil {
 428                 t.Fatal(err)
 429         }
 430         defer dir.Close()
 431
 432         names, _ := dir.Readdirnames(1025)
 433         if len(names) < 1025 {
 434                 t.Fatalf("RemoveAll(<read-only directory>) unexpectedly removed %d read-only files from that directory", 1025-len(names))
 435         }
 436 }