Source file src/os/os_test.go

Documentation: os

     1  // Copyright 2009 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  	"bytes"
     9  	"errors"
    10  	"flag"
    11  	"fmt"
    12  	"internal/testenv"
    13  	"io"
    14  	"io/fs"
    15  	"os"
    16  	. "os"
    17  	osexec "os/exec"
    18  	"path/filepath"
    19  	"reflect"
    20  	"runtime"
    21  	"runtime/debug"
    22  	"sort"
    23  	"strings"
    24  	"sync"
    25  	"syscall"
    26  	"testing"
    27  	"testing/fstest"
    28  	"time"
    29  )
    30  
    31  var dot = []string{
    32  	"dir_unix.go",
    33  	"env.go",
    34  	"error.go",
    35  	"file.go",
    36  	"os_test.go",
    37  	"types.go",
    38  	"stat_darwin.go",
    39  	"stat_linux.go",
    40  }
    41  
    42  type sysDir struct {
    43  	name  string
    44  	files []string
    45  }
    46  
    47  var sysdir = func() *sysDir {
    48  	switch runtime.GOOS {
    49  	case "android":
    50  		return &sysDir{
    51  			"/system/lib",
    52  			[]string{
    53  				"libmedia.so",
    54  				"libpowermanager.so",
    55  			},
    56  		}
    57  	case "darwin", "ios":
    58  		switch runtime.GOARCH {
    59  		case "arm64":
    60  			wd, err := syscall.Getwd()
    61  			if err != nil {
    62  				wd = err.Error()
    63  			}
    64  			sd := &sysDir{
    65  				filepath.Join(wd, "..", ".."),
    66  				[]string{
    67  					"ResourceRules.plist",
    68  					"Info.plist",
    69  				},
    70  			}
    71  			found := true
    72  			for _, f := range sd.files {
    73  				path := filepath.Join(sd.name, f)
    74  				if _, err := Stat(path); err != nil {
    75  					found = false
    76  					break
    77  				}
    78  			}
    79  			if found {
    80  				return sd
    81  			}
    82  			// In a self-hosted iOS build the above files might
    83  			// not exist. Look for system files instead below.
    84  		}
    85  	case "windows":
    86  		return &sysDir{
    87  			Getenv("SystemRoot") + "\\system32\\drivers\\etc",
    88  			[]string{
    89  				"networks",
    90  				"protocol",
    91  				"services",
    92  			},
    93  		}
    94  	case "plan9":
    95  		return &sysDir{
    96  			"/lib/ndb",
    97  			[]string{
    98  				"common",
    99  				"local",
   100  			},
   101  		}
   102  	}
   103  	return &sysDir{
   104  		"/etc",
   105  		[]string{
   106  			"group",
   107  			"hosts",
   108  			"passwd",
   109  		},
   110  	}
   111  }()
   112  
   113  func size(name string, t *testing.T) int64 {
   114  	file, err := Open(name)
   115  	if err != nil {
   116  		t.Fatal("open failed:", err)
   117  	}
   118  	defer file.Close()
   119  	var buf [100]byte
   120  	len := 0
   121  	for {
   122  		n, e := file.Read(buf[0:])
   123  		len += n
   124  		if e == io.EOF {
   125  			break
   126  		}
   127  		if e != nil {
   128  			t.Fatal("read failed:", e)
   129  		}
   130  	}
   131  	return int64(len)
   132  }
   133  
   134  func equal(name1, name2 string) (r bool) {
   135  	switch runtime.GOOS {
   136  	case "windows":
   137  		r = strings.ToLower(name1) == strings.ToLower(name2)
   138  	default:
   139  		r = name1 == name2
   140  	}
   141  	return
   142  }
   143  
   144  // localTmp returns a local temporary directory not on NFS.
   145  func localTmp() string {
   146  	switch runtime.GOOS {
   147  	case "android", "windows":
   148  		return TempDir()
   149  	case "darwin", "ios":
   150  		switch runtime.GOARCH {
   151  		case "arm64":
   152  			return TempDir()
   153  		}
   154  	}
   155  	return "/tmp"
   156  }
   157  
   158  func newFile(testName string, t *testing.T) (f *File) {
   159  	f, err := os.CreateTemp(localTmp(), "_Go_"+testName)
   160  	if err != nil {
   161  		t.Fatalf("TempFile %s: %s", testName, err)
   162  	}
   163  	return
   164  }
   165  
   166  func newDir(testName string, t *testing.T) (name string) {
   167  	name, err := os.MkdirTemp(localTmp(), "_Go_"+testName)
   168  	if err != nil {
   169  		t.Fatalf("TempDir %s: %s", testName, err)
   170  	}
   171  	return
   172  }
   173  
   174  var sfdir = sysdir.name
   175  var sfname = sysdir.files[0]
   176  
   177  func TestStat(t *testing.T) {
   178  	path := sfdir + "/" + sfname
   179  	dir, err := Stat(path)
   180  	if err != nil {
   181  		t.Fatal("stat failed:", err)
   182  	}
   183  	if !equal(sfname, dir.Name()) {
   184  		t.Error("name should be ", sfname, "; is", dir.Name())
   185  	}
   186  	filesize := size(path, t)
   187  	if dir.Size() != filesize {
   188  		t.Error("size should be", filesize, "; is", dir.Size())
   189  	}
   190  }
   191  
   192  func TestStatError(t *testing.T) {
   193  	defer chtmpdir(t)()
   194  
   195  	path := "no-such-file"
   196  
   197  	fi, err := Stat(path)
   198  	if err == nil {
   199  		t.Fatal("got nil, want error")
   200  	}
   201  	if fi != nil {
   202  		t.Errorf("got %v, want nil", fi)
   203  	}
   204  	if perr, ok := err.(*PathError); !ok {
   205  		t.Errorf("got %T, want %T", err, perr)
   206  	}
   207  
   208  	testenv.MustHaveSymlink(t)
   209  
   210  	link := "symlink"
   211  	err = Symlink(path, link)
   212  	if err != nil {
   213  		t.Fatal(err)
   214  	}
   215  
   216  	fi, err = Stat(link)
   217  	if err == nil {
   218  		t.Fatal("got nil, want error")
   219  	}
   220  	if fi != nil {
   221  		t.Errorf("got %v, want nil", fi)
   222  	}
   223  	if perr, ok := err.(*PathError); !ok {
   224  		t.Errorf("got %T, want %T", err, perr)
   225  	}
   226  }
   227  
   228  func TestFstat(t *testing.T) {
   229  	path := sfdir + "/" + sfname
   230  	file, err1 := Open(path)
   231  	if err1 != nil {
   232  		t.Fatal("open failed:", err1)
   233  	}
   234  	defer file.Close()
   235  	dir, err2 := file.Stat()
   236  	if err2 != nil {
   237  		t.Fatal("fstat failed:", err2)
   238  	}
   239  	if !equal(sfname, dir.Name()) {
   240  		t.Error("name should be ", sfname, "; is", dir.Name())
   241  	}
   242  	filesize := size(path, t)
   243  	if dir.Size() != filesize {
   244  		t.Error("size should be", filesize, "; is", dir.Size())
   245  	}
   246  }
   247  
   248  func TestLstat(t *testing.T) {
   249  	path := sfdir + "/" + sfname
   250  	dir, err := Lstat(path)
   251  	if err != nil {
   252  		t.Fatal("lstat failed:", err)
   253  	}
   254  	if !equal(sfname, dir.Name()) {
   255  		t.Error("name should be ", sfname, "; is", dir.Name())
   256  	}
   257  	filesize := size(path, t)
   258  	if dir.Size() != filesize {
   259  		t.Error("size should be", filesize, "; is", dir.Size())
   260  	}
   261  }
   262  
   263  // Read with length 0 should not return EOF.
   264  func TestRead0(t *testing.T) {
   265  	path := sfdir + "/" + sfname
   266  	f, err := Open(path)
   267  	if err != nil {
   268  		t.Fatal("open failed:", err)
   269  	}
   270  	defer f.Close()
   271  
   272  	b := make([]byte, 0)
   273  	n, err := f.Read(b)
   274  	if n != 0 || err != nil {
   275  		t.Errorf("Read(0) = %d, %v, want 0, nil", n, err)
   276  	}
   277  	b = make([]byte, 100)
   278  	n, err = f.Read(b)
   279  	if n <= 0 || err != nil {
   280  		t.Errorf("Read(100) = %d, %v, want >0, nil", n, err)
   281  	}
   282  }
   283  
   284  // Reading a closed file should return ErrClosed error
   285  func TestReadClosed(t *testing.T) {
   286  	path := sfdir + "/" + sfname
   287  	file, err := Open(path)
   288  	if err != nil {
   289  		t.Fatal("open failed:", err)
   290  	}
   291  	file.Close() // close immediately
   292  
   293  	b := make([]byte, 100)
   294  	_, err = file.Read(b)
   295  
   296  	e, ok := err.(*PathError)
   297  	if !ok {
   298  		t.Fatalf("Read: %T(%v), want PathError", e, e)
   299  	}
   300  
   301  	if e.Err != ErrClosed {
   302  		t.Errorf("Read: %v, want PathError(ErrClosed)", e)
   303  	}
   304  }
   305  
   306  func testReaddirnames(dir string, contents []string, t *testing.T) {
   307  	file, err := Open(dir)
   308  	if err != nil {
   309  		t.Fatalf("open %q failed: %v", dir, err)
   310  	}
   311  	defer file.Close()
   312  	s, err2 := file.Readdirnames(-1)
   313  	if err2 != nil {
   314  		t.Fatalf("Readdirnames %q failed: %v", dir, err2)
   315  	}
   316  	for _, m := range contents {
   317  		found := false
   318  		for _, n := range s {
   319  			if n == "." || n == ".." {
   320  				t.Errorf("got %q in directory", n)
   321  			}
   322  			if !equal(m, n) {
   323  				continue
   324  			}
   325  			if found {
   326  				t.Error("present twice:", m)
   327  			}
   328  			found = true
   329  		}
   330  		if !found {
   331  			t.Error("could not find", m)
   332  		}
   333  	}
   334  	if s == nil {
   335  		t.Error("Readdirnames returned nil instead of empty slice")
   336  	}
   337  }
   338  
   339  func testReaddir(dir string, contents []string, t *testing.T) {
   340  	file, err := Open(dir)
   341  	if err != nil {
   342  		t.Fatalf("open %q failed: %v", dir, err)
   343  	}
   344  	defer file.Close()
   345  	s, err2 := file.Readdir(-1)
   346  	if err2 != nil {
   347  		t.Fatalf("Readdir %q failed: %v", dir, err2)
   348  	}
   349  	for _, m := range contents {
   350  		found := false
   351  		for _, n := range s {
   352  			if n.Name() == "." || n.Name() == ".." {
   353  				t.Errorf("got %q in directory", n.Name())
   354  			}
   355  			if !equal(m, n.Name()) {
   356  				continue
   357  			}
   358  			if found {
   359  				t.Error("present twice:", m)
   360  			}
   361  			found = true
   362  		}
   363  		if !found {
   364  			t.Error("could not find", m)
   365  		}
   366  	}
   367  	if s == nil {
   368  		t.Error("Readdir returned nil instead of empty slice")
   369  	}
   370  }
   371  
   372  func testReadDir(dir string, contents []string, t *testing.T) {
   373  	file, err := Open(dir)
   374  	if err != nil {
   375  		t.Fatalf("open %q failed: %v", dir, err)
   376  	}
   377  	defer file.Close()
   378  	s, err2 := file.ReadDir(-1)
   379  	if err2 != nil {
   380  		t.Fatalf("ReadDir %q failed: %v", dir, err2)
   381  	}
   382  	for _, m := range contents {
   383  		found := false
   384  		for _, n := range s {
   385  			if n.Name() == "." || n.Name() == ".." {
   386  				t.Errorf("got %q in directory", n)
   387  			}
   388  			if !equal(m, n.Name()) {
   389  				continue
   390  			}
   391  			if found {
   392  				t.Error("present twice:", m)
   393  			}
   394  			found = true
   395  			lstat, err := Lstat(dir + "/" + m)
   396  			if err != nil {
   397  				t.Fatal(err)
   398  			}
   399  			if n.IsDir() != lstat.IsDir() {
   400  				t.Errorf("%s: IsDir=%v, want %v", m, n.IsDir(), lstat.IsDir())
   401  			}
   402  			if n.Type() != lstat.Mode().Type() {
   403  				t.Errorf("%s: IsDir=%v, want %v", m, n.Type(), lstat.Mode().Type())
   404  			}
   405  			info, err := n.Info()
   406  			if err != nil {
   407  				t.Errorf("%s: Info: %v", m, err)
   408  				continue
   409  			}
   410  			if !SameFile(info, lstat) {
   411  				t.Errorf("%s: Info: SameFile(info, lstat) = false", m)
   412  			}
   413  		}
   414  		if !found {
   415  			t.Error("could not find", m)
   416  		}
   417  	}
   418  	if s == nil {
   419  		t.Error("ReadDir returned nil instead of empty slice")
   420  	}
   421  }
   422  
   423  func TestFileReaddirnames(t *testing.T) {
   424  	testReaddirnames(".", dot, t)
   425  	testReaddirnames(sysdir.name, sysdir.files, t)
   426  	testReaddirnames(t.TempDir(), nil, t)
   427  }
   428  
   429  func TestFileReaddir(t *testing.T) {
   430  	testReaddir(".", dot, t)
   431  	testReaddir(sysdir.name, sysdir.files, t)
   432  	testReaddir(t.TempDir(), nil, t)
   433  }
   434  
   435  func TestFileReadDir(t *testing.T) {
   436  	testReadDir(".", dot, t)
   437  	testReadDir(sysdir.name, sysdir.files, t)
   438  	testReadDir(t.TempDir(), nil, t)
   439  }
   440  
   441  func benchmarkReaddirname(path string, b *testing.B) {
   442  	var nentries int
   443  	for i := 0; i < b.N; i++ {
   444  		f, err := Open(path)
   445  		if err != nil {
   446  			b.Fatalf("open %q failed: %v", path, err)
   447  		}
   448  		ns, err := f.Readdirnames(-1)
   449  		f.Close()
   450  		if err != nil {
   451  			b.Fatalf("readdirnames %q failed: %v", path, err)
   452  		}
   453  		nentries = len(ns)
   454  	}
   455  	b.Logf("benchmarkReaddirname %q: %d entries", path, nentries)
   456  }
   457  
   458  func benchmarkReaddir(path string, b *testing.B) {
   459  	var nentries int
   460  	for i := 0; i < b.N; i++ {
   461  		f, err := Open(path)
   462  		if err != nil {
   463  			b.Fatalf("open %q failed: %v", path, err)
   464  		}
   465  		fs, err := f.Readdir(-1)
   466  		f.Close()
   467  		if err != nil {
   468  			b.Fatalf("readdir %q failed: %v", path, err)
   469  		}
   470  		nentries = len(fs)
   471  	}
   472  	b.Logf("benchmarkReaddir %q: %d entries", path, nentries)
   473  }
   474  
   475  func benchmarkReadDir(path string, b *testing.B) {
   476  	var nentries int
   477  	for i := 0; i < b.N; i++ {
   478  		f, err := Open(path)
   479  		if err != nil {
   480  			b.Fatalf("open %q failed: %v", path, err)
   481  		}
   482  		fs, err := f.ReadDir(-1)
   483  		f.Close()
   484  		if err != nil {
   485  			b.Fatalf("readdir %q failed: %v", path, err)
   486  		}
   487  		nentries = len(fs)
   488  	}
   489  	b.Logf("benchmarkReadDir %q: %d entries", path, nentries)
   490  }
   491  
   492  func BenchmarkReaddirname(b *testing.B) {
   493  	benchmarkReaddirname(".", b)
   494  }
   495  
   496  func BenchmarkReaddir(b *testing.B) {
   497  	benchmarkReaddir(".", b)
   498  }
   499  
   500  func BenchmarkReadDir(b *testing.B) {
   501  	benchmarkReadDir(".", b)
   502  }
   503  
   504  func benchmarkStat(b *testing.B, path string) {
   505  	b.ResetTimer()
   506  	for i := 0; i < b.N; i++ {
   507  		_, err := Stat(path)
   508  		if err != nil {
   509  			b.Fatalf("Stat(%q) failed: %v", path, err)
   510  		}
   511  	}
   512  }
   513  
   514  func benchmarkLstat(b *testing.B, path string) {
   515  	b.ResetTimer()
   516  	for i := 0; i < b.N; i++ {
   517  		_, err := Lstat(path)
   518  		if err != nil {
   519  			b.Fatalf("Lstat(%q) failed: %v", path, err)
   520  		}
   521  	}
   522  }
   523  
   524  func BenchmarkStatDot(b *testing.B) {
   525  	benchmarkStat(b, ".")
   526  }
   527  
   528  func BenchmarkStatFile(b *testing.B) {
   529  	benchmarkStat(b, filepath.Join(runtime.GOROOT(), "src/os/os_test.go"))
   530  }
   531  
   532  func BenchmarkStatDir(b *testing.B) {
   533  	benchmarkStat(b, filepath.Join(runtime.GOROOT(), "src/os"))
   534  }
   535  
   536  func BenchmarkLstatDot(b *testing.B) {
   537  	benchmarkLstat(b, ".")
   538  }
   539  
   540  func BenchmarkLstatFile(b *testing.B) {
   541  	benchmarkLstat(b, filepath.Join(runtime.GOROOT(), "src/os/os_test.go"))
   542  }
   543  
   544  func BenchmarkLstatDir(b *testing.B) {
   545  	benchmarkLstat(b, filepath.Join(runtime.GOROOT(), "src/os"))
   546  }
   547  
   548  // Read the directory one entry at a time.
   549  func smallReaddirnames(file *File, length int, t *testing.T) []string {
   550  	names := make([]string, length)
   551  	count := 0
   552  	for {
   553  		d, err := file.Readdirnames(1)
   554  		if err == io.EOF {
   555  			break
   556  		}
   557  		if err != nil {
   558  			t.Fatalf("readdirnames %q failed: %v", file.Name(), err)
   559  		}
   560  		if len(d) == 0 {
   561  			t.Fatalf("readdirnames %q returned empty slice and no error", file.Name())
   562  		}
   563  		names[count] = d[0]
   564  		count++
   565  	}
   566  	return names[0:count]
   567  }
   568  
   569  // Check that reading a directory one entry at a time gives the same result
   570  // as reading it all at once.
   571  func TestReaddirnamesOneAtATime(t *testing.T) {
   572  	// big directory that doesn't change often.
   573  	dir := "/usr/bin"
   574  	switch runtime.GOOS {
   575  	case "android":
   576  		dir = "/system/bin"
   577  	case "darwin", "ios":
   578  		switch runtime.GOARCH {
   579  		case "arm64":
   580  			wd, err := Getwd()
   581  			if err != nil {
   582  				t.Fatal(err)
   583  			}
   584  			dir = wd
   585  		}
   586  	case "plan9":
   587  		dir = "/bin"
   588  	case "windows":
   589  		dir = Getenv("SystemRoot") + "\\system32"
   590  	}
   591  	file, err := Open(dir)
   592  	if err != nil {
   593  		t.Fatalf("open %q failed: %v", dir, err)
   594  	}
   595  	defer file.Close()
   596  	all, err1 := file.Readdirnames(-1)
   597  	if err1 != nil {
   598  		t.Fatalf("readdirnames %q failed: %v", dir, err1)
   599  	}
   600  	file1, err2 := Open(dir)
   601  	if err2 != nil {
   602  		t.Fatalf("open %q failed: %v", dir, err2)
   603  	}
   604  	defer file1.Close()
   605  	small := smallReaddirnames(file1, len(all)+100, t) // +100 in case we screw up
   606  	if len(small) < len(all) {
   607  		t.Fatalf("len(small) is %d, less than %d", len(small), len(all))
   608  	}
   609  	for i, n := range all {
   610  		if small[i] != n {
   611  			t.Errorf("small read %q mismatch: %v", small[i], n)
   612  		}
   613  	}
   614  }
   615  
   616  func TestReaddirNValues(t *testing.T) {
   617  	if testing.Short() {
   618  		t.Skip("test.short; skipping")
   619  	}
   620  	dir := t.TempDir()
   621  	for i := 1; i <= 105; i++ {
   622  		f, err := Create(filepath.Join(dir, fmt.Sprintf("%d", i)))
   623  		if err != nil {
   624  			t.Fatalf("Create: %v", err)
   625  		}
   626  		f.Write([]byte(strings.Repeat("X", i)))
   627  		f.Close()
   628  	}
   629  
   630  	var d *File
   631  	openDir := func() {
   632  		var err error
   633  		d, err = Open(dir)
   634  		if err != nil {
   635  			t.Fatalf("Open directory: %v", err)
   636  		}
   637  	}
   638  
   639  	readdirExpect := func(n, want int, wantErr error) {
   640  		t.Helper()
   641  		fi, err := d.Readdir(n)
   642  		if err != wantErr {
   643  			t.Fatalf("Readdir of %d got error %v, want %v", n, err, wantErr)
   644  		}
   645  		if g, e := len(fi), want; g != e {
   646  			t.Errorf("Readdir of %d got %d files, want %d", n, g, e)
   647  		}
   648  	}
   649  
   650  	readDirExpect := func(n, want int, wantErr error) {
   651  		t.Helper()
   652  		de, err := d.ReadDir(n)
   653  		if err != wantErr {
   654  			t.Fatalf("ReadDir of %d got error %v, want %v", n, err, wantErr)
   655  		}
   656  		if g, e := len(de), want; g != e {
   657  			t.Errorf("ReadDir of %d got %d files, want %d", n, g, e)
   658  		}
   659  	}
   660  
   661  	readdirnamesExpect := func(n, want int, wantErr error) {
   662  		t.Helper()
   663  		fi, err := d.Readdirnames(n)
   664  		if err != wantErr {
   665  			t.Fatalf("Readdirnames of %d got error %v, want %v", n, err, wantErr)
   666  		}
   667  		if g, e := len(fi), want; g != e {
   668  			t.Errorf("Readdirnames of %d got %d files, want %d", n, g, e)
   669  		}
   670  	}
   671  
   672  	for _, fn := range []func(int, int, error){readdirExpect, readdirnamesExpect, readDirExpect} {
   673  		// Test the slurp case
   674  		openDir()
   675  		fn(0, 105, nil)
   676  		fn(0, 0, nil)
   677  		d.Close()
   678  
   679  		// Slurp with -1 instead
   680  		openDir()
   681  		fn(-1, 105, nil)
   682  		fn(-2, 0, nil)
   683  		fn(0, 0, nil)
   684  		d.Close()
   685  
   686  		// Test the bounded case
   687  		openDir()
   688  		fn(1, 1, nil)
   689  		fn(2, 2, nil)
   690  		fn(105, 102, nil) // and tests buffer >100 case
   691  		fn(3, 0, io.EOF)
   692  		d.Close()
   693  	}
   694  }
   695  
   696  func touch(t *testing.T, name string) {
   697  	f, err := Create(name)
   698  	if err != nil {
   699  		t.Fatal(err)
   700  	}
   701  	if err := f.Close(); err != nil {
   702  		t.Fatal(err)
   703  	}
   704  }
   705  
   706  func TestReaddirStatFailures(t *testing.T) {
   707  	switch runtime.GOOS {
   708  	case "windows", "plan9":
   709  		// Windows and Plan 9 already do this correctly,
   710  		// but are structured with different syscalls such
   711  		// that they don't use Lstat, so the hook below for
   712  		// testing it wouldn't work.
   713  		t.Skipf("skipping test on %v", runtime.GOOS)
   714  	}
   715  	dir := t.TempDir()
   716  	touch(t, filepath.Join(dir, "good1"))
   717  	touch(t, filepath.Join(dir, "x")) // will disappear or have an error
   718  	touch(t, filepath.Join(dir, "good2"))
   719  	defer func() {
   720  		*LstatP = Lstat
   721  	}()
   722  	var xerr error // error to return for x
   723  	*LstatP = func(path string) (FileInfo, error) {
   724  		if xerr != nil && strings.HasSuffix(path, "x") {
   725  			return nil, xerr
   726  		}
   727  		return Lstat(path)
   728  	}
   729  	readDir := func() ([]FileInfo, error) {
   730  		d, err := Open(dir)
   731  		if err != nil {
   732  			t.Fatal(err)
   733  		}
   734  		defer d.Close()
   735  		return d.Readdir(-1)
   736  	}
   737  	mustReadDir := func(testName string) []FileInfo {
   738  		fis, err := readDir()
   739  		if err != nil {
   740  			t.Fatalf("%s: Readdir: %v", testName, err)
   741  		}
   742  		return fis
   743  	}
   744  	names := func(fis []FileInfo) []string {
   745  		s := make([]string, len(fis))
   746  		for i, fi := range fis {
   747  			s[i] = fi.Name()
   748  		}
   749  		sort.Strings(s)
   750  		return s
   751  	}
   752  
   753  	if got, want := names(mustReadDir("initial readdir")),
   754  		[]string{"good1", "good2", "x"}; !reflect.DeepEqual(got, want) {
   755  		t.Errorf("initial readdir got %q; want %q", got, want)
   756  	}
   757  
   758  	xerr = ErrNotExist
   759  	if got, want := names(mustReadDir("with x disappearing")),
   760  		[]string{"good1", "good2"}; !reflect.DeepEqual(got, want) {
   761  		t.Errorf("with x disappearing, got %q; want %q", got, want)
   762  	}
   763  
   764  	xerr = errors.New("some real error")
   765  	if _, err := readDir(); err != xerr {
   766  		t.Errorf("with a non-ErrNotExist error, got error %v; want %v", err, xerr)
   767  	}
   768  }
   769  
   770  // Readdir on a regular file should fail.
   771  func TestReaddirOfFile(t *testing.T) {
   772  	f, err := os.CreateTemp("", "_Go_ReaddirOfFile")
   773  	if err != nil {
   774  		t.Fatal(err)
   775  	}
   776  	defer Remove(f.Name())
   777  	f.Write([]byte("foo"))
   778  	f.Close()
   779  	reg, err := Open(f.Name())
   780  	if err != nil {
   781  		t.Fatal(err)
   782  	}
   783  	defer reg.Close()
   784  
   785  	names, err := reg.Readdirnames(-1)
   786  	if err == nil {
   787  		t.Error("Readdirnames succeeded; want non-nil error")
   788  	}
   789  	var pe *PathError
   790  	if !errors.As(err, &pe) || pe.Path != f.Name() {
   791  		t.Errorf("Readdirnames returned %q; want a PathError with path %q", err, f.Name())
   792  	}
   793  	if len(names) > 0 {
   794  		t.Errorf("unexpected dir names in regular file: %q", names)
   795  	}
   796  }
   797  
   798  func TestHardLink(t *testing.T) {
   799  	testenv.MustHaveLink(t)
   800  
   801  	defer chtmpdir(t)()
   802  	from, to := "hardlinktestfrom", "hardlinktestto"
   803  	file, err := Create(to)
   804  	if err != nil {
   805  		t.Fatalf("open %q failed: %v", to, err)
   806  	}
   807  	if err = file.Close(); err != nil {
   808  		t.Errorf("close %q failed: %v", to, err)
   809  	}
   810  	err = Link(to, from)
   811  	if err != nil {
   812  		t.Fatalf("link %q, %q failed: %v", to, from, err)
   813  	}
   814  
   815  	none := "hardlinktestnone"
   816  	err = Link(none, none)
   817  	// Check the returned error is well-formed.
   818  	if lerr, ok := err.(*LinkError); !ok || lerr.Error() == "" {
   819  		t.Errorf("link %q, %q failed to return a valid error", none, none)
   820  	}
   821  
   822  	tostat, err := Stat(to)
   823  	if err != nil {
   824  		t.Fatalf("stat %q failed: %v", to, err)
   825  	}
   826  	fromstat, err := Stat(from)
   827  	if err != nil {
   828  		t.Fatalf("stat %q failed: %v", from, err)
   829  	}
   830  	if !SameFile(tostat, fromstat) {
   831  		t.Errorf("link %q, %q did not create hard link", to, from)
   832  	}
   833  	// We should not be able to perform the same Link() a second time
   834  	err = Link(to, from)
   835  	switch err := err.(type) {
   836  	case *LinkError:
   837  		if err.Op != "link" {
   838  			t.Errorf("Link(%q, %q) err.Op = %q; want %q", to, from, err.Op, "link")
   839  		}
   840  		if err.Old != to {
   841  			t.Errorf("Link(%q, %q) err.Old = %q; want %q", to, from, err.Old, to)
   842  		}
   843  		if err.New != from {
   844  			t.Errorf("Link(%q, %q) err.New = %q; want %q", to, from, err.New, from)
   845  		}
   846  		if !IsExist(err.Err) {
   847  			t.Errorf("Link(%q, %q) err.Err = %q; want %q", to, from, err.Err, "file exists error")
   848  		}
   849  	case nil:
   850  		t.Errorf("link %q, %q: expected error, got nil", from, to)
   851  	default:
   852  		t.Errorf("link %q, %q: expected %T, got %T %v", from, to, new(LinkError), err, err)
   853  	}
   854  }
   855  
   856  // chtmpdir changes the working directory to a new temporary directory and
   857  // provides a cleanup function.
   858  func chtmpdir(t *testing.T) func() {
   859  	oldwd, err := Getwd()
   860  	if err != nil {
   861  		t.Fatalf("chtmpdir: %v", err)
   862  	}
   863  	d, err := os.MkdirTemp("", "test")
   864  	if err != nil {
   865  		t.Fatalf("chtmpdir: %v", err)
   866  	}
   867  	if err := Chdir(d); err != nil {
   868  		t.Fatalf("chtmpdir: %v", err)
   869  	}
   870  	return func() {
   871  		if err := Chdir(oldwd); err != nil {
   872  			t.Fatalf("chtmpdir: %v", err)
   873  		}
   874  		RemoveAll(d)
   875  	}
   876  }
   877  
   878  func TestSymlink(t *testing.T) {
   879  	testenv.MustHaveSymlink(t)
   880  
   881  	defer chtmpdir(t)()
   882  	from, to := "symlinktestfrom", "symlinktestto"
   883  	file, err := Create(to)
   884  	if err != nil {
   885  		t.Fatalf("Create(%q) failed: %v", to, err)
   886  	}
   887  	if err = file.Close(); err != nil {
   888  		t.Errorf("Close(%q) failed: %v", to, err)
   889  	}
   890  	err = Symlink(to, from)
   891  	if err != nil {
   892  		t.Fatalf("Symlink(%q, %q) failed: %v", to, from, err)
   893  	}
   894  	tostat, err := Lstat(to)
   895  	if err != nil {
   896  		t.Fatalf("Lstat(%q) failed: %v", to, err)
   897  	}
   898  	if tostat.Mode()&ModeSymlink != 0 {
   899  		t.Fatalf("Lstat(%q).Mode()&ModeSymlink = %v, want 0", to, tostat.Mode()&ModeSymlink)
   900  	}
   901  	fromstat, err := Stat(from)
   902  	if err != nil {
   903  		t.Fatalf("Stat(%q) failed: %v", from, err)
   904  	}
   905  	if !SameFile(tostat, fromstat) {
   906  		t.Errorf("Symlink(%q, %q) did not create symlink", to, from)
   907  	}
   908  	fromstat, err = Lstat(from)
   909  	if err != nil {
   910  		t.Fatalf("Lstat(%q) failed: %v", from, err)
   911  	}
   912  	if fromstat.Mode()&ModeSymlink == 0 {
   913  		t.Fatalf("Lstat(%q).Mode()&ModeSymlink = 0, want %v", from, ModeSymlink)
   914  	}
   915  	fromstat, err = Stat(from)
   916  	if err != nil {
   917  		t.Fatalf("Stat(%q) failed: %v", from, err)
   918  	}
   919  	if fromstat.Name() != from {
   920  		t.Errorf("Stat(%q).Name() = %q, want %q", from, fromstat.Name(), from)
   921  	}
   922  	if fromstat.Mode()&ModeSymlink != 0 {
   923  		t.Fatalf("Stat(%q).Mode()&ModeSymlink = %v, want 0", from, fromstat.Mode()&ModeSymlink)
   924  	}
   925  	s, err := Readlink(from)
   926  	if err != nil {
   927  		t.Fatalf("Readlink(%q) failed: %v", from, err)
   928  	}
   929  	if s != to {
   930  		t.Fatalf("Readlink(%q) = %q, want %q", from, s, to)
   931  	}
   932  	file, err = Open(from)
   933  	if err != nil {
   934  		t.Fatalf("Open(%q) failed: %v", from, err)
   935  	}
   936  	file.Close()
   937  }
   938  
   939  func TestLongSymlink(t *testing.T) {
   940  	testenv.MustHaveSymlink(t)
   941  
   942  	defer chtmpdir(t)()
   943  	s := "0123456789abcdef"
   944  	// Long, but not too long: a common limit is 255.
   945  	s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s
   946  	from := "longsymlinktestfrom"
   947  	err := Symlink(s, from)
   948  	if err != nil {
   949  		t.Fatalf("symlink %q, %q failed: %v", s, from, err)
   950  	}
   951  	r, err := Readlink(from)
   952  	if err != nil {
   953  		t.Fatalf("readlink %q failed: %v", from, err)
   954  	}
   955  	if r != s {
   956  		t.Fatalf("after symlink %q != %q", r, s)
   957  	}
   958  }
   959  
   960  func TestRename(t *testing.T) {
   961  	defer chtmpdir(t)()
   962  	from, to := "renamefrom", "renameto"
   963  
   964  	file, err := Create(from)
   965  	if err != nil {
   966  		t.Fatalf("open %q failed: %v", from, err)
   967  	}
   968  	if err = file.Close(); err != nil {
   969  		t.Errorf("close %q failed: %v", from, err)
   970  	}
   971  	err = Rename(from, to)
   972  	if err != nil {
   973  		t.Fatalf("rename %q, %q failed: %v", to, from, err)
   974  	}
   975  	_, err = Stat(to)
   976  	if err != nil {
   977  		t.Errorf("stat %q failed: %v", to, err)
   978  	}
   979  }
   980  
   981  func TestRenameOverwriteDest(t *testing.T) {
   982  	defer chtmpdir(t)()
   983  	from, to := "renamefrom", "renameto"
   984  
   985  	toData := []byte("to")
   986  	fromData := []byte("from")
   987  
   988  	err := os.WriteFile(to, toData, 0777)
   989  	if err != nil {
   990  		t.Fatalf("write file %q failed: %v", to, err)
   991  	}
   992  
   993  	err = os.WriteFile(from, fromData, 0777)
   994  	if err != nil {
   995  		t.Fatalf("write file %q failed: %v", from, err)
   996  	}
   997  	err = Rename(from, to)
   998  	if err != nil {
   999  		t.Fatalf("rename %q, %q failed: %v", to, from, err)
  1000  	}
  1001  
  1002  	_, err = Stat(from)
  1003  	if err == nil {
  1004  		t.Errorf("from file %q still exists", from)
  1005  	}
  1006  	if err != nil && !IsNotExist(err) {
  1007  		t.Fatalf("stat from: %v", err)
  1008  	}
  1009  	toFi, err := Stat(to)
  1010  	if err != nil {
  1011  		t.Fatalf("stat %q failed: %v", to, err)
  1012  	}
  1013  	if toFi.Size() != int64(len(fromData)) {
  1014  		t.Errorf(`"to" size = %d; want %d (old "from" size)`, toFi.Size(), len(fromData))
  1015  	}
  1016  }
  1017  
  1018  func TestRenameFailed(t *testing.T) {
  1019  	defer chtmpdir(t)()
  1020  	from, to := "renamefrom", "renameto"
  1021  
  1022  	err := Rename(from, to)
  1023  	switch err := err.(type) {
  1024  	case *LinkError:
  1025  		if err.Op != "rename" {
  1026  			t.Errorf("rename %q, %q: err.Op: want %q, got %q", from, to, "rename", err.Op)
  1027  		}
  1028  		if err.Old != from {
  1029  			t.Errorf("rename %q, %q: err.Old: want %q, got %q", from, to, from, err.Old)
  1030  		}
  1031  		if err.New != to {
  1032  			t.Errorf("rename %q, %q: err.New: want %q, got %q", from, to, to, err.New)
  1033  		}
  1034  	case nil:
  1035  		t.Errorf("rename %q, %q: expected error, got nil", from, to)
  1036  	default:
  1037  		t.Errorf("rename %q, %q: expected %T, got %T %v", from, to, new(LinkError), err, err)
  1038  	}
  1039  }
  1040  
  1041  func TestRenameNotExisting(t *testing.T) {
  1042  	defer chtmpdir(t)()
  1043  	from, to := "doesnt-exist", "dest"
  1044  
  1045  	Mkdir(to, 0777)
  1046  
  1047  	if err := Rename(from, to); !IsNotExist(err) {
  1048  		t.Errorf("Rename(%q, %q) = %v; want an IsNotExist error", from, to, err)
  1049  	}
  1050  }
  1051  
  1052  func TestRenameToDirFailed(t *testing.T) {
  1053  	defer chtmpdir(t)()
  1054  	from, to := "renamefrom", "renameto"
  1055  
  1056  	Mkdir(from, 0777)
  1057  	Mkdir(to, 0777)
  1058  
  1059  	err := Rename(from, to)
  1060  	switch err := err.(type) {
  1061  	case *LinkError:
  1062  		if err.Op != "rename" {
  1063  			t.Errorf("rename %q, %q: err.Op: want %q, got %q", from, to, "rename", err.Op)
  1064  		}
  1065  		if err.Old != from {
  1066  			t.Errorf("rename %q, %q: err.Old: want %q, got %q", from, to, from, err.Old)
  1067  		}
  1068  		if err.New != to {
  1069  			t.Errorf("rename %q, %q: err.New: want %q, got %q", from, to, to, err.New)
  1070  		}
  1071  	case nil:
  1072  		t.Errorf("rename %q, %q: expected error, got nil", from, to)
  1073  	default:
  1074  		t.Errorf("rename %q, %q: expected %T, got %T %v", from, to, new(LinkError), err, err)
  1075  	}
  1076  }
  1077  
  1078  func TestRenameCaseDifference(pt *testing.T) {
  1079  	from, to := "renameFROM", "RENAMEfrom"
  1080  	tests := []struct {
  1081  		name   string
  1082  		create func() error
  1083  	}{
  1084  		{"dir", func() error {
  1085  			return Mkdir(from, 0777)
  1086  		}},
  1087  		{"file", func() error {
  1088  			fd, err := Create(from)
  1089  			if err != nil {
  1090  				return err
  1091  			}
  1092  			return fd.Close()
  1093  		}},
  1094  	}
  1095  
  1096  	for _, test := range tests {
  1097  		pt.Run(test.name, func(t *testing.T) {
  1098  			defer chtmpdir(t)()
  1099  
  1100  			if err := test.create(); err != nil {
  1101  				t.Fatalf("failed to create test file: %s", err)
  1102  			}
  1103  
  1104  			if _, err := Stat(to); err != nil {
  1105  				// Sanity check that the underlying filesystem is not case sensitive.
  1106  				if IsNotExist(err) {
  1107  					t.Skipf("case sensitive filesystem")
  1108  				}
  1109  				t.Fatalf("stat %q, got: %q", to, err)
  1110  			}
  1111  
  1112  			if err := Rename(from, to); err != nil {
  1113  				t.Fatalf("unexpected error when renaming from %q to %q: %s", from, to, err)
  1114  			}
  1115  
  1116  			fd, err := Open(".")
  1117  			if err != nil {
  1118  				t.Fatalf("Open .: %s", err)
  1119  			}
  1120  
  1121  			// Stat does not return the real case of the file (it returns what the called asked for)
  1122  			// So we have to use readdir to get the real name of the file.
  1123  			dirNames, err := fd.Readdirnames(-1)
  1124  			if err != nil {
  1125  				t.Fatalf("readdirnames: %s", err)
  1126  			}
  1127  
  1128  			if dirNamesLen := len(dirNames); dirNamesLen != 1 {
  1129  				t.Fatalf("unexpected dirNames len, got %q, want %q", dirNamesLen, 1)
  1130  			}
  1131  
  1132  			if dirNames[0] != to {
  1133  				t.Errorf("unexpected name, got %q, want %q", dirNames[0], to)
  1134  			}
  1135  		})
  1136  	}
  1137  }
  1138  
  1139  func exec(t *testing.T, dir, cmd string, args []string, expect string) {
  1140  	r, w, err := Pipe()
  1141  	if err != nil {
  1142  		t.Fatalf("Pipe: %v", err)
  1143  	}
  1144  	defer r.Close()
  1145  	attr := &ProcAttr{Dir: dir, Files: []*File{nil, w, Stderr}}
  1146  	p, err := StartProcess(cmd, args, attr)
  1147  	if err != nil {
  1148  		t.Fatalf("StartProcess: %v", err)
  1149  	}
  1150  	w.Close()
  1151  
  1152  	var b bytes.Buffer
  1153  	io.Copy(&b, r)
  1154  	output := b.String()
  1155  
  1156  	fi1, _ := Stat(strings.TrimSpace(output))
  1157  	fi2, _ := Stat(expect)
  1158  	if !SameFile(fi1, fi2) {
  1159  		t.Errorf("exec %q returned %q wanted %q",
  1160  			strings.Join(append([]string{cmd}, args...), " "), output, expect)
  1161  	}
  1162  	p.Wait()
  1163  }
  1164  
  1165  func TestStartProcess(t *testing.T) {
  1166  	testenv.MustHaveExec(t)
  1167  
  1168  	var dir, cmd string
  1169  	var args []string
  1170  	switch runtime.GOOS {
  1171  	case "android":
  1172  		t.Skip("android doesn't have /bin/pwd")
  1173  	case "windows":
  1174  		cmd = Getenv("COMSPEC")
  1175  		dir = Getenv("SystemRoot")
  1176  		args = []string{"/c", "cd"}
  1177  	default:
  1178  		var err error
  1179  		cmd, err = osexec.LookPath("pwd")
  1180  		if err != nil {
  1181  			t.Fatalf("Can't find pwd: %v", err)
  1182  		}
  1183  		dir = "/"
  1184  		args = []string{}
  1185  		t.Logf("Testing with %v", cmd)
  1186  	}
  1187  	cmddir, cmdbase := filepath.Split(cmd)
  1188  	args = append([]string{cmdbase}, args...)
  1189  	// Test absolute executable path.
  1190  	exec(t, dir, cmd, args, dir)
  1191  	// Test relative executable path.
  1192  	exec(t, cmddir, cmdbase, args, cmddir)
  1193  }
  1194  
  1195  func checkMode(t *testing.T, path string, mode FileMode) {
  1196  	dir, err := Stat(path)
  1197  	if err != nil {
  1198  		t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
  1199  	}
  1200  	if dir.Mode()&ModePerm != mode {
  1201  		t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode(), mode)
  1202  	}
  1203  }
  1204  
  1205  func TestChmod(t *testing.T) {
  1206  	f := newFile("TestChmod", t)
  1207  	defer Remove(f.Name())
  1208  	defer f.Close()
  1209  	// Creation mode is read write
  1210  
  1211  	fm := FileMode(0456)
  1212  	if runtime.GOOS == "windows" {
  1213  		fm = FileMode(0444) // read-only file
  1214  	}
  1215  	if err := Chmod(f.Name(), fm); err != nil {
  1216  		t.Fatalf("chmod %s %#o: %s", f.Name(), fm, err)
  1217  	}
  1218  	checkMode(t, f.Name(), fm)
  1219  
  1220  	fm = FileMode(0123)
  1221  	if runtime.GOOS == "windows" {
  1222  		fm = FileMode(0666) // read-write file
  1223  	}
  1224  	if err := f.Chmod(fm); err != nil {
  1225  		t.Fatalf("chmod %s %#o: %s", f.Name(), fm, err)
  1226  	}
  1227  	checkMode(t, f.Name(), fm)
  1228  }
  1229  
  1230  func checkSize(t *testing.T, f *File, size int64) {
  1231  	t.Helper()
  1232  	dir, err := f.Stat()
  1233  	if err != nil {
  1234  		t.Fatalf("Stat %q (looking for size %d): %s", f.Name(), size, err)
  1235  	}
  1236  	if dir.Size() != size {
  1237  		t.Errorf("Stat %q: size %d want %d", f.Name(), dir.Size(), size)
  1238  	}
  1239  }
  1240  
  1241  func TestFTruncate(t *testing.T) {
  1242  	f := newFile("TestFTruncate", t)
  1243  	defer Remove(f.Name())
  1244  	defer f.Close()
  1245  
  1246  	checkSize(t, f, 0)
  1247  	f.Write([]byte("hello, world\n"))
  1248  	checkSize(t, f, 13)
  1249  	f.Truncate(10)
  1250  	checkSize(t, f, 10)
  1251  	f.Truncate(1024)
  1252  	checkSize(t, f, 1024)
  1253  	f.Truncate(0)
  1254  	checkSize(t, f, 0)
  1255  	_, err := f.Write([]byte("surprise!"))
  1256  	if err == nil {
  1257  		checkSize(t, f, 13+9) // wrote at offset past where hello, world was.
  1258  	}
  1259  }
  1260  
  1261  func TestTruncate(t *testing.T) {
  1262  	f := newFile("TestTruncate", t)
  1263  	defer Remove(f.Name())
  1264  	defer f.Close()
  1265  
  1266  	checkSize(t, f, 0)
  1267  	f.Write([]byte("hello, world\n"))
  1268  	checkSize(t, f, 13)
  1269  	Truncate(f.Name(), 10)
  1270  	checkSize(t, f, 10)
  1271  	Truncate(f.Name(), 1024)
  1272  	checkSize(t, f, 1024)
  1273  	Truncate(f.Name(), 0)
  1274  	checkSize(t, f, 0)
  1275  	_, err := f.Write([]byte("surprise!"))
  1276  	if err == nil {
  1277  		checkSize(t, f, 13+9) // wrote at offset past where hello, world was.
  1278  	}
  1279  }
  1280  
  1281  // Use TempDir (via newFile) to make sure we're on a local file system,
  1282  // so that timings are not distorted by latency and caching.
  1283  // On NFS, timings can be off due to caching of meta-data on
  1284  // NFS servers (Issue 848).
  1285  func TestChtimes(t *testing.T) {
  1286  	f := newFile("TestChtimes", t)
  1287  	defer Remove(f.Name())
  1288  
  1289  	f.Write([]byte("hello, world\n"))
  1290  	f.Close()
  1291  
  1292  	testChtimes(t, f.Name())
  1293  }
  1294  
  1295  // Use TempDir (via newDir) to make sure we're on a local file system,
  1296  // so that timings are not distorted by latency and caching.
  1297  // On NFS, timings can be off due to caching of meta-data on
  1298  // NFS servers (Issue 848).
  1299  func TestChtimesDir(t *testing.T) {
  1300  	name := newDir("TestChtimes", t)
  1301  	defer RemoveAll(name)
  1302  
  1303  	testChtimes(t, name)
  1304  }
  1305  
  1306  func testChtimes(t *testing.T, name string) {
  1307  	st, err := Stat(name)
  1308  	if err != nil {
  1309  		t.Fatalf("Stat %s: %s", name, err)
  1310  	}
  1311  	preStat := st
  1312  
  1313  	// Move access and modification time back a second
  1314  	at := Atime(preStat)
  1315  	mt := preStat.ModTime()
  1316  	err = Chtimes(name, at.Add(-time.Second), mt.Add(-time.Second))
  1317  	if err != nil {
  1318  		t.Fatalf("Chtimes %s: %s", name, err)
  1319  	}
  1320  
  1321  	st, err = Stat(name)
  1322  	if err != nil {
  1323  		t.Fatalf("second Stat %s: %s", name, err)
  1324  	}
  1325  	postStat := st
  1326  
  1327  	pat := Atime(postStat)
  1328  	pmt := postStat.ModTime()
  1329  	if !pat.Before(at) {
  1330  		switch runtime.GOOS {
  1331  		case "plan9":
  1332  			// Mtime is the time of the last change of
  1333  			// content.  Similarly, atime is set whenever
  1334  			// the contents are accessed; also, it is set
  1335  			// whenever mtime is set.
  1336  		case "netbsd":
  1337  			mounts, _ := os.ReadFile("/proc/mounts")
  1338  			if strings.Contains(string(mounts), "noatime") {
  1339  				t.Logf("AccessTime didn't go backwards, but see a filesystem mounted noatime; ignoring. Issue 19293.")
  1340  			} else {
  1341  				t.Logf("AccessTime didn't go backwards; was=%v, after=%v (Ignoring on NetBSD, assuming noatime, Issue 19293)", at, pat)
  1342  			}
  1343  		default:
  1344  			t.Errorf("AccessTime didn't go backwards; was=%v, after=%v", at, pat)
  1345  		}
  1346  	}
  1347  
  1348  	if !pmt.Before(mt) {
  1349  		t.Errorf("ModTime didn't go backwards; was=%v, after=%v", mt, pmt)
  1350  	}
  1351  }
  1352  
  1353  func TestFileChdir(t *testing.T) {
  1354  	// TODO(brainman): file.Chdir() is not implemented on windows.
  1355  	if runtime.GOOS == "windows" {
  1356  		return
  1357  	}
  1358  
  1359  	wd, err := Getwd()
  1360  	if err != nil {
  1361  		t.Fatalf("Getwd: %s", err)
  1362  	}
  1363  	defer Chdir(wd)
  1364  
  1365  	fd, err := Open(".")
  1366  	if err != nil {
  1367  		t.Fatalf("Open .: %s", err)
  1368  	}
  1369  	defer fd.Close()
  1370  
  1371  	if err := Chdir("/"); err != nil {
  1372  		t.Fatalf("Chdir /: %s", err)
  1373  	}
  1374  
  1375  	if err := fd.Chdir(); err != nil {
  1376  		t.Fatalf("fd.Chdir: %s", err)
  1377  	}
  1378  
  1379  	wdNew, err := Getwd()
  1380  	if err != nil {
  1381  		t.Fatalf("Getwd: %s", err)
  1382  	}
  1383  	if wdNew != wd {
  1384  		t.Fatalf("fd.Chdir failed, got %s, want %s", wdNew, wd)
  1385  	}
  1386  }
  1387  
  1388  func TestChdirAndGetwd(t *testing.T) {
  1389  	// TODO(brainman): file.Chdir() is not implemented on windows.
  1390  	if runtime.GOOS == "windows" {
  1391  		return
  1392  	}
  1393  	fd, err := Open(".")
  1394  	if err != nil {
  1395  		t.Fatalf("Open .: %s", err)
  1396  	}
  1397  	// These are chosen carefully not to be symlinks on a Mac
  1398  	// (unlike, say, /var, /etc), except /tmp, which we handle below.
  1399  	dirs := []string{"/", "/usr/bin", "/tmp"}
  1400  	// /usr/bin does not usually exist on Plan 9 or Android.
  1401  	switch runtime.GOOS {
  1402  	case "android":
  1403  		dirs = []string{"/system/bin"}
  1404  	case "plan9":
  1405  		dirs = []string{"/", "/usr"}
  1406  	case "darwin", "ios":
  1407  		switch runtime.GOARCH {
  1408  		case "arm64":
  1409  			dirs = nil
  1410  			for _, d := range []string{"d1", "d2"} {
  1411  				dir, err := os.MkdirTemp("", d)
  1412  				if err != nil {
  1413  					t.Fatalf("TempDir: %v", err)
  1414  				}
  1415  				// Expand symlinks so path equality tests work.
  1416  				dir, err = filepath.EvalSymlinks(dir)
  1417  				if err != nil {
  1418  					t.Fatalf("EvalSymlinks: %v", err)
  1419  				}
  1420  				dirs = append(dirs, dir)
  1421  			}
  1422  		}
  1423  	}
  1424  	oldwd := Getenv("PWD")
  1425  	for mode := 0; mode < 2; mode++ {
  1426  		for _, d := range dirs {
  1427  			if mode == 0 {
  1428  				err = Chdir(d)
  1429  			} else {
  1430  				fd1, err1 := Open(d)
  1431  				if err1 != nil {
  1432  					t.Errorf("Open %s: %s", d, err1)
  1433  					continue
  1434  				}
  1435  				err = fd1.Chdir()
  1436  				fd1.Close()
  1437  			}
  1438  			if d == "/tmp" {
  1439  				Setenv("PWD", "/tmp")
  1440  			}
  1441  			pwd, err1 := Getwd()
  1442  			Setenv("PWD", oldwd)
  1443  			err2 := fd.Chdir()
  1444  			if err2 != nil {
  1445  				// We changed the current directory and cannot go back.
  1446  				// Don't let the tests continue; they'll scribble
  1447  				// all over some other directory.
  1448  				fmt.Fprintf(Stderr, "fchdir back to dot failed: %s\n", err2)
  1449  				Exit(1)
  1450  			}
  1451  			if err != nil {
  1452  				fd.Close()
  1453  				t.Fatalf("Chdir %s: %s", d, err)
  1454  			}
  1455  			if err1 != nil {
  1456  				fd.Close()
  1457  				t.Fatalf("Getwd in %s: %s", d, err1)
  1458  			}
  1459  			if pwd != d {
  1460  				fd.Close()
  1461  				t.Fatalf("Getwd returned %q want %q", pwd, d)
  1462  			}
  1463  		}
  1464  	}
  1465  	fd.Close()
  1466  }
  1467  
  1468  // Test that Chdir+Getwd is program-wide.
  1469  func TestProgWideChdir(t *testing.T) {
  1470  	const N = 10
  1471  	const ErrPwd = "Error!"
  1472  	c := make(chan bool)
  1473  	cpwd := make(chan string, N)
  1474  	for i := 0; i < N; i++ {
  1475  		go func(i int) {
  1476  			// Lock half the goroutines in their own operating system
  1477  			// thread to exercise more scheduler possibilities.
  1478  			if i%2 == 1 {
  1479  				// On Plan 9, after calling LockOSThread, the goroutines
  1480  				// run on different processes which don't share the working
  1481  				// directory. This used to be an issue because Go expects
  1482  				// the working directory to be program-wide.
  1483  				// See issue 9428.
  1484  				runtime.LockOSThread()
  1485  			}
  1486  			hasErr, closed := <-c
  1487  			if !closed && hasErr {
  1488  				cpwd <- ErrPwd
  1489  				return
  1490  			}
  1491  			pwd, err := Getwd()
  1492  			if err != nil {
  1493  				t.Errorf("Getwd on goroutine %d: %v", i, err)
  1494  				cpwd <- ErrPwd
  1495  				return
  1496  			}
  1497  			cpwd <- pwd
  1498  		}(i)
  1499  	}
  1500  	oldwd, err := Getwd()
  1501  	if err != nil {
  1502  		c <- true
  1503  		t.Fatalf("Getwd: %v", err)
  1504  	}
  1505  	d, err := os.MkdirTemp("", "test")
  1506  	if err != nil {
  1507  		c <- true
  1508  		t.Fatalf("TempDir: %v", err)
  1509  	}
  1510  	defer func() {
  1511  		if err := Chdir(oldwd); err != nil {
  1512  			t.Fatalf("Chdir: %v", err)
  1513  		}
  1514  		RemoveAll(d)
  1515  	}()
  1516  	if err := Chdir(d); err != nil {
  1517  		c <- true
  1518  		t.Fatalf("Chdir: %v", err)
  1519  	}
  1520  	// OS X sets TMPDIR to a symbolic link.
  1521  	// So we resolve our working directory again before the test.
  1522  	d, err = Getwd()
  1523  	if err != nil {
  1524  		c <- true
  1525  		t.Fatalf("Getwd: %v", err)
  1526  	}
  1527  	close(c)
  1528  	for i := 0; i < N; i++ {
  1529  		pwd := <-cpwd
  1530  		if pwd == ErrPwd {
  1531  			t.FailNow()
  1532  		}
  1533  		if pwd != d {
  1534  			t.Errorf("Getwd returned %q; want %q", pwd, d)
  1535  		}
  1536  	}
  1537  }
  1538  
  1539  func TestSeek(t *testing.T) {
  1540  	f := newFile("TestSeek", t)
  1541  	defer Remove(f.Name())
  1542  	defer f.Close()
  1543  
  1544  	const data = "hello, world\n"
  1545  	io.WriteString(f, data)
  1546  
  1547  	type test struct {
  1548  		in     int64
  1549  		whence int
  1550  		out    int64
  1551  	}
  1552  	var tests = []test{
  1553  		{0, io.SeekCurrent, int64(len(data))},
  1554  		{0, io.SeekStart, 0},
  1555  		{5, io.SeekStart, 5},
  1556  		{0, io.SeekEnd, int64(len(data))},
  1557  		{0, io.SeekStart, 0},
  1558  		{-1, io.SeekEnd, int64(len(data)) - 1},
  1559  		{1 << 33, io.SeekStart, 1 << 33},
  1560  		{1 << 33, io.SeekEnd, 1<<33 + int64(len(data))},
  1561  
  1562  		// Issue 21681, Windows 4G-1, etc:
  1563  		{1<<32 - 1, io.SeekStart, 1<<32 - 1},
  1564  		{0, io.SeekCurrent, 1<<32 - 1},
  1565  		{2<<32 - 1, io.SeekStart, 2<<32 - 1},
  1566  		{0, io.SeekCurrent, 2<<32 - 1},
  1567  	}
  1568  	for i, tt := range tests {
  1569  		off, err := f.Seek(tt.in, tt.whence)
  1570  		if off != tt.out || err != nil {
  1571  			if e, ok := err.(*PathError); ok && e.Err == syscall.EINVAL && tt.out > 1<<32 && runtime.GOOS == "linux" {
  1572  				mounts, _ := os.ReadFile("/proc/mounts")
  1573  				if strings.Contains(string(mounts), "reiserfs") {
  1574  					// Reiserfs rejects the big seeks.
  1575  					t.Skipf("skipping test known to fail on reiserfs; https://golang.org/issue/91")
  1576  				}
  1577  			}
  1578  			t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
  1579  		}
  1580  	}
  1581  }
  1582  
  1583  func TestSeekError(t *testing.T) {
  1584  	switch runtime.GOOS {
  1585  	case "js", "plan9":
  1586  		t.Skipf("skipping test on %v", runtime.GOOS)
  1587  	}
  1588  
  1589  	r, w, err := Pipe()
  1590  	if err != nil {
  1591  		t.Fatal(err)
  1592  	}
  1593  	_, err = r.Seek(0, 0)
  1594  	if err == nil {
  1595  		t.Fatal("Seek on pipe should fail")
  1596  	}
  1597  	if perr, ok := err.(*PathError); !ok || perr.Err != syscall.ESPIPE {
  1598  		t.Errorf("Seek returned error %v, want &PathError{Err: syscall.ESPIPE}", err)
  1599  	}
  1600  	_, err = w.Seek(0, 0)
  1601  	if err == nil {
  1602  		t.Fatal("Seek on pipe should fail")
  1603  	}
  1604  	if perr, ok := err.(*PathError); !ok || perr.Err != syscall.ESPIPE {
  1605  		t.Errorf("Seek returned error %v, want &PathError{Err: syscall.ESPIPE}", err)
  1606  	}
  1607  }
  1608  
  1609  type openErrorTest struct {
  1610  	path  string
  1611  	mode  int
  1612  	error error
  1613  }
  1614  
  1615  var openErrorTests = []openErrorTest{
  1616  	{
  1617  		sfdir + "/no-such-file",
  1618  		O_RDONLY,
  1619  		syscall.ENOENT,
  1620  	},
  1621  	{
  1622  		sfdir,
  1623  		O_WRONLY,
  1624  		syscall.EISDIR,
  1625  	},
  1626  	{
  1627  		sfdir + "/" + sfname + "/no-such-file",
  1628  		O_WRONLY,
  1629  		syscall.ENOTDIR,
  1630  	},
  1631  }
  1632  
  1633  func TestOpenError(t *testing.T) {
  1634  	for _, tt := range openErrorTests {
  1635  		f, err := OpenFile(tt.path, tt.mode, 0)
  1636  		if err == nil {
  1637  			t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode)
  1638  			f.Close()
  1639  			continue
  1640  		}
  1641  		perr, ok := err.(*PathError)
  1642  		if !ok {
  1643  			t.Errorf("Open(%q, %d) returns error of %T type; want *PathError", tt.path, tt.mode, err)
  1644  		}
  1645  		if perr.Err != tt.error {
  1646  			if runtime.GOOS == "plan9" {
  1647  				syscallErrStr := perr.Err.Error()
  1648  				expectedErrStr := strings.Replace(tt.error.Error(), "file ", "", 1)
  1649  				if !strings.HasSuffix(syscallErrStr, expectedErrStr) {
  1650  					// Some Plan 9 file servers incorrectly return
  1651  					// EACCES rather than EISDIR when a directory is
  1652  					// opened for write.
  1653  					if tt.error == syscall.EISDIR && strings.HasSuffix(syscallErrStr, syscall.EACCES.Error()) {
  1654  						continue
  1655  					}
  1656  					t.Errorf("Open(%q, %d) = _, %q; want suffix %q", tt.path, tt.mode, syscallErrStr, expectedErrStr)
  1657  				}
  1658  				continue
  1659  			}
  1660  			if runtime.GOOS == "dragonfly" {
  1661  				// DragonFly incorrectly returns EACCES rather
  1662  				// EISDIR when a directory is opened for write.
  1663  				if tt.error == syscall.EISDIR && perr.Err == syscall.EACCES {
  1664  					continue
  1665  				}
  1666  			}
  1667  			t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Err.Error(), tt.error.Error())
  1668  		}
  1669  	}
  1670  }
  1671  
  1672  func TestOpenNoName(t *testing.T) {
  1673  	f, err := Open("")
  1674  	if err == nil {
  1675  		f.Close()
  1676  		t.Fatal(`Open("") succeeded`)
  1677  	}
  1678  }
  1679  
  1680  func runBinHostname(t *testing.T) string {
  1681  	// Run /bin/hostname and collect output.
  1682  	r, w, err := Pipe()
  1683  	if err != nil {
  1684  		t.Fatal(err)
  1685  	}
  1686  	defer r.Close()
  1687  	const path = "/bin/hostname"
  1688  	argv := []string{"hostname"}
  1689  	if runtime.GOOS == "aix" {
  1690  		argv = []string{"hostname", "-s"}
  1691  	}
  1692  	p, err := StartProcess(path, argv, &ProcAttr{Files: []*File{nil, w, Stderr}})
  1693  	if err != nil {
  1694  		if _, err := Stat(path); IsNotExist(err) {
  1695  			t.Skipf("skipping test; test requires %s but it does not exist", path)
  1696  		}
  1697  		t.Fatal(err)
  1698  	}
  1699  	w.Close()
  1700  
  1701  	var b bytes.Buffer
  1702  	io.Copy(&b, r)
  1703  	_, err = p.Wait()
  1704  	if err != nil {
  1705  		t.Fatalf("run hostname Wait: %v", err)
  1706  	}
  1707  	err = p.Kill()
  1708  	if err == nil {
  1709  		t.Errorf("expected an error from Kill running 'hostname'")
  1710  	}
  1711  	output := b.String()
  1712  	if n := len(output); n > 0 && output[n-1] == '\n' {
  1713  		output = output[0 : n-1]
  1714  	}
  1715  	if output == "" {
  1716  		t.Fatalf("/bin/hostname produced no output")
  1717  	}
  1718  
  1719  	return output
  1720  }
  1721  
  1722  func testWindowsHostname(t *testing.T, hostname string) {
  1723  	cmd := osexec.Command("hostname")
  1724  	out, err := cmd.CombinedOutput()
  1725  	if err != nil {
  1726  		t.Fatalf("Failed to execute hostname command: %v %s", err, out)
  1727  	}
  1728  	want := strings.Trim(string(out), "\r\n")
  1729  	if hostname != want {
  1730  		t.Fatalf("Hostname() = %q != system hostname of %q", hostname, want)
  1731  	}
  1732  }
  1733  
  1734  func TestHostname(t *testing.T) {
  1735  	hostname, err := Hostname()
  1736  	if err != nil {
  1737  		t.Fatal(err)
  1738  	}
  1739  	if hostname == "" {
  1740  		t.Fatal("Hostname returned empty string and no error")
  1741  	}
  1742  	if strings.Contains(hostname, "\x00") {
  1743  		t.Fatalf("unexpected zero byte in hostname: %q", hostname)
  1744  	}
  1745  
  1746  	// There is no other way to fetch hostname on windows, but via winapi.
  1747  	// On Plan 9 it can be taken from #c/sysname as Hostname() does.
  1748  	switch runtime.GOOS {
  1749  	case "android", "plan9":
  1750  		// No /bin/hostname to verify against.
  1751  		return
  1752  	case "windows":
  1753  		testWindowsHostname(t, hostname)
  1754  		return
  1755  	}
  1756  
  1757  	testenv.MustHaveExec(t)
  1758  
  1759  	// Check internal Hostname() against the output of /bin/hostname.
  1760  	// Allow that the internal Hostname returns a Fully Qualified Domain Name
  1761  	// and the /bin/hostname only returns the first component
  1762  	want := runBinHostname(t)
  1763  	if hostname != want {
  1764  		i := strings.Index(hostname, ".")
  1765  		if i < 0 || hostname[0:i] != want {
  1766  			t.Errorf("Hostname() = %q, want %q", hostname, want)
  1767  		}
  1768  	}
  1769  }
  1770  
  1771  func TestReadAt(t *testing.T) {
  1772  	f := newFile("TestReadAt", t)
  1773  	defer Remove(f.Name())
  1774  	defer f.Close()
  1775  
  1776  	const data = "hello, world\n"
  1777  	io.WriteString(f, data)
  1778  
  1779  	b := make([]byte, 5)
  1780  	n, err := f.ReadAt(b, 7)
  1781  	if err != nil || n != len(b) {
  1782  		t.Fatalf("ReadAt 7: %d, %v", n, err)
  1783  	}
  1784  	if string(b) != "world" {
  1785  		t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
  1786  	}
  1787  }
  1788  
  1789  // Verify that ReadAt doesn't affect seek offset.
  1790  // In the Plan 9 kernel, there used to be a bug in the implementation of
  1791  // the pread syscall, where the channel offset was erroneously updated after
  1792  // calling pread on a file.
  1793  func TestReadAtOffset(t *testing.T) {
  1794  	f := newFile("TestReadAtOffset", t)
  1795  	defer Remove(f.Name())
  1796  	defer f.Close()
  1797  
  1798  	const data = "hello, world\n"
  1799  	io.WriteString(f, data)
  1800  
  1801  	f.Seek(0, 0)
  1802  	b := make([]byte, 5)
  1803  
  1804  	n, err := f.ReadAt(b, 7)
  1805  	if err != nil || n != len(b) {
  1806  		t.Fatalf("ReadAt 7: %d, %v", n, err)
  1807  	}
  1808  	if string(b) != "world" {
  1809  		t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
  1810  	}
  1811  
  1812  	n, err = f.Read(b)
  1813  	if err != nil || n != len(b) {
  1814  		t.Fatalf("Read: %d, %v", n, err)
  1815  	}
  1816  	if string(b) != "hello" {
  1817  		t.Fatalf("Read: have %q want %q", string(b), "hello")
  1818  	}
  1819  }
  1820  
  1821  // Verify that ReadAt doesn't allow negative offset.
  1822  func TestReadAtNegativeOffset(t *testing.T) {
  1823  	f := newFile("TestReadAtNegativeOffset", t)
  1824  	defer Remove(f.Name())
  1825  	defer f.Close()
  1826  
  1827  	const data = "hello, world\n"
  1828  	io.WriteString(f, data)
  1829  
  1830  	f.Seek(0, 0)
  1831  	b := make([]byte, 5)
  1832  
  1833  	n, err := f.ReadAt(b, -10)
  1834  
  1835  	const wantsub = "negative offset"
  1836  	if !strings.Contains(fmt.Sprint(err), wantsub) || n != 0 {
  1837  		t.Errorf("ReadAt(-10) = %v, %v; want 0, ...%q...", n, err, wantsub)
  1838  	}
  1839  }
  1840  
  1841  func TestWriteAt(t *testing.T) {
  1842  	f := newFile("TestWriteAt", t)
  1843  	defer Remove(f.Name())
  1844  	defer f.Close()
  1845  
  1846  	const data = "hello, world\n"
  1847  	io.WriteString(f, data)
  1848  
  1849  	n, err := f.WriteAt([]byte("WORLD"), 7)
  1850  	if err != nil || n != 5 {
  1851  		t.Fatalf("WriteAt 7: %d, %v", n, err)
  1852  	}
  1853  
  1854  	b, err := os.ReadFile(f.Name())
  1855  	if err != nil {
  1856  		t.Fatalf("ReadFile %s: %v", f.Name(), err)
  1857  	}
  1858  	if string(b) != "hello, WORLD\n" {
  1859  		t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n")
  1860  	}
  1861  }
  1862  
  1863  // Verify that WriteAt doesn't allow negative offset.
  1864  func TestWriteAtNegativeOffset(t *testing.T) {
  1865  	f := newFile("TestWriteAtNegativeOffset", t)
  1866  	defer Remove(f.Name())
  1867  	defer f.Close()
  1868  
  1869  	n, err := f.WriteAt([]byte("WORLD"), -10)
  1870  
  1871  	const wantsub = "negative offset"
  1872  	if !strings.Contains(fmt.Sprint(err), wantsub) || n != 0 {
  1873  		t.Errorf("WriteAt(-10) = %v, %v; want 0, ...%q...", n, err, wantsub)
  1874  	}
  1875  }
  1876  
  1877  // Verify that WriteAt doesn't work in append mode.
  1878  func TestWriteAtInAppendMode(t *testing.T) {
  1879  	defer chtmpdir(t)()
  1880  	f, err := OpenFile("write_at_in_append_mode.txt", O_APPEND|O_CREATE, 0666)
  1881  	if err != nil {
  1882  		t.Fatalf("OpenFile: %v", err)
  1883  	}
  1884  	defer f.Close()
  1885  
  1886  	_, err = f.WriteAt([]byte(""), 1)
  1887  	if err != ErrWriteAtInAppendMode {
  1888  		t.Fatalf("f.WriteAt returned %v, expected %v", err, ErrWriteAtInAppendMode)
  1889  	}
  1890  }
  1891  
  1892  func writeFile(t *testing.T, fname string, flag int, text string) string {
  1893  	f, err := OpenFile(fname, flag, 0666)
  1894  	if err != nil {
  1895  		t.Fatalf("Open: %v", err)
  1896  	}
  1897  	n, err := io.WriteString(f, text)
  1898  	if err != nil {
  1899  		t.Fatalf("WriteString: %d, %v", n, err)
  1900  	}
  1901  	f.Close()
  1902  	data, err := os.ReadFile(fname)
  1903  	if err != nil {
  1904  		t.Fatalf("ReadFile: %v", err)
  1905  	}
  1906  	return string(data)
  1907  }
  1908  
  1909  func TestAppend(t *testing.T) {
  1910  	defer chtmpdir(t)()
  1911  	const f = "append.txt"
  1912  	s := writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
  1913  	if s != "new" {
  1914  		t.Fatalf("writeFile: have %q want %q", s, "new")
  1915  	}
  1916  	s = writeFile(t, f, O_APPEND|O_RDWR, "|append")
  1917  	if s != "new|append" {
  1918  		t.Fatalf("writeFile: have %q want %q", s, "new|append")
  1919  	}
  1920  	s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "|append")
  1921  	if s != "new|append|append" {
  1922  		t.Fatalf("writeFile: have %q want %q", s, "new|append|append")
  1923  	}
  1924  	err := Remove(f)
  1925  	if err != nil {
  1926  		t.Fatalf("Remove: %v", err)
  1927  	}
  1928  	s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "new&append")
  1929  	if s != "new&append" {
  1930  		t.Fatalf("writeFile: after append have %q want %q", s, "new&append")
  1931  	}
  1932  	s = writeFile(t, f, O_CREATE|O_RDWR, "old")
  1933  	if s != "old&append" {
  1934  		t.Fatalf("writeFile: after create have %q want %q", s, "old&append")
  1935  	}
  1936  	s = writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
  1937  	if s != "new" {
  1938  		t.Fatalf("writeFile: after truncate have %q want %q", s, "new")
  1939  	}
  1940  }
  1941  
  1942  func TestStatDirWithTrailingSlash(t *testing.T) {
  1943  	// Create new temporary directory and arrange to clean it up.
  1944  	path := t.TempDir()
  1945  
  1946  	// Stat of path should succeed.
  1947  	if _, err := Stat(path); err != nil {
  1948  		t.Fatalf("stat %s failed: %s", path, err)
  1949  	}
  1950  
  1951  	// Stat of path+"/" should succeed too.
  1952  	path += "/"
  1953  	if _, err := Stat(path); err != nil {
  1954  		t.Fatalf("stat %s failed: %s", path, err)
  1955  	}
  1956  }
  1957  
  1958  func TestNilProcessStateString(t *testing.T) {
  1959  	var ps *ProcessState
  1960  	s := ps.String()
  1961  	if s != "<nil>" {
  1962  		t.Errorf("(*ProcessState)(nil).String() = %q, want %q", s, "<nil>")
  1963  	}
  1964  }
  1965  
  1966  func TestSameFile(t *testing.T) {
  1967  	defer chtmpdir(t)()
  1968  	fa, err := Create("a")
  1969  	if err != nil {
  1970  		t.Fatalf("Create(a): %v", err)
  1971  	}
  1972  	fa.Close()
  1973  	fb, err := Create("b")
  1974  	if err != nil {
  1975  		t.Fatalf("Create(b): %v", err)
  1976  	}
  1977  	fb.Close()
  1978  
  1979  	ia1, err := Stat("a")
  1980  	if err != nil {
  1981  		t.Fatalf("Stat(a): %v", err)
  1982  	}
  1983  	ia2, err := Stat("a")
  1984  	if err != nil {
  1985  		t.Fatalf("Stat(a): %v", err)
  1986  	}
  1987  	if !SameFile(ia1, ia2) {
  1988  		t.Errorf("files should be same")
  1989  	}
  1990  
  1991  	ib, err := Stat("b")
  1992  	if err != nil {
  1993  		t.Fatalf("Stat(b): %v", err)
  1994  	}
  1995  	if SameFile(ia1, ib) {
  1996  		t.Errorf("files should be different")
  1997  	}
  1998  }
  1999  
  2000  func testDevNullFileInfo(t *testing.T, statname, devNullName string, fi FileInfo, ignoreCase bool) {
  2001  	pre := fmt.Sprintf("%s(%q): ", statname, devNullName)
  2002  	name := filepath.Base(devNullName)
  2003  	if ignoreCase {
  2004  		if strings.ToUpper(fi.Name()) != strings.ToUpper(name) {
  2005  			t.Errorf(pre+"wrong file name have %v want %v", fi.Name(), name)
  2006  		}
  2007  	} else {
  2008  		if fi.Name() != name {
  2009  			t.Errorf(pre+"wrong file name have %v want %v", fi.Name(), name)
  2010  		}
  2011  	}
  2012  	if fi.Size() != 0 {
  2013  		t.Errorf(pre+"wrong file size have %d want 0", fi.Size())
  2014  	}
  2015  	if fi.Mode()&ModeDevice == 0 {
  2016  		t.Errorf(pre+"wrong file mode %q: ModeDevice is not set", fi.Mode())
  2017  	}
  2018  	if fi.Mode()&ModeCharDevice == 0 {
  2019  		t.Errorf(pre+"wrong file mode %q: ModeCharDevice is not set", fi.Mode())
  2020  	}
  2021  	if fi.Mode().IsRegular() {
  2022  		t.Errorf(pre+"wrong file mode %q: IsRegular returns true", fi.Mode())
  2023  	}
  2024  }
  2025  
  2026  func testDevNullFile(t *testing.T, devNullName string, ignoreCase bool) {
  2027  	f, err := Open(devNullName)
  2028  	if err != nil {
  2029  		t.Fatalf("Open(%s): %v", devNullName, err)
  2030  	}
  2031  	defer f.Close()
  2032  
  2033  	fi, err := f.Stat()
  2034  	if err != nil {
  2035  		t.Fatalf("Stat(%s): %v", devNullName, err)
  2036  	}
  2037  	testDevNullFileInfo(t, "f.Stat", devNullName, fi, ignoreCase)
  2038  
  2039  	fi, err = Stat(devNullName)
  2040  	if err != nil {
  2041  		t.Fatalf("Stat(%s): %v", devNullName, err)
  2042  	}
  2043  	testDevNullFileInfo(t, "Stat", devNullName, fi, ignoreCase)
  2044  }
  2045  
  2046  func TestDevNullFile(t *testing.T) {
  2047  	testDevNullFile(t, DevNull, false)
  2048  }
  2049  
  2050  var testLargeWrite = flag.Bool("large_write", false, "run TestLargeWriteToConsole test that floods console with output")
  2051  
  2052  func TestLargeWriteToConsole(t *testing.T) {
  2053  	if !*testLargeWrite {
  2054  		t.Skip("skipping console-flooding test; enable with -large_write")
  2055  	}
  2056  	b := make([]byte, 32000)
  2057  	for i := range b {
  2058  		b[i] = '.'
  2059  	}
  2060  	b[len(b)-1] = '\n'
  2061  	n, err := Stdout.Write(b)
  2062  	if err != nil {
  2063  		t.Fatalf("Write to os.Stdout failed: %v", err)
  2064  	}
  2065  	if n != len(b) {
  2066  		t.Errorf("Write to os.Stdout should return %d; got %d", len(b), n)
  2067  	}
  2068  	n, err = Stderr.Write(b)
  2069  	if err != nil {
  2070  		t.Fatalf("Write to os.Stderr failed: %v", err)
  2071  	}
  2072  	if n != len(b) {
  2073  		t.Errorf("Write to os.Stderr should return %d; got %d", len(b), n)
  2074  	}
  2075  }
  2076  
  2077  func TestStatDirModeExec(t *testing.T) {
  2078  	const mode = 0111
  2079  
  2080  	path := t.TempDir()
  2081  	if err := Chmod(path, 0777); err != nil {
  2082  		t.Fatalf("Chmod %q 0777: %v", path, err)
  2083  	}
  2084  
  2085  	dir, err := Stat(path)
  2086  	if err != nil {
  2087  		t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
  2088  	}
  2089  	if dir.Mode()&mode != mode {
  2090  		t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode()&mode, mode)
  2091  	}
  2092  }
  2093  
  2094  func TestStatStdin(t *testing.T) {
  2095  	switch runtime.GOOS {
  2096  	case "android", "plan9":
  2097  		t.Skipf("%s doesn't have /bin/sh", runtime.GOOS)
  2098  	}
  2099  
  2100  	testenv.MustHaveExec(t)
  2101  
  2102  	if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
  2103  		st, err := Stdin.Stat()
  2104  		if err != nil {
  2105  			t.Fatalf("Stat failed: %v", err)
  2106  		}
  2107  		fmt.Println(st.Mode() & ModeNamedPipe)
  2108  		Exit(0)
  2109  	}
  2110  
  2111  	fi, err := Stdin.Stat()
  2112  	if err != nil {
  2113  		t.Fatal(err)
  2114  	}
  2115  	switch mode := fi.Mode(); {
  2116  	case mode&ModeCharDevice != 0 && mode&ModeDevice != 0:
  2117  	case mode&ModeNamedPipe != 0:
  2118  	default:
  2119  		t.Fatalf("unexpected Stdin mode (%v), want ModeCharDevice or ModeNamedPipe", mode)
  2120  	}
  2121  
  2122  	var cmd *osexec.Cmd
  2123  	if runtime.GOOS == "windows" {
  2124  		cmd = osexec.Command("cmd", "/c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
  2125  	} else {
  2126  		cmd = osexec.Command("/bin/sh", "-c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
  2127  	}
  2128  	cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
  2129  
  2130  	output, err := cmd.CombinedOutput()
  2131  	if err != nil {
  2132  		t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
  2133  	}
  2134  
  2135  	// result will be like "prw-rw-rw"
  2136  	if len(output) < 1 || output[0] != 'p' {
  2137  		t.Fatalf("Child process reports stdin is not pipe '%v'", string(output))
  2138  	}
  2139  }
  2140  
  2141  func TestStatRelativeSymlink(t *testing.T) {
  2142  	testenv.MustHaveSymlink(t)
  2143  
  2144  	tmpdir := t.TempDir()
  2145  	target := filepath.Join(tmpdir, "target")
  2146  	f, err := Create(target)
  2147  	if err != nil {
  2148  		t.Fatal(err)
  2149  	}
  2150  	defer f.Close()
  2151  
  2152  	st, err := f.Stat()
  2153  	if err != nil {
  2154  		t.Fatal(err)
  2155  	}
  2156  
  2157  	link := filepath.Join(tmpdir, "link")
  2158  	err = Symlink(filepath.Base(target), link)
  2159  	if err != nil {
  2160  		t.Fatal(err)
  2161  	}
  2162  
  2163  	st1, err := Stat(link)
  2164  	if err != nil {
  2165  		t.Fatal(err)
  2166  	}
  2167  
  2168  	if !SameFile(st, st1) {
  2169  		t.Error("Stat doesn't follow relative symlink")
  2170  	}
  2171  
  2172  	if runtime.GOOS == "windows" {
  2173  		Remove(link)
  2174  		err = Symlink(target[len(filepath.VolumeName(target)):], link)
  2175  		if err != nil {
  2176  			t.Fatal(err)
  2177  		}
  2178  
  2179  		st1, err := Stat(link)
  2180  		if err != nil {
  2181  			t.Fatal(err)
  2182  		}
  2183  
  2184  		if !SameFile(st, st1) {
  2185  			t.Error("Stat doesn't follow relative symlink")
  2186  		}
  2187  	}
  2188  }
  2189  
  2190  func TestReadAtEOF(t *testing.T) {
  2191  	f := newFile("TestReadAtEOF", t)
  2192  	defer Remove(f.Name())
  2193  	defer f.Close()
  2194  
  2195  	_, err := f.ReadAt(make([]byte, 10), 0)
  2196  	switch err {
  2197  	case io.EOF:
  2198  		// all good
  2199  	case nil:
  2200  		t.Fatalf("ReadAt succeeded")
  2201  	default:
  2202  		t.Fatalf("ReadAt failed: %s", err)
  2203  	}
  2204  }
  2205  
  2206  func TestLongPath(t *testing.T) {
  2207  	tmpdir := newDir("TestLongPath", t)
  2208  	defer func(d string) {
  2209  		if err := RemoveAll(d); err != nil {
  2210  			t.Fatalf("RemoveAll failed: %v", err)
  2211  		}
  2212  	}(tmpdir)
  2213  
  2214  	// Test the boundary of 247 and fewer bytes (normal) and 248 and more bytes (adjusted).
  2215  	sizes := []int{247, 248, 249, 400}
  2216  	for len(tmpdir) < 400 {
  2217  		tmpdir += "/dir3456789"
  2218  	}
  2219  	for _, sz := range sizes {
  2220  		t.Run(fmt.Sprintf("length=%d", sz), func(t *testing.T) {
  2221  			sizedTempDir := tmpdir[:sz-1] + "x" // Ensure it does not end with a slash.
  2222  
  2223  			// The various sized runs are for this call to trigger the boundary
  2224  			// condition.
  2225  			if err := MkdirAll(sizedTempDir, 0755); err != nil {
  2226  				t.Fatalf("MkdirAll failed: %v", err)
  2227  			}
  2228  			data := []byte("hello world\n")
  2229  			if err := os.WriteFile(sizedTempDir+"/foo.txt", data, 0644); err != nil {
  2230  				t.Fatalf("os.WriteFile() failed: %v", err)
  2231  			}
  2232  			if err := Rename(sizedTempDir+"/foo.txt", sizedTempDir+"/bar.txt"); err != nil {
  2233  				t.Fatalf("Rename failed: %v", err)
  2234  			}
  2235  			mtime := time.Now().Truncate(time.Minute)
  2236  			if err := Chtimes(sizedTempDir+"/bar.txt", mtime, mtime); err != nil {
  2237  				t.Fatalf("Chtimes failed: %v", err)
  2238  			}
  2239  			names := []string{"bar.txt"}
  2240  			if testenv.HasSymlink() {
  2241  				if err := Symlink(sizedTempDir+"/bar.txt", sizedTempDir+"/symlink.txt"); err != nil {
  2242  					t.Fatalf("Symlink failed: %v", err)
  2243  				}
  2244  				names = append(names, "symlink.txt")
  2245  			}
  2246  			if testenv.HasLink() {
  2247  				if err := Link(sizedTempDir+"/bar.txt", sizedTempDir+"/link.txt"); err != nil {
  2248  					t.Fatalf("Link failed: %v", err)
  2249  				}
  2250  				names = append(names, "link.txt")
  2251  			}
  2252  			for _, wantSize := range []int64{int64(len(data)), 0} {
  2253  				for _, name := range names {
  2254  					path := sizedTempDir + "/" + name
  2255  					dir, err := Stat(path)
  2256  					if err != nil {
  2257  						t.Fatalf("Stat(%q) failed: %v", path, err)
  2258  					}
  2259  					filesize := size(path, t)
  2260  					if dir.Size() != filesize || filesize != wantSize {
  2261  						t.Errorf("Size(%q) is %d, len(ReadFile()) is %d, want %d", path, dir.Size(), filesize, wantSize)
  2262  					}
  2263  					err = Chmod(path, dir.Mode())
  2264  					if err != nil {
  2265  						t.Fatalf("Chmod(%q) failed: %v", path, err)
  2266  					}
  2267  				}
  2268  				if err := Truncate(sizedTempDir+"/bar.txt", 0); err != nil {
  2269  					t.Fatalf("Truncate failed: %v", err)
  2270  				}
  2271  			}
  2272  		})
  2273  	}
  2274  }
  2275  
  2276  func testKillProcess(t *testing.T, processKiller func(p *Process)) {
  2277  	testenv.MustHaveExec(t)
  2278  	t.Parallel()
  2279  
  2280  	// Re-exec the test binary itself to emulate "sleep 1".
  2281  	cmd := osexec.Command(Args[0], "-test.run", "TestSleep")
  2282  	err := cmd.Start()
  2283  	if err != nil {
  2284  		t.Fatalf("Failed to start test process: %v", err)
  2285  	}
  2286  
  2287  	defer func() {
  2288  		if err := cmd.Wait(); err == nil {
  2289  			t.Errorf("Test process succeeded, but expected to fail")
  2290  		}
  2291  	}()
  2292  
  2293  	time.Sleep(100 * time.Millisecond)
  2294  	processKiller(cmd.Process)
  2295  }
  2296  
  2297  // TestSleep emulates "sleep 1". It is a helper for testKillProcess, so we
  2298  // don't have to rely on an external "sleep" command being available.
  2299  func TestSleep(t *testing.T) {
  2300  	if testing.Short() {
  2301  		t.Skip("Skipping in short mode")
  2302  	}
  2303  	time.Sleep(time.Second)
  2304  }
  2305  
  2306  func TestKillStartProcess(t *testing.T) {
  2307  	testKillProcess(t, func(p *Process) {
  2308  		err := p.Kill()
  2309  		if err != nil {
  2310  			t.Fatalf("Failed to kill test process: %v", err)
  2311  		}
  2312  	})
  2313  }
  2314  
  2315  func TestGetppid(t *testing.T) {
  2316  	if runtime.GOOS == "plan9" {
  2317  		// TODO: golang.org/issue/8206
  2318  		t.Skipf("skipping test on plan9; see issue 8206")
  2319  	}
  2320  
  2321  	testenv.MustHaveExec(t)
  2322  
  2323  	if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
  2324  		fmt.Print(Getppid())
  2325  		Exit(0)
  2326  	}
  2327  
  2328  	cmd := osexec.Command(Args[0], "-test.run=TestGetppid")
  2329  	cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
  2330  
  2331  	// verify that Getppid() from the forked process reports our process id
  2332  	output, err := cmd.CombinedOutput()
  2333  	if err != nil {
  2334  		t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
  2335  	}
  2336  
  2337  	childPpid := string(output)
  2338  	ourPid := fmt.Sprintf("%d", Getpid())
  2339  	if childPpid != ourPid {
  2340  		t.Fatalf("Child process reports parent process id '%v', expected '%v'", childPpid, ourPid)
  2341  	}
  2342  }
  2343  
  2344  func TestKillFindProcess(t *testing.T) {
  2345  	testKillProcess(t, func(p *Process) {
  2346  		p2, err := FindProcess(p.Pid)
  2347  		if err != nil {
  2348  			t.Fatalf("Failed to find test process: %v", err)
  2349  		}
  2350  		err = p2.Kill()
  2351  		if err != nil {
  2352  			t.Fatalf("Failed to kill test process: %v", err)
  2353  		}
  2354  	})
  2355  }
  2356  
  2357  var nilFileMethodTests = []struct {
  2358  	name string
  2359  	f    func(*File) error
  2360  }{
  2361  	{"Chdir", func(f *File) error { return f.Chdir() }},
  2362  	{"Close", func(f *File) error { return f.Close() }},
  2363  	{"Chmod", func(f *File) error { return f.Chmod(0) }},
  2364  	{"Chown", func(f *File) error { return f.Chown(0, 0) }},
  2365  	{"Read", func(f *File) error { _, err := f.Read(make([]byte, 0)); return err }},
  2366  	{"ReadAt", func(f *File) error { _, err := f.ReadAt(make([]byte, 0), 0); return err }},
  2367  	{"Readdir", func(f *File) error { _, err := f.Readdir(1); return err }},
  2368  	{"Readdirnames", func(f *File) error { _, err := f.Readdirnames(1); return err }},
  2369  	{"Seek", func(f *File) error { _, err := f.Seek(0, io.SeekStart); return err }},
  2370  	{"Stat", func(f *File) error { _, err := f.Stat(); return err }},
  2371  	{"Sync", func(f *File) error { return f.Sync() }},
  2372  	{"Truncate", func(f *File) error { return f.Truncate(0) }},
  2373  	{"Write", func(f *File) error { _, err := f.Write(make([]byte, 0)); return err }},
  2374  	{"WriteAt", func(f *File) error { _, err := f.WriteAt(make([]byte, 0), 0); return err }},
  2375  	{"WriteString", func(f *File) error { _, err := f.WriteString(""); return err }},
  2376  }
  2377  
  2378  // Test that all File methods give ErrInvalid if the receiver is nil.
  2379  func TestNilFileMethods(t *testing.T) {
  2380  	for _, tt := range nilFileMethodTests {
  2381  		var file *File
  2382  		got := tt.f(file)
  2383  		if got != ErrInvalid {
  2384  			t.Errorf("%v should fail when f is nil; got %v", tt.name, got)
  2385  		}
  2386  	}
  2387  }
  2388  
  2389  func mkdirTree(t *testing.T, root string, level, max int) {
  2390  	if level >= max {
  2391  		return
  2392  	}
  2393  	level++
  2394  	for i := 'a'; i < 'c'; i++ {
  2395  		dir := filepath.Join(root, string(i))
  2396  		if err := Mkdir(dir, 0700); err != nil {
  2397  			t.Fatal(err)
  2398  		}
  2399  		mkdirTree(t, dir, level, max)
  2400  	}
  2401  }
  2402  
  2403  // Test that simultaneous RemoveAll do not report an error.
  2404  // As long as it gets removed, we should be happy.
  2405  func TestRemoveAllRace(t *testing.T) {
  2406  	if runtime.GOOS == "windows" {
  2407  		// Windows has very strict rules about things like
  2408  		// removing directories while someone else has
  2409  		// them open. The racing doesn't work out nicely
  2410  		// like it does on Unix.
  2411  		t.Skip("skipping on windows")
  2412  	}
  2413  
  2414  	n := runtime.GOMAXPROCS(16)
  2415  	defer runtime.GOMAXPROCS(n)
  2416  	root, err := os.MkdirTemp("", "issue")
  2417  	if err != nil {
  2418  		t.Fatal(err)
  2419  	}
  2420  	mkdirTree(t, root, 1, 6)
  2421  	hold := make(chan struct{})
  2422  	var wg sync.WaitGroup
  2423  	for i := 0; i < 4; i++ {
  2424  		wg.Add(1)
  2425  		go func() {
  2426  			defer wg.Done()
  2427  			<-hold
  2428  			err := RemoveAll(root)
  2429  			if err != nil {
  2430  				t.Errorf("unexpected error: %T, %q", err, err)
  2431  			}
  2432  		}()
  2433  	}
  2434  	close(hold) // let workers race to remove root
  2435  	wg.Wait()
  2436  }
  2437  
  2438  // Test that reading from a pipe doesn't use up a thread.
  2439  func TestPipeThreads(t *testing.T) {
  2440  	switch runtime.GOOS {
  2441  	case "freebsd":
  2442  		t.Skip("skipping on FreeBSD; issue 19093")
  2443  	case "illumos", "solaris":
  2444  		t.Skip("skipping on Solaris and illumos; issue 19111")
  2445  	case "windows":
  2446  		t.Skip("skipping on Windows; issue 19098")
  2447  	case "plan9":
  2448  		t.Skip("skipping on Plan 9; does not support runtime poller")
  2449  	case "js":
  2450  		t.Skip("skipping on js; no support for os.Pipe")
  2451  	}
  2452  
  2453  	threads := 100
  2454  
  2455  	// OpenBSD has a low default for max number of files.
  2456  	if runtime.GOOS == "openbsd" {
  2457  		threads = 50
  2458  	}
  2459  
  2460  	r := make([]*File, threads)
  2461  	w := make([]*File, threads)
  2462  	for i := 0; i < threads; i++ {
  2463  		rp, wp, err := Pipe()
  2464  		if err != nil {
  2465  			for j := 0; j < i; j++ {
  2466  				r[j].Close()
  2467  				w[j].Close()
  2468  			}
  2469  			t.Fatal(err)
  2470  		}
  2471  		r[i] = rp
  2472  		w[i] = wp
  2473  	}
  2474  
  2475  	defer debug.SetMaxThreads(debug.SetMaxThreads(threads / 2))
  2476  
  2477  	creading := make(chan bool, threads)
  2478  	cdone := make(chan bool, threads)
  2479  	for i := 0; i < threads; i++ {
  2480  		go func(i int) {
  2481  			var b [1]byte
  2482  			creading <- true
  2483  			if _, err := r[i].Read(b[:]); err != nil {
  2484  				t.Error(err)
  2485  			}
  2486  			if err := r[i].Close(); err != nil {
  2487  				t.Error(err)
  2488  			}
  2489  			cdone <- true
  2490  		}(i)
  2491  	}
  2492  
  2493  	for i := 0; i < threads; i++ {
  2494  		<-creading
  2495  	}
  2496  
  2497  	// If we are still alive, it means that the 100 goroutines did
  2498  	// not require 100 threads.
  2499  
  2500  	for i := 0; i < threads; i++ {
  2501  		if _, err := w[i].Write([]byte{0}); err != nil {
  2502  			t.Error(err)
  2503  		}
  2504  		if err := w[i].Close(); err != nil {
  2505  			t.Error(err)
  2506  		}
  2507  		<-cdone
  2508  	}
  2509  }
  2510  
  2511  func testDoubleCloseError(t *testing.T, path string) {
  2512  	file, err := Open(path)
  2513  	if err != nil {
  2514  		t.Fatal(err)
  2515  	}
  2516  	if err := file.Close(); err != nil {
  2517  		t.Fatalf("unexpected error from Close: %v", err)
  2518  	}
  2519  	if err := file.Close(); err == nil {
  2520  		t.Error("second Close did not fail")
  2521  	} else if pe, ok := err.(*PathError); !ok {
  2522  		t.Errorf("second Close returned unexpected error type %T; expected fs.PathError", pe)
  2523  	} else if pe.Err != ErrClosed {
  2524  		t.Errorf("second Close returned %q, wanted %q", err, ErrClosed)
  2525  	} else {
  2526  		t.Logf("second close returned expected error %q", err)
  2527  	}
  2528  }
  2529  
  2530  func TestDoubleCloseError(t *testing.T) {
  2531  	testDoubleCloseError(t, filepath.Join(sfdir, sfname))
  2532  	testDoubleCloseError(t, sfdir)
  2533  }
  2534  
  2535  func TestUserHomeDir(t *testing.T) {
  2536  	dir, err := UserHomeDir()
  2537  	if dir == "" && err == nil {
  2538  		t.Fatal("UserHomeDir returned an empty string but no error")
  2539  	}
  2540  	if err != nil {
  2541  		t.Skipf("UserHomeDir failed: %v", err)
  2542  	}
  2543  	fi, err := Stat(dir)
  2544  	if err != nil {
  2545  		t.Fatal(err)
  2546  	}
  2547  	if !fi.IsDir() {
  2548  		t.Fatalf("dir %s is not directory; type = %v", dir, fi.Mode())
  2549  	}
  2550  }
  2551  
  2552  func TestDirSeek(t *testing.T) {
  2553  	if runtime.GOOS == "windows" {
  2554  		testenv.SkipFlaky(t, 36019)
  2555  	}
  2556  	wd, err := Getwd()
  2557  	if err != nil {
  2558  		t.Fatal(err)
  2559  	}
  2560  	f, err := Open(wd)
  2561  	if err != nil {
  2562  		t.Fatal(err)
  2563  	}
  2564  	dirnames1, err := f.Readdirnames(0)
  2565  	if err != nil {
  2566  		t.Fatal(err)
  2567  	}
  2568  
  2569  	ret, err := f.Seek(0, 0)
  2570  	if err != nil {
  2571  		t.Fatal(err)
  2572  	}
  2573  	if ret != 0 {
  2574  		t.Fatalf("seek result not zero: %d", ret)
  2575  	}
  2576  
  2577  	dirnames2, err := f.Readdirnames(0)
  2578  	if err != nil {
  2579  		t.Fatal(err)
  2580  		return
  2581  	}
  2582  
  2583  	if len(dirnames1) != len(dirnames2) {
  2584  		t.Fatalf("listings have different lengths: %d and %d\n", len(dirnames1), len(dirnames2))
  2585  	}
  2586  	for i, n1 := range dirnames1 {
  2587  		n2 := dirnames2[i]
  2588  		if n1 != n2 {
  2589  			t.Fatalf("different name i=%d n1=%s n2=%s\n", i, n1, n2)
  2590  		}
  2591  	}
  2592  }
  2593  
  2594  func TestReaddirSmallSeek(t *testing.T) {
  2595  	// See issue 37161. Read only one entry from a directory,
  2596  	// seek to the beginning, and read again. We should not see
  2597  	// duplicate entries.
  2598  	if runtime.GOOS == "windows" {
  2599  		testenv.SkipFlaky(t, 36019)
  2600  	}
  2601  	wd, err := Getwd()
  2602  	if err != nil {
  2603  		t.Fatal(err)
  2604  	}
  2605  	df, err := Open(filepath.Join(wd, "testdata", "issue37161"))
  2606  	if err != nil {
  2607  		t.Fatal(err)
  2608  	}
  2609  	names1, err := df.Readdirnames(1)
  2610  	if err != nil {
  2611  		t.Fatal(err)
  2612  	}
  2613  	if _, err = df.Seek(0, 0); err != nil {
  2614  		t.Fatal(err)
  2615  	}
  2616  	names2, err := df.Readdirnames(0)
  2617  	if err != nil {
  2618  		t.Fatal(err)
  2619  	}
  2620  	if len(names2) != 3 {
  2621  		t.Fatalf("first names: %v, second names: %v", names1, names2)
  2622  	}
  2623  }
  2624  
  2625  // isDeadlineExceeded reports whether err is or wraps os.ErrDeadlineExceeded.
  2626  // We also check that the error has a Timeout method that returns true.
  2627  func isDeadlineExceeded(err error) bool {
  2628  	if !IsTimeout(err) {
  2629  		return false
  2630  	}
  2631  	if !errors.Is(err, ErrDeadlineExceeded) {
  2632  		return false
  2633  	}
  2634  	return true
  2635  }
  2636  
  2637  // Test that opening a file does not change its permissions.  Issue 38225.
  2638  func TestOpenFileKeepsPermissions(t *testing.T) {
  2639  	t.Parallel()
  2640  	dir := t.TempDir()
  2641  	name := filepath.Join(dir, "x")
  2642  	f, err := Create(name)
  2643  	if err != nil {
  2644  		t.Fatal(err)
  2645  	}
  2646  	if err := f.Close(); err != nil {
  2647  		t.Error(err)
  2648  	}
  2649  	f, err = OpenFile(name, O_WRONLY|O_CREATE|O_TRUNC, 0)
  2650  	if err != nil {
  2651  		t.Fatal(err)
  2652  	}
  2653  	if fi, err := f.Stat(); err != nil {
  2654  		t.Error(err)
  2655  	} else if fi.Mode()&0222 == 0 {
  2656  		t.Errorf("f.Stat.Mode after OpenFile is %v, should be writable", fi.Mode())
  2657  	}
  2658  	if err := f.Close(); err != nil {
  2659  		t.Error(err)
  2660  	}
  2661  	if fi, err := Stat(name); err != nil {
  2662  		t.Error(err)
  2663  	} else if fi.Mode()&0222 == 0 {
  2664  		t.Errorf("Stat after OpenFile is %v, should be writable", fi.Mode())
  2665  	}
  2666  }
  2667  
  2668  func TestDirFS(t *testing.T) {
  2669  	// On Windows, we force the MFT to update by reading the actual metadata from GetFileInformationByHandle and then
  2670  	// explicitly setting that. Otherwise it might get out of sync with FindFirstFile. See golang.org/issues/42637.
  2671  	if runtime.GOOS == "windows" {
  2672  		if err := filepath.WalkDir("./testdata/dirfs", func(path string, d fs.DirEntry, err error) error {
  2673  			if err != nil {
  2674  				t.Fatal(err)
  2675  			}
  2676  			info, err := d.Info()
  2677  			if err != nil {
  2678  				t.Fatal(err)
  2679  			}
  2680  			stat, err := Stat(path) // This uses GetFileInformationByHandle internally.
  2681  			if err != nil {
  2682  				t.Fatal(err)
  2683  			}
  2684  			if stat.ModTime() == info.ModTime() {
  2685  				return nil
  2686  			}
  2687  			if err := Chtimes(path, stat.ModTime(), stat.ModTime()); err != nil {
  2688  				t.Log(err) // We only log, not die, in case the test directory is not writable.
  2689  			}
  2690  			return nil
  2691  		}); err != nil {
  2692  			t.Fatal(err)
  2693  		}
  2694  	}
  2695  	if err := fstest.TestFS(DirFS("./testdata/dirfs"), "a", "b", "dir/x"); err != nil {
  2696  		t.Fatal(err)
  2697  	}
  2698  
  2699  	// Test that Open does not accept backslash as separator.
  2700  	d := DirFS(".")
  2701  	_, err := d.Open(`testdata\dirfs`)
  2702  	if err == nil {
  2703  		t.Fatalf(`Open testdata\dirfs succeeded`)
  2704  	}
  2705  }
  2706  
  2707  func TestDirFSPathsValid(t *testing.T) {
  2708  	if runtime.GOOS == "windows" {
  2709  		t.Skipf("skipping on Windows")
  2710  	}
  2711  
  2712  	d := t.TempDir()
  2713  	if err := os.WriteFile(filepath.Join(d, "control.txt"), []byte(string("Hello, world!")), 0644); err != nil {
  2714  		t.Fatal(err)
  2715  	}
  2716  	if err := os.WriteFile(filepath.Join(d, `e:xperi\ment.txt`), []byte(string("Hello, colon and backslash!")), 0644); err != nil {
  2717  		t.Fatal(err)
  2718  	}
  2719  
  2720  	fsys := os.DirFS(d)
  2721  	err := fs.WalkDir(fsys, ".", func(path string, e fs.DirEntry, err error) error {
  2722  		if fs.ValidPath(e.Name()) {
  2723  			t.Logf("%q ok", e.Name())
  2724  		} else {
  2725  			t.Errorf("%q INVALID", e.Name())
  2726  		}
  2727  		return nil
  2728  	})
  2729  	if err != nil {
  2730  		t.Fatal(err)
  2731  	}
  2732  }
  2733  
  2734  func TestReadFileProc(t *testing.T) {
  2735  	// Linux files in /proc report 0 size,
  2736  	// but then if ReadFile reads just a single byte at offset 0,
  2737  	// the read at offset 1 returns EOF instead of more data.
  2738  	// ReadFile has a minimum read size of 512 to work around this,
  2739  	// but test explicitly that it's working.
  2740  	name := "/proc/sys/fs/pipe-max-size"
  2741  	if _, err := Stat(name); err != nil {
  2742  		t.Skip(err)
  2743  	}
  2744  	data, err := ReadFile(name)
  2745  	if err != nil {
  2746  		t.Fatal(err)
  2747  	}
  2748  	if len(data) == 0 || data[len(data)-1] != '\n' {
  2749  		t.Fatalf("read %s: not newline-terminated: %q", name, data)
  2750  	}
  2751  }
  2752  
  2753  func TestWriteStringAlloc(t *testing.T) {
  2754  	if runtime.GOOS == "js" {
  2755  		t.Skip("js allocates a lot during File.WriteString")
  2756  	}
  2757  	d := t.TempDir()
  2758  	f, err := Create(filepath.Join(d, "whiteboard.txt"))
  2759  	if err != nil {
  2760  		t.Fatal(err)
  2761  	}
  2762  	defer f.Close()
  2763  	allocs := testing.AllocsPerRun(100, func() {
  2764  		f.WriteString("I will not allocate when passed a string longer than 32 bytes.\n")
  2765  	})
  2766  	if allocs != 0 {
  2767  		t.Errorf("expected 0 allocs for File.WriteString, got %v", allocs)
  2768  	}
  2769  }
  2770  

View as plain text