Source file src/os/removeall_test.go

Documentation: os

		 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  }
	 437  

View as plain text