libgo/go/os/os_test.go

   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/ioutil"
  15         . "os"
  16         osexec "os/exec"
  17         "path/filepath"
  18         "reflect"
  19         "runtime"
  20         "sort"
  21         "strings"
  22         "sync"
  23         "syscall"
  24         "testing"
  25         "time"
  26 )
  27
  28 var dot = []string{
  29         "dir.go",
  30         "env.go",
  31         "error.go",
  32         "file.go",
  33         "os_test.go",
  34         "types.go",
  35 }
  36
  37 type sysDir struct {
  38         name  string
  39         files []string
  40 }
  41
  42 var sysdir = func() *sysDir {
  43         switch runtime.GOOS {
  44         case "android":
  45                 return &sysDir{
  46                         "/system/lib",
  47                         []string{
  48                                 "libmedia.so",
  49                                 "libpowermanager.so",
  50                         },
  51                 }
  52         case "darwin":
  53                 switch runtime.GOARCH {
  54                 case "arm", "arm64":
  55                         /// At this point the test harness has not had a chance
  56                         // to move us into the ./src/os directory, so the
  57                         // current working directory is the root of the app.
  58                         wd, err := syscall.Getwd()
  59                         if err != nil {
  60                                 wd = err.Error()
  61                         }
  62                         return &sysDir{
  63                                 wd,
  64                                 []string{
  65                                         "ResourceRules.plist",
  66                                         "Info.plist",
  67                                 },
  68                         }
  69                 }
  70         case "windows":
  71                 return &sysDir{
  72                         Getenv("SystemRoot") + "\\system32\\drivers\\etc",
  73                         []string{
  74                                 "networks",
  75                                 "protocol",
  76                                 "services",
  77                         },
  78                 }
  79         case "plan9":
  80                 return &sysDir{
  81                         "/lib/ndb",
  82                         []string{
  83                                 "common",
  84                                 "local",
  85                         },
  86                 }
  87         }
  88         return &sysDir{
  89                 "/etc",
  90                 []string{
  91                         "group",
  92                         "hosts",
  93                         "passwd",
  94                 },
  95         }
  96 }()
  97
  98 func size(name string, t *testing.T) int64 {
  99         file, err := Open(name)
 100         if err != nil {
 101                 t.Fatal("open failed:", err)
 102         }
 103         defer file.Close()
 104         var buf [100]byte
 105         len := 0
 106         for {
 107                 n, e := file.Read(buf[0:])
 108                 len += n
 109                 if e == io.EOF {
 110                         break
 111                 }
 112                 if e != nil {
 113                         t.Fatal("read failed:", err)
 114                 }
 115         }
 116         return int64(len)
 117 }
 118
 119 func equal(name1, name2 string) (r bool) {
 120         switch runtime.GOOS {
 121         case "windows":
 122                 r = strings.ToLower(name1) == strings.ToLower(name2)
 123         default:
 124                 r = name1 == name2
 125         }
 126         return
 127 }
 128
 129 // localTmp returns a local temporary directory not on NFS.
 130 func localTmp() string {
 131         switch runtime.GOOS {
 132         case "android", "windows":
 133                 return TempDir()
 134         case "darwin":
 135                 switch runtime.GOARCH {
 136                 case "arm", "arm64":
 137                         return TempDir()
 138                 }
 139         }
 140         return "/tmp"
 141 }
 142
 143 func newFile(testName string, t *testing.T) (f *File) {
 144         f, err := ioutil.TempFile(localTmp(), "_Go_"+testName)
 145         if err != nil {
 146                 t.Fatalf("TempFile %s: %s", testName, err)
 147         }
 148         return
 149 }
 150
 151 func newDir(testName string, t *testing.T) (name string) {
 152         name, err := ioutil.TempDir(localTmp(), "_Go_"+testName)
 153         if err != nil {
 154                 t.Fatalf("TempDir %s: %s", testName, err)
 155         }
 156         return
 157 }
 158
 159 var sfdir = sysdir.name
 160 var sfname = sysdir.files[0]
 161
 162 func TestStat(t *testing.T) {
 163         path := sfdir + "/" + sfname
 164         dir, err := Stat(path)
 165         if err != nil {
 166                 t.Fatal("stat failed:", err)
 167         }
 168         if !equal(sfname, dir.Name()) {
 169                 t.Error("name should be ", sfname, "; is", dir.Name())
 170         }
 171         filesize := size(path, t)
 172         if dir.Size() != filesize {
 173                 t.Error("size should be", filesize, "; is", dir.Size())
 174         }
 175 }
 176
 177 func TestFstat(t *testing.T) {
 178         path := sfdir + "/" + sfname
 179         file, err1 := Open(path)
 180         if err1 != nil {
 181                 t.Fatal("open failed:", err1)
 182         }
 183         defer file.Close()
 184         dir, err2 := file.Stat()
 185         if err2 != nil {
 186                 t.Fatal("fstat failed:", err2)
 187         }
 188         if !equal(sfname, dir.Name()) {
 189                 t.Error("name should be ", sfname, "; is", dir.Name())
 190         }
 191         filesize := size(path, t)
 192         if dir.Size() != filesize {
 193                 t.Error("size should be", filesize, "; is", dir.Size())
 194         }
 195 }
 196
 197 func TestLstat(t *testing.T) {
 198         path := sfdir + "/" + sfname
 199         dir, err := Lstat(path)
 200         if err != nil {
 201                 t.Fatal("lstat failed:", err)
 202         }
 203         if !equal(sfname, dir.Name()) {
 204                 t.Error("name should be ", sfname, "; is", dir.Name())
 205         }
 206         filesize := size(path, t)
 207         if dir.Size() != filesize {
 208                 t.Error("size should be", filesize, "; is", dir.Size())
 209         }
 210 }
 211
 212 // Read with length 0 should not return EOF.
 213 func TestRead0(t *testing.T) {
 214         path := sfdir + "/" + sfname
 215         f, err := Open(path)
 216         if err != nil {
 217                 t.Fatal("open failed:", err)
 218         }
 219         defer f.Close()
 220
 221         b := make([]byte, 0)
 222         n, err := f.Read(b)
 223         if n != 0 || err != nil {
 224                 t.Errorf("Read(0) = %d, %v, want 0, nil", n, err)
 225         }
 226         b = make([]byte, 100)
 227         n, err = f.Read(b)
 228         if n <= 0 || err != nil {
 229                 t.Errorf("Read(100) = %d, %v, want >0, nil", n, err)
 230         }
 231 }
 232
 233 // Reading a closed file should should return ErrClosed error
 234 func TestReadClosed(t *testing.T) {
 235         path := sfdir + "/" + sfname
 236         file, err := Open(path)
 237         if err != nil {
 238                 t.Fatal("open failed:", err)
 239         }
 240         file.Close() // close immediately
 241
 242         b := make([]byte, 100)
 243         _, err = file.Read(b)
 244
 245         e, ok := err.(*PathError)
 246         if !ok {
 247                 t.Fatalf("Read: %T(%v), want PathError", e, e)
 248         }
 249
 250         if e.Err != ErrClosed {
 251                 t.Errorf("Read: %v, want PathError(ErrClosed)", e)
 252         }
 253 }
 254
 255 func testReaddirnames(dir string, contents []string, t *testing.T) {
 256         file, err := Open(dir)
 257         if err != nil {
 258                 t.Fatalf("open %q failed: %v", dir, err)
 259         }
 260         defer file.Close()
 261         s, err2 := file.Readdirnames(-1)
 262         if err2 != nil {
 263                 t.Fatalf("readdirnames %q failed: %v", dir, err2)
 264         }
 265         for _, m := range contents {
 266                 found := false
 267                 for _, n := range s {
 268                         if n == "." || n == ".." {
 269                                 t.Errorf("got %s in directory", n)
 270                         }
 271                         if equal(m, n) {
 272                                 if found {
 273                                         t.Error("present twice:", m)
 274                                 }
 275                                 found = true
 276                         }
 277                 }
 278                 if !found {
 279                         t.Error("could not find", m)
 280                 }
 281         }
 282 }
 283
 284 func testReaddir(dir string, contents []string, t *testing.T) {
 285         file, err := Open(dir)
 286         if err != nil {
 287                 t.Fatalf("open %q failed: %v", dir, err)
 288         }
 289         defer file.Close()
 290         s, err2 := file.Readdir(-1)
 291         if err2 != nil {
 292                 t.Fatalf("readdir %q failed: %v", dir, err2)
 293         }
 294         for _, m := range contents {
 295                 found := false
 296                 for _, n := range s {
 297                         if equal(m, n.Name()) {
 298                                 if found {
 299                                         t.Error("present twice:", m)
 300                                 }
 301                                 found = true
 302                         }
 303                 }
 304                 if !found {
 305                         t.Error("could not find", m)
 306                 }
 307         }
 308 }
 309
 310 func TestReaddirnames(t *testing.T) {
 311         testReaddirnames(".", dot, t)
 312         testReaddirnames(sysdir.name, sysdir.files, t)
 313 }
 314
 315 func TestReaddir(t *testing.T) {
 316         testReaddir(".", dot, t)
 317         testReaddir(sysdir.name, sysdir.files, t)
 318 }
 319
 320 func benchmarkReaddirname(path string, b *testing.B) {
 321         var nentries int
 322         for i := 0; i < b.N; i++ {
 323                 f, err := Open(path)
 324                 if err != nil {
 325                         b.Fatalf("open %q failed: %v", path, err)
 326                 }
 327                 ns, err := f.Readdirnames(-1)
 328                 f.Close()
 329                 if err != nil {
 330                         b.Fatalf("readdirnames %q failed: %v", path, err)
 331                 }
 332                 nentries = len(ns)
 333         }
 334         b.Logf("benchmarkReaddirname %q: %d entries", path, nentries)
 335 }
 336
 337 func benchmarkReaddir(path string, b *testing.B) {
 338         var nentries int
 339         for i := 0; i < b.N; i++ {
 340                 f, err := Open(path)
 341                 if err != nil {
 342                         b.Fatalf("open %q failed: %v", path, err)
 343                 }
 344                 fs, err := f.Readdir(-1)
 345                 f.Close()
 346                 if err != nil {
 347                         b.Fatalf("readdir %q failed: %v", path, err)
 348                 }
 349                 nentries = len(fs)
 350         }
 351         b.Logf("benchmarkReaddir %q: %d entries", path, nentries)
 352 }
 353
 354 func BenchmarkReaddirname(b *testing.B) {
 355         benchmarkReaddirname(".", b)
 356 }
 357
 358 func BenchmarkReaddir(b *testing.B) {
 359         benchmarkReaddir(".", b)
 360 }
 361
 362 // Read the directory one entry at a time.
 363 func smallReaddirnames(file *File, length int, t *testing.T) []string {
 364         names := make([]string, length)
 365         count := 0
 366         for {
 367                 d, err := file.Readdirnames(1)
 368                 if err == io.EOF {
 369                         break
 370                 }
 371                 if err != nil {
 372                         t.Fatalf("readdirnames %q failed: %v", file.Name(), err)
 373                 }
 374                 if len(d) == 0 {
 375                         t.Fatalf("readdirnames %q returned empty slice and no error", file.Name())
 376                 }
 377                 names[count] = d[0]
 378                 count++
 379         }
 380         return names[0:count]
 381 }
 382
 383 // Check that reading a directory one entry at a time gives the same result
 384 // as reading it all at once.
 385 func TestReaddirnamesOneAtATime(t *testing.T) {
 386         // big directory that doesn't change often.
 387         dir := "/usr/bin"
 388         switch runtime.GOOS {
 389         case "android":
 390                 dir = "/system/bin"
 391         case "darwin":
 392                 switch runtime.GOARCH {
 393                 case "arm", "arm64":
 394                         wd, err := Getwd()
 395                         if err != nil {
 396                                 t.Fatal(err)
 397                         }
 398                         dir = wd
 399                 }
 400         case "plan9":
 401                 dir = "/bin"
 402         case "windows":
 403                 dir = Getenv("SystemRoot") + "\\system32"
 404         }
 405         file, err := Open(dir)
 406         if err != nil {
 407                 t.Fatalf("open %q failed: %v", dir, err)
 408         }
 409         defer file.Close()
 410         all, err1 := file.Readdirnames(-1)
 411         if err1 != nil {
 412                 t.Fatalf("readdirnames %q failed: %v", dir, err1)
 413         }
 414         file1, err2 := Open(dir)
 415         if err2 != nil {
 416                 t.Fatalf("open %q failed: %v", dir, err2)
 417         }
 418         defer file1.Close()
 419         small := smallReaddirnames(file1, len(all)+100, t) // +100 in case we screw up
 420         if len(small) < len(all) {
 421                 t.Fatalf("len(small) is %d, less than %d", len(small), len(all))
 422         }
 423         for i, n := range all {
 424                 if small[i] != n {
 425                         t.Errorf("small read %q mismatch: %v", small[i], n)
 426                 }
 427         }
 428 }
 429
 430 func TestReaddirNValues(t *testing.T) {
 431         if testing.Short() {
 432                 t.Skip("test.short; skipping")
 433         }
 434         dir, err := ioutil.TempDir("", "")
 435         if err != nil {
 436                 t.Fatalf("TempDir: %v", err)
 437         }
 438         defer RemoveAll(dir)
 439         for i := 1; i <= 105; i++ {
 440                 f, err := Create(filepath.Join(dir, fmt.Sprintf("%d", i)))
 441                 if err != nil {
 442                         t.Fatalf("Create: %v", err)
 443                 }
 444                 f.Write([]byte(strings.Repeat("X", i)))
 445                 f.Close()
 446         }
 447
 448         var d *File
 449         openDir := func() {
 450                 var err error
 451                 d, err = Open(dir)
 452                 if err != nil {
 453                         t.Fatalf("Open directory: %v", err)
 454                 }
 455         }
 456
 457         readDirExpect := func(n, want int, wantErr error) {
 458                 fi, err := d.Readdir(n)
 459                 if err != wantErr {
 460                         t.Fatalf("Readdir of %d got error %v, want %v", n, err, wantErr)
 461                 }
 462                 if g, e := len(fi), want; g != e {
 463                         t.Errorf("Readdir of %d got %d files, want %d", n, g, e)
 464                 }
 465         }
 466
 467         readDirNamesExpect := func(n, want int, wantErr error) {
 468                 fi, err := d.Readdirnames(n)
 469                 if err != wantErr {
 470                         t.Fatalf("Readdirnames of %d got error %v, want %v", n, err, wantErr)
 471                 }
 472                 if g, e := len(fi), want; g != e {
 473                         t.Errorf("Readdirnames of %d got %d files, want %d", n, g, e)
 474                 }
 475         }
 476
 477         for _, fn := range []func(int, int, error){readDirExpect, readDirNamesExpect} {
 478                 // Test the slurp case
 479                 openDir()
 480                 fn(0, 105, nil)
 481                 fn(0, 0, nil)
 482                 d.Close()
 483
 484                 // Slurp with -1 instead
 485                 openDir()
 486                 fn(-1, 105, nil)
 487                 fn(-2, 0, nil)
 488                 fn(0, 0, nil)
 489                 d.Close()
 490
 491                 // Test the bounded case
 492                 openDir()
 493                 fn(1, 1, nil)
 494                 fn(2, 2, nil)
 495                 fn(105, 102, nil) // and tests buffer >100 case
 496                 fn(3, 0, io.EOF)
 497                 d.Close()
 498         }
 499 }
 500
 501 func touch(t *testing.T, name string) {
 502         f, err := Create(name)
 503         if err != nil {
 504                 t.Fatal(err)
 505         }
 506         if err := f.Close(); err != nil {
 507                 t.Fatal(err)
 508         }
 509 }
 510
 511 func TestReaddirStatFailures(t *testing.T) {
 512         switch runtime.GOOS {
 513         case "windows", "plan9":
 514                 // Windows and Plan 9 already do this correctly,
 515                 // but are structured with different syscalls such
 516                 // that they don't use Lstat, so the hook below for
 517                 // testing it wouldn't work.
 518                 t.Skipf("skipping test on %v", runtime.GOOS)
 519         }
 520         dir, err := ioutil.TempDir("", "")
 521         if err != nil {
 522                 t.Fatalf("TempDir: %v", err)
 523         }
 524         defer RemoveAll(dir)
 525         touch(t, filepath.Join(dir, "good1"))
 526         touch(t, filepath.Join(dir, "x")) // will disappear or have an error
 527         touch(t, filepath.Join(dir, "good2"))
 528         defer func() {
 529                 *LstatP = Lstat
 530         }()
 531         var xerr error // error to return for x
 532         *LstatP = func(path string) (FileInfo, error) {
 533                 if xerr != nil && strings.HasSuffix(path, "x") {
 534                         return nil, xerr
 535                 }
 536                 return Lstat(path)
 537         }
 538         readDir := func() ([]FileInfo, error) {
 539                 d, err := Open(dir)
 540                 if err != nil {
 541                         t.Fatal(err)
 542                 }
 543                 defer d.Close()
 544                 return d.Readdir(-1)
 545         }
 546         mustReadDir := func(testName string) []FileInfo {
 547                 fis, err := readDir()
 548                 if err != nil {
 549                         t.Fatalf("%s: Readdir: %v", testName, err)
 550                 }
 551                 return fis
 552         }
 553         names := func(fis []FileInfo) []string {
 554                 s := make([]string, len(fis))
 555                 for i, fi := range fis {
 556                         s[i] = fi.Name()
 557                 }
 558                 sort.Strings(s)
 559                 return s
 560         }
 561
 562         if got, want := names(mustReadDir("initial readdir")),
 563                 []string{"good1", "good2", "x"}; !reflect.DeepEqual(got, want) {
 564                 t.Errorf("initial readdir got %q; want %q", got, want)
 565         }
 566
 567         xerr = ErrNotExist
 568         if got, want := names(mustReadDir("with x disappearing")),
 569                 []string{"good1", "good2"}; !reflect.DeepEqual(got, want) {
 570                 t.Errorf("with x disappearing, got %q; want %q", got, want)
 571         }
 572
 573         xerr = errors.New("some real error")
 574         if _, err := readDir(); err != xerr {
 575                 t.Errorf("with a non-ErrNotExist error, got error %v; want %v", err, xerr)
 576         }
 577 }
 578
 579 // Readdir on a regular file should fail.
 580 func TestReaddirOfFile(t *testing.T) {
 581         f, err := ioutil.TempFile("", "_Go_ReaddirOfFile")
 582         if err != nil {
 583                 t.Fatal(err)
 584         }
 585         defer Remove(f.Name())
 586         f.Write([]byte("foo"))
 587         f.Close()
 588         reg, err := Open(f.Name())
 589         if err != nil {
 590                 t.Fatal(err)
 591         }
 592         defer reg.Close()
 593
 594         names, err := reg.Readdirnames(-1)
 595         if err == nil {
 596                 t.Error("Readdirnames succeeded; want non-nil error")
 597         }
 598         if len(names) > 0 {
 599                 t.Errorf("unexpected dir names in regular file: %q", names)
 600         }
 601 }
 602
 603 func TestHardLink(t *testing.T) {
 604         testenv.MustHaveLink(t)
 605
 606         defer chtmpdir(t)()
 607         from, to := "hardlinktestfrom", "hardlinktestto"
 608         Remove(from) // Just in case.
 609         file, err := Create(to)
 610         if err != nil {
 611                 t.Fatalf("open %q failed: %v", to, err)
 612         }
 613         defer Remove(to)
 614         if err = file.Close(); err != nil {
 615                 t.Errorf("close %q failed: %v", to, err)
 616         }
 617         err = Link(to, from)
 618         if err != nil {
 619                 t.Fatalf("link %q, %q failed: %v", to, from, err)
 620         }
 621
 622         none := "hardlinktestnone"
 623         err = Link(none, none)
 624         // Check the returned error is well-formed.
 625         if lerr, ok := err.(*LinkError); !ok || lerr.Error() == "" {
 626                 t.Errorf("link %q, %q failed to return a valid error", none, none)
 627         }
 628
 629         defer Remove(from)
 630         tostat, err := Stat(to)
 631         if err != nil {
 632                 t.Fatalf("stat %q failed: %v", to, err)
 633         }
 634         fromstat, err := Stat(from)
 635         if err != nil {
 636                 t.Fatalf("stat %q failed: %v", from, err)
 637         }
 638         if !SameFile(tostat, fromstat) {
 639                 t.Errorf("link %q, %q did not create hard link", to, from)
 640         }
 641 }
 642
 643 // chtmpdir changes the working directory to a new temporary directory and
 644 // provides a cleanup function. Used when PWD is read-only.
 645 func chtmpdir(t *testing.T) func() {
 646         if runtime.GOOS != "darwin" || (runtime.GOARCH != "arm" && runtime.GOARCH != "arm64") {
 647                 return func() {} // only needed on darwin/arm{,64}
 648         }
 649         oldwd, err := Getwd()
 650         if err != nil {
 651                 t.Fatalf("chtmpdir: %v", err)
 652         }
 653         d, err := ioutil.TempDir("", "test")
 654         if err != nil {
 655                 t.Fatalf("chtmpdir: %v", err)
 656         }
 657         if err := Chdir(d); err != nil {
 658                 t.Fatalf("chtmpdir: %v", err)
 659         }
 660         return func() {
 661                 if err := Chdir(oldwd); err != nil {
 662                         t.Fatalf("chtmpdir: %v", err)
 663                 }
 664                 RemoveAll(d)
 665         }
 666 }
 667
 668 func TestSymlink(t *testing.T) {
 669         testenv.MustHaveSymlink(t)
 670
 671         defer chtmpdir(t)()
 672         from, to := "symlinktestfrom", "symlinktestto"
 673         Remove(from) // Just in case.
 674         file, err := Create(to)
 675         if err != nil {
 676                 t.Fatalf("open %q failed: %v", to, err)
 677         }
 678         defer Remove(to)
 679         if err = file.Close(); err != nil {
 680                 t.Errorf("close %q failed: %v", to, err)
 681         }
 682         err = Symlink(to, from)
 683         if err != nil {
 684                 t.Fatalf("symlink %q, %q failed: %v", to, from, err)
 685         }
 686         defer Remove(from)
 687         tostat, err := Lstat(to)
 688         if err != nil {
 689                 t.Fatalf("stat %q failed: %v", to, err)
 690         }
 691         if tostat.Mode()&ModeSymlink != 0 {
 692                 t.Fatalf("stat %q claims to have found a symlink", to)
 693         }
 694         fromstat, err := Stat(from)
 695         if err != nil {
 696                 t.Fatalf("stat %q failed: %v", from, err)
 697         }
 698         if !SameFile(tostat, fromstat) {
 699                 t.Errorf("symlink %q, %q did not create symlink", to, from)
 700         }
 701         fromstat, err = Lstat(from)
 702         if err != nil {
 703                 t.Fatalf("lstat %q failed: %v", from, err)
 704         }
 705         if fromstat.Mode()&ModeSymlink == 0 {
 706                 t.Fatalf("symlink %q, %q did not create symlink", to, from)
 707         }
 708         fromstat, err = Stat(from)
 709         if err != nil {
 710                 t.Fatalf("stat %q failed: %v", from, err)
 711         }
 712         if fromstat.Mode()&ModeSymlink != 0 {
 713                 t.Fatalf("stat %q did not follow symlink", from)
 714         }
 715         s, err := Readlink(from)
 716         if err != nil {
 717                 t.Fatalf("readlink %q failed: %v", from, err)
 718         }
 719         if s != to {
 720                 t.Fatalf("after symlink %q != %q", s, to)
 721         }
 722         file, err = Open(from)
 723         if err != nil {
 724                 t.Fatalf("open %q failed: %v", from, err)
 725         }
 726         file.Close()
 727 }
 728
 729 func TestLongSymlink(t *testing.T) {
 730         testenv.MustHaveSymlink(t)
 731
 732         defer chtmpdir(t)()
 733         s := "0123456789abcdef"
 734         // Long, but not too long: a common limit is 255.
 735         s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s
 736         from := "longsymlinktestfrom"
 737         Remove(from) // Just in case.
 738         err := Symlink(s, from)
 739         if err != nil {
 740                 t.Fatalf("symlink %q, %q failed: %v", s, from, err)
 741         }
 742         defer Remove(from)
 743         r, err := Readlink(from)
 744         if err != nil {
 745                 t.Fatalf("readlink %q failed: %v", from, err)
 746         }
 747         if r != s {
 748                 t.Fatalf("after symlink %q != %q", r, s)
 749         }
 750 }
 751
 752 func TestRename(t *testing.T) {
 753         defer chtmpdir(t)()
 754         from, to := "renamefrom", "renameto"
 755         // Ensure we are not testing the overwrite case here.
 756         Remove(from)
 757         Remove(to)
 758
 759         file, err := Create(from)
 760         if err != nil {
 761                 t.Fatalf("open %q failed: %v", from, err)
 762         }
 763         if err = file.Close(); err != nil {
 764                 t.Errorf("close %q failed: %v", from, err)
 765         }
 766         err = Rename(from, to)
 767         if err != nil {
 768                 t.Fatalf("rename %q, %q failed: %v", to, from, err)
 769         }
 770         defer Remove(to)
 771         _, err = Stat(to)
 772         if err != nil {
 773                 t.Errorf("stat %q failed: %v", to, err)
 774         }
 775 }
 776
 777 func TestRenameOverwriteDest(t *testing.T) {
 778         defer chtmpdir(t)()
 779         from, to := "renamefrom", "renameto"
 780         // Just in case.
 781         Remove(from)
 782         Remove(to)
 783
 784         toData := []byte("to")
 785         fromData := []byte("from")
 786
 787         err := ioutil.WriteFile(to, toData, 0777)
 788         if err != nil {
 789                 t.Fatalf("write file %q failed: %v", to, err)
 790         }
 791
 792         err = ioutil.WriteFile(from, fromData, 0777)
 793         if err != nil {
 794                 t.Fatalf("write file %q failed: %v", from, err)
 795         }
 796         err = Rename(from, to)
 797         if err != nil {
 798                 t.Fatalf("rename %q, %q failed: %v", to, from, err)
 799         }
 800         defer Remove(to)
 801
 802         _, err = Stat(from)
 803         if err == nil {
 804                 t.Errorf("from file %q still exists", from)
 805         }
 806         if err != nil && !IsNotExist(err) {
 807                 t.Fatalf("stat from: %v", err)
 808         }
 809         toFi, err := Stat(to)
 810         if err != nil {
 811                 t.Fatalf("stat %q failed: %v", to, err)
 812         }
 813         if toFi.Size() != int64(len(fromData)) {
 814                 t.Errorf(`"to" size = %d; want %d (old "from" size)`, toFi.Size(), len(fromData))
 815         }
 816 }
 817
 818 func TestRenameFailed(t *testing.T) {
 819         defer chtmpdir(t)()
 820         from, to := "renamefrom", "renameto"
 821         // Ensure we are not testing the overwrite case here.
 822         Remove(from)
 823         Remove(to)
 824
 825         err := Rename(from, to)
 826         switch err := err.(type) {
 827         case *LinkError:
 828                 if err.Op != "rename" {
 829                         t.Errorf("rename %q, %q: err.Op: want %q, got %q", from, to, "rename", err.Op)
 830                 }
 831                 if err.Old != from {
 832                         t.Errorf("rename %q, %q: err.Old: want %q, got %q", from, to, from, err.Old)
 833                 }
 834                 if err.New != to {
 835                         t.Errorf("rename %q, %q: err.New: want %q, got %q", from, to, to, err.New)
 836                 }
 837         case nil:
 838                 t.Errorf("rename %q, %q: expected error, got nil", from, to)
 839
 840                 // cleanup whatever was placed in "renameto"
 841                 Remove(to)
 842         default:
 843                 t.Errorf("rename %q, %q: expected %T, got %T %v", from, to, new(LinkError), err, err)
 844         }
 845 }
 846
 847 func TestRenameToDirFailed(t *testing.T) {
 848         defer chtmpdir(t)()
 849         from, to := "renamefrom", "renameto"
 850
 851         Remove(from)
 852         Remove(to)
 853         Mkdir(from, 0777)
 854         Mkdir(to, 0777)
 855         defer Remove(from)
 856         defer Remove(to)
 857
 858         err := Rename(from, to)
 859         switch err := err.(type) {
 860         case *LinkError:
 861                 if err.Op != "rename" {
 862                         t.Errorf("rename %q, %q: err.Op: want %q, got %q", from, to, "rename", err.Op)
 863                 }
 864                 if err.Old != from {
 865                         t.Errorf("rename %q, %q: err.Old: want %q, got %q", from, to, from, err.Old)
 866                 }
 867                 if err.New != to {
 868                         t.Errorf("rename %q, %q: err.New: want %q, got %q", from, to, to, err.New)
 869                 }
 870         case nil:
 871                 t.Errorf("rename %q, %q: expected error, got nil", from, to)
 872
 873                 // cleanup whatever was placed in "renameto"
 874                 Remove(to)
 875         default:
 876                 t.Errorf("rename %q, %q: expected %T, got %T %v", from, to, new(LinkError), err, err)
 877         }
 878 }
 879
 880 func exec(t *testing.T, dir, cmd string, args []string, expect string) {
 881         r, w, err := Pipe()
 882         if err != nil {
 883                 t.Fatalf("Pipe: %v", err)
 884         }
 885         defer r.Close()
 886         attr := &ProcAttr{Dir: dir, Files: []*File{nil, w, Stderr}}
 887         p, err := StartProcess(cmd, args, attr)
 888         if err != nil {
 889                 t.Fatalf("StartProcess: %v", err)
 890         }
 891         w.Close()
 892
 893         var b bytes.Buffer
 894         io.Copy(&b, r)
 895         output := b.String()
 896
 897         fi1, _ := Stat(strings.TrimSpace(output))
 898         fi2, _ := Stat(expect)
 899         if !SameFile(fi1, fi2) {
 900                 t.Errorf("exec %q returned %q wanted %q",
 901                         strings.Join(append([]string{cmd}, args...), " "), output, expect)
 902         }
 903         p.Wait()
 904 }
 905
 906 func TestStartProcess(t *testing.T) {
 907         testenv.MustHaveExec(t)
 908
 909         var dir, cmd string
 910         var args []string
 911         switch runtime.GOOS {
 912         case "android":
 913                 t.Skip("android doesn't have /bin/pwd")
 914         case "windows":
 915                 cmd = Getenv("COMSPEC")
 916                 dir = Getenv("SystemRoot")
 917                 args = []string{"/c", "cd"}
 918         default:
 919                 cmd = "/bin/pwd"
 920                 dir = "/"
 921                 args = []string{}
 922         }
 923         cmddir, cmdbase := filepath.Split(cmd)
 924         args = append([]string{cmdbase}, args...)
 925         // Test absolute executable path.
 926         exec(t, dir, cmd, args, dir)
 927         // Test relative executable path.
 928         exec(t, cmddir, cmdbase, args, cmddir)
 929 }
 930
 931 func checkMode(t *testing.T, path string, mode FileMode) {
 932         dir, err := Stat(path)
 933         if err != nil {
 934                 t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
 935         }
 936         if dir.Mode()&0777 != mode {
 937                 t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode(), mode)
 938         }
 939 }
 940
 941 func TestChmod(t *testing.T) {
 942         // Chmod is not supported under windows.
 943         if runtime.GOOS == "windows" {
 944                 return
 945         }
 946         f := newFile("TestChmod", t)
 947         defer Remove(f.Name())
 948         defer f.Close()
 949
 950         if err := Chmod(f.Name(), 0456); err != nil {
 951                 t.Fatalf("chmod %s 0456: %s", f.Name(), err)
 952         }
 953         checkMode(t, f.Name(), 0456)
 954
 955         if err := f.Chmod(0123); err != nil {
 956                 t.Fatalf("chmod %s 0123: %s", f.Name(), err)
 957         }
 958         checkMode(t, f.Name(), 0123)
 959 }
 960
 961 func checkSize(t *testing.T, f *File, size int64) {
 962         dir, err := f.Stat()
 963         if err != nil {
 964                 t.Fatalf("Stat %q (looking for size %d): %s", f.Name(), size, err)
 965         }
 966         if dir.Size() != size {
 967                 t.Errorf("Stat %q: size %d want %d", f.Name(), dir.Size(), size)
 968         }
 969 }
 970
 971 func TestFTruncate(t *testing.T) {
 972         f := newFile("TestFTruncate", t)
 973         defer Remove(f.Name())
 974         defer f.Close()
 975
 976         checkSize(t, f, 0)
 977         f.Write([]byte("hello, world\n"))
 978         checkSize(t, f, 13)
 979         f.Truncate(10)
 980         checkSize(t, f, 10)
 981         f.Truncate(1024)
 982         checkSize(t, f, 1024)
 983         f.Truncate(0)
 984         checkSize(t, f, 0)
 985         _, err := f.Write([]byte("surprise!"))
 986         if err == nil {
 987                 checkSize(t, f, 13+9) // wrote at offset past where hello, world was.
 988         }
 989 }
 990
 991 func TestTruncate(t *testing.T) {
 992         f := newFile("TestTruncate", t)
 993         defer Remove(f.Name())
 994         defer f.Close()
 995
 996         checkSize(t, f, 0)
 997         f.Write([]byte("hello, world\n"))
 998         checkSize(t, f, 13)
 999         Truncate(f.Name(), 10)
1000         checkSize(t, f, 10)
1001         Truncate(f.Name(), 1024)
1002         checkSize(t, f, 1024)
1003         Truncate(f.Name(), 0)
1004         checkSize(t, f, 0)
1005         _, err := f.Write([]byte("surprise!"))
1006         if err == nil {
1007                 checkSize(t, f, 13+9) // wrote at offset past where hello, world was.
1008         }
1009 }
1010
1011 // Use TempDir (via newFile) to make sure we're on a local file system,
1012 // so that timings are not distorted by latency and caching.
1013 // On NFS, timings can be off due to caching of meta-data on
1014 // NFS servers (Issue 848).
1015 func TestChtimes(t *testing.T) {
1016         f := newFile("TestChtimes", t)
1017         defer Remove(f.Name())
1018
1019         f.Write([]byte("hello, world\n"))
1020         f.Close()
1021
1022         testChtimes(t, f.Name())
1023 }
1024
1025 // Use TempDir (via newDir) to make sure we're on a local file system,
1026 // so that timings are not distorted by latency and caching.
1027 // On NFS, timings can be off due to caching of meta-data on
1028 // NFS servers (Issue 848).
1029 func TestChtimesDir(t *testing.T) {
1030         name := newDir("TestChtimes", t)
1031         defer RemoveAll(name)
1032
1033         testChtimes(t, name)
1034 }
1035
1036 func testChtimes(t *testing.T, name string) {
1037         st, err := Stat(name)
1038         if err != nil {
1039                 t.Fatalf("Stat %s: %s", name, err)
1040         }
1041         preStat := st
1042
1043         // Move access and modification time back a second
1044         at := Atime(preStat)
1045         mt := preStat.ModTime()
1046         err = Chtimes(name, at.Add(-time.Second), mt.Add(-time.Second))
1047         if err != nil {
1048                 t.Fatalf("Chtimes %s: %s", name, err)
1049         }
1050
1051         st, err = Stat(name)
1052         if err != nil {
1053                 t.Fatalf("second Stat %s: %s", name, err)
1054         }
1055         postStat := st
1056
1057         /* Plan 9, NaCl:
1058                 Mtime is the time of the last change of content.  Similarly, atime is set whenever the
1059             contents are accessed; also, it is set whenever mtime is set.
1060         */
1061         pat := Atime(postStat)
1062         pmt := postStat.ModTime()
1063         if !pat.Before(at) && runtime.GOOS != "plan9" && runtime.GOOS != "nacl" {
1064                 t.Errorf("AccessTime didn't go backwards; was=%d, after=%d", at, pat)
1065         }
1066
1067         if !pmt.Before(mt) {
1068                 t.Errorf("ModTime didn't go backwards; was=%v, after=%v", mt, pmt)
1069         }
1070 }
1071
1072 func TestChdirAndGetwd(t *testing.T) {
1073         // TODO(brainman): file.Chdir() is not implemented on windows.
1074         if runtime.GOOS == "windows" {
1075                 return
1076         }
1077         fd, err := Open(".")
1078         if err != nil {
1079                 t.Fatalf("Open .: %s", err)
1080         }
1081         // These are chosen carefully not to be symlinks on a Mac
1082         // (unlike, say, /var, /etc), except /tmp, which we handle below.
1083         dirs := []string{"/", "/usr/bin", "/tmp"}
1084         // /usr/bin does not usually exist on Plan 9 or Android.
1085         switch runtime.GOOS {
1086         case "android":
1087                 dirs = []string{"/", "/system/bin"}
1088         case "plan9":
1089                 dirs = []string{"/", "/usr"}
1090         case "darwin":
1091                 switch runtime.GOARCH {
1092                 case "arm", "arm64":
1093                         d1, err := ioutil.TempDir("", "d1")
1094                         if err != nil {
1095                                 t.Fatalf("TempDir: %v", err)
1096                         }
1097                         d2, err := ioutil.TempDir("", "d2")
1098                         if err != nil {
1099                                 t.Fatalf("TempDir: %v", err)
1100                         }
1101                         dirs = []string{d1, d2}
1102                 }
1103         }
1104         oldwd := Getenv("PWD")
1105         for mode := 0; mode < 2; mode++ {
1106                 for _, d := range dirs {
1107                         if mode == 0 {
1108                                 err = Chdir(d)
1109                         } else {
1110                                 fd1, err := Open(d)
1111                                 if err != nil {
1112                                         t.Errorf("Open %s: %s", d, err)
1113                                         continue
1114                                 }
1115                                 err = fd1.Chdir()
1116                                 fd1.Close()
1117                         }
1118                         if d == "/tmp" {
1119                                 Setenv("PWD", "/tmp")
1120                         }
1121                         pwd, err1 := Getwd()
1122                         Setenv("PWD", oldwd)
1123                         err2 := fd.Chdir()
1124                         if err2 != nil {
1125                                 // We changed the current directory and cannot go back.
1126                                 // Don't let the tests continue; they'll scribble
1127                                 // all over some other directory.
1128                                 fmt.Fprintf(Stderr, "fchdir back to dot failed: %s\n", err2)
1129                                 Exit(1)
1130                         }
1131                         if err != nil {
1132                                 fd.Close()
1133                                 t.Fatalf("Chdir %s: %s", d, err)
1134                         }
1135                         if err1 != nil {
1136                                 fd.Close()
1137                                 t.Fatalf("Getwd in %s: %s", d, err1)
1138                         }
1139                         if pwd != d {
1140                                 fd.Close()
1141                                 t.Fatalf("Getwd returned %q want %q", pwd, d)
1142                         }
1143                 }
1144         }
1145         fd.Close()
1146 }
1147
1148 // Test that Chdir+Getwd is program-wide.
1149 func TestProgWideChdir(t *testing.T) {
1150         const N = 10
1151         c := make(chan bool)
1152         cpwd := make(chan string)
1153         for i := 0; i < N; i++ {
1154                 go func(i int) {
1155                         // Lock half the goroutines in their own operating system
1156                         // thread to exercise more scheduler possibilities.
1157                         if i%2 == 1 {
1158                                 // On Plan 9, after calling LockOSThread, the goroutines
1159                                 // run on different processes which don't share the working
1160                                 // directory. This used to be an issue because Go expects
1161                                 // the working directory to be program-wide.
1162                                 // See issue 9428.
1163                                 runtime.LockOSThread()
1164                         }
1165                         <-c
1166                         pwd, err := Getwd()
1167                         if err != nil {
1168                                 t.Errorf("Getwd on goroutine %d: %v", i, err)
1169                                 return
1170                         }
1171                         cpwd <- pwd
1172                 }(i)
1173         }
1174         oldwd, err := Getwd()
1175         if err != nil {
1176                 t.Fatalf("Getwd: %v", err)
1177         }
1178         d, err := ioutil.TempDir("", "test")
1179         if err != nil {
1180                 t.Fatalf("TempDir: %v", err)
1181         }
1182         defer func() {
1183                 if err := Chdir(oldwd); err != nil {
1184                         t.Fatalf("Chdir: %v", err)
1185                 }
1186                 RemoveAll(d)
1187         }()
1188         if err := Chdir(d); err != nil {
1189                 t.Fatalf("Chdir: %v", err)
1190         }
1191         // OS X sets TMPDIR to a symbolic link.
1192         // So we resolve our working directory again before the test.
1193         d, err = Getwd()
1194         if err != nil {
1195                 t.Fatalf("Getwd: %v", err)
1196         }
1197         close(c)
1198         for i := 0; i < N; i++ {
1199                 pwd := <-cpwd
1200                 if pwd != d {
1201                         t.Errorf("Getwd returned %q; want %q", pwd, d)
1202                 }
1203         }
1204 }
1205
1206 func TestSeek(t *testing.T) {
1207         f := newFile("TestSeek", t)
1208         defer Remove(f.Name())
1209         defer f.Close()
1210
1211         const data = "hello, world\n"
1212         io.WriteString(f, data)
1213
1214         type test struct {
1215                 in     int64
1216                 whence int
1217                 out    int64
1218         }
1219         var tests = []test{
1220                 {0, io.SeekCurrent, int64(len(data))},
1221                 {0, io.SeekStart, 0},
1222                 {5, io.SeekStart, 5},
1223                 {0, io.SeekEnd, int64(len(data))},
1224                 {0, io.SeekStart, 0},
1225                 {-1, io.SeekEnd, int64(len(data)) - 1},
1226                 {1 << 33, io.SeekStart, 1 << 33},
1227                 {1 << 33, io.SeekEnd, 1<<33 + int64(len(data))},
1228         }
1229         for i, tt := range tests {
1230                 off, err := f.Seek(tt.in, tt.whence)
1231                 if off != tt.out || err != nil {
1232                         if e, ok := err.(*PathError); ok && e.Err == syscall.EINVAL && tt.out > 1<<32 {
1233                                 // Reiserfs rejects the big seeks.
1234                                 // https://golang.org/issue/91
1235                                 break
1236                         }
1237                         t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
1238                 }
1239         }
1240 }
1241
1242 type openErrorTest struct {
1243         path  string
1244         mode  int
1245         error error
1246 }
1247
1248 var openErrorTests = []openErrorTest{
1249         {
1250                 sfdir + "/no-such-file",
1251                 O_RDONLY,
1252                 syscall.ENOENT,
1253         },
1254         {
1255                 sfdir,
1256                 O_WRONLY,
1257                 syscall.EISDIR,
1258         },
1259         {
1260                 sfdir + "/" + sfname + "/no-such-file",
1261                 O_WRONLY,
1262                 syscall.ENOTDIR,
1263         },
1264 }
1265
1266 func TestOpenError(t *testing.T) {
1267         for _, tt := range openErrorTests {
1268                 f, err := OpenFile(tt.path, tt.mode, 0)
1269                 if err == nil {
1270                         t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode)
1271                         f.Close()
1272                         continue
1273                 }
1274                 perr, ok := err.(*PathError)
1275                 if !ok {
1276                         t.Errorf("Open(%q, %d) returns error of %T type; want *PathError", tt.path, tt.mode, err)
1277                 }
1278                 if perr.Err != tt.error {
1279                         if runtime.GOOS == "plan9" {
1280                                 syscallErrStr := perr.Err.Error()
1281                                 expectedErrStr := strings.Replace(tt.error.Error(), "file ", "", 1)
1282                                 if !strings.HasSuffix(syscallErrStr, expectedErrStr) {
1283                                         // Some Plan 9 file servers incorrectly return
1284                                         // EACCES rather than EISDIR when a directory is
1285                                         // opened for write.
1286                                         if tt.error == syscall.EISDIR && strings.HasSuffix(syscallErrStr, syscall.EACCES.Error()) {
1287                                                 continue
1288                                         }
1289                                         t.Errorf("Open(%q, %d) = _, %q; want suffix %q", tt.path, tt.mode, syscallErrStr, expectedErrStr)
1290                                 }
1291                                 continue
1292                         }
1293                         if runtime.GOOS == "dragonfly" {
1294                                 // DragonFly incorrectly returns EACCES rather
1295                                 // EISDIR when a directory is opened for write.
1296                                 if tt.error == syscall.EISDIR && perr.Err == syscall.EACCES {
1297                                         continue
1298                                 }
1299                         }
1300                         t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Err.Error(), tt.error.Error())
1301                 }
1302         }
1303 }
1304
1305 func TestOpenNoName(t *testing.T) {
1306         f, err := Open("")
1307         if err == nil {
1308                 t.Fatal(`Open("") succeeded`)
1309                 f.Close()
1310         }
1311 }
1312
1313 func runBinHostname(t *testing.T) string {
1314         // Run /bin/hostname and collect output.
1315         r, w, err := Pipe()
1316         if err != nil {
1317                 t.Fatal(err)
1318         }
1319         defer r.Close()
1320         const path = "/bin/hostname"
1321         p, err := StartProcess(path, []string{"hostname"}, &ProcAttr{Files: []*File{nil, w, Stderr}})
1322         if err != nil {
1323                 if _, err := Stat(path); IsNotExist(err) {
1324                         t.Skipf("skipping test; test requires %s but it does not exist", path)
1325                 }
1326                 t.Fatal(err)
1327         }
1328         w.Close()
1329
1330         var b bytes.Buffer
1331         io.Copy(&b, r)
1332         _, err = p.Wait()
1333         if err != nil {
1334                 t.Fatalf("run hostname Wait: %v", err)
1335         }
1336         err = p.Kill()
1337         if err == nil {
1338                 t.Errorf("expected an error from Kill running 'hostname'")
1339         }
1340         output := b.String()
1341         if n := len(output); n > 0 && output[n-1] == '\n' {
1342                 output = output[0 : n-1]
1343         }
1344         if output == "" {
1345                 t.Fatalf("/bin/hostname produced no output")
1346         }
1347
1348         return output
1349 }
1350
1351 func testWindowsHostname(t *testing.T) {
1352         hostname, err := Hostname()
1353         if err != nil {
1354                 t.Fatal(err)
1355         }
1356         cmd := osexec.Command("hostname")
1357         out, err := cmd.CombinedOutput()
1358         if err != nil {
1359                 t.Fatalf("Failed to execute hostname command: %v %s", err, out)
1360         }
1361         want := strings.Trim(string(out), "\r\n")
1362         if hostname != want {
1363                 t.Fatalf("Hostname() = %q, want %q", hostname, want)
1364         }
1365 }
1366
1367 func TestHostname(t *testing.T) {
1368         // There is no other way to fetch hostname on windows, but via winapi.
1369         // On Plan 9 it can be taken from #c/sysname as Hostname() does.
1370         switch runtime.GOOS {
1371         case "android", "plan9":
1372                 t.Skipf("%s doesn't have /bin/hostname", runtime.GOOS)
1373         case "windows":
1374                 testWindowsHostname(t)
1375                 return
1376         }
1377
1378         testenv.MustHaveExec(t)
1379
1380         // Check internal Hostname() against the output of /bin/hostname.
1381         // Allow that the internal Hostname returns a Fully Qualified Domain Name
1382         // and the /bin/hostname only returns the first component
1383         hostname, err := Hostname()
1384         if err != nil {
1385                 t.Fatalf("%v", err)
1386         }
1387         want := runBinHostname(t)
1388         if hostname != want {
1389                 i := strings.Index(hostname, ".")
1390                 if i < 0 || hostname[0:i] != want {
1391                         t.Errorf("Hostname() = %q, want %q", hostname, want)
1392                 }
1393         }
1394 }
1395
1396 func TestReadAt(t *testing.T) {
1397         f := newFile("TestReadAt", t)
1398         defer Remove(f.Name())
1399         defer f.Close()
1400
1401         const data = "hello, world\n"
1402         io.WriteString(f, data)
1403
1404         b := make([]byte, 5)
1405         n, err := f.ReadAt(b, 7)
1406         if err != nil || n != len(b) {
1407                 t.Fatalf("ReadAt 7: %d, %v", n, err)
1408         }
1409         if string(b) != "world" {
1410                 t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
1411         }
1412 }
1413
1414 // Verify that ReadAt doesn't affect seek offset.
1415 // In the Plan 9 kernel, there used to be a bug in the implementation of
1416 // the pread syscall, where the channel offset was erroneously updated after
1417 // calling pread on a file.
1418 func TestReadAtOffset(t *testing.T) {
1419         f := newFile("TestReadAtOffset", t)
1420         defer Remove(f.Name())
1421         defer f.Close()
1422
1423         const data = "hello, world\n"
1424         io.WriteString(f, data)
1425
1426         f.Seek(0, 0)
1427         b := make([]byte, 5)
1428
1429         n, err := f.ReadAt(b, 7)
1430         if err != nil || n != len(b) {
1431                 t.Fatalf("ReadAt 7: %d, %v", n, err)
1432         }
1433         if string(b) != "world" {
1434                 t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
1435         }
1436
1437         n, err = f.Read(b)
1438         if err != nil || n != len(b) {
1439                 t.Fatalf("Read: %d, %v", n, err)
1440         }
1441         if string(b) != "hello" {
1442                 t.Fatalf("Read: have %q want %q", string(b), "hello")
1443         }
1444 }
1445
1446 func TestWriteAt(t *testing.T) {
1447         f := newFile("TestWriteAt", t)
1448         defer Remove(f.Name())
1449         defer f.Close()
1450
1451         const data = "hello, world\n"
1452         io.WriteString(f, data)
1453
1454         n, err := f.WriteAt([]byte("WORLD"), 7)
1455         if err != nil || n != 5 {
1456                 t.Fatalf("WriteAt 7: %d, %v", n, err)
1457         }
1458
1459         b, err := ioutil.ReadFile(f.Name())
1460         if err != nil {
1461                 t.Fatalf("ReadFile %s: %v", f.Name(), err)
1462         }
1463         if string(b) != "hello, WORLD\n" {
1464                 t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n")
1465         }
1466 }
1467
1468 func writeFile(t *testing.T, fname string, flag int, text string) string {
1469         f, err := OpenFile(fname, flag, 0666)
1470         if err != nil {
1471                 t.Fatalf("Open: %v", err)
1472         }
1473         n, err := io.WriteString(f, text)
1474         if err != nil {
1475                 t.Fatalf("WriteString: %d, %v", n, err)
1476         }
1477         f.Close()
1478         data, err := ioutil.ReadFile(fname)
1479         if err != nil {
1480                 t.Fatalf("ReadFile: %v", err)
1481         }
1482         return string(data)
1483 }
1484
1485 func TestAppend(t *testing.T) {
1486         defer chtmpdir(t)()
1487         const f = "append.txt"
1488         defer Remove(f)
1489         s := writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
1490         if s != "new" {
1491                 t.Fatalf("writeFile: have %q want %q", s, "new")
1492         }
1493         s = writeFile(t, f, O_APPEND|O_RDWR, "|append")
1494         if s != "new|append" {
1495                 t.Fatalf("writeFile: have %q want %q", s, "new|append")
1496         }
1497         s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "|append")
1498         if s != "new|append|append" {
1499                 t.Fatalf("writeFile: have %q want %q", s, "new|append|append")
1500         }
1501         err := Remove(f)
1502         if err != nil {
1503                 t.Fatalf("Remove: %v", err)
1504         }
1505         s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "new&append")
1506         if s != "new&append" {
1507                 t.Fatalf("writeFile: after append have %q want %q", s, "new&append")
1508         }
1509         s = writeFile(t, f, O_CREATE|O_RDWR, "old")
1510         if s != "old&append" {
1511                 t.Fatalf("writeFile: after create have %q want %q", s, "old&append")
1512         }
1513         s = writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
1514         if s != "new" {
1515                 t.Fatalf("writeFile: after truncate have %q want %q", s, "new")
1516         }
1517 }
1518
1519 func TestStatDirWithTrailingSlash(t *testing.T) {
1520         // Create new temporary directory and arrange to clean it up.
1521         path, err := ioutil.TempDir("", "/_TestStatDirWithSlash_")
1522         if err != nil {
1523                 t.Fatalf("TempDir: %s", err)
1524         }
1525         defer RemoveAll(path)
1526
1527         // Stat of path should succeed.
1528         _, err = Stat(path)
1529         if err != nil {
1530                 t.Fatalf("stat %s failed: %s", path, err)
1531         }
1532
1533         // Stat of path+"/" should succeed too.
1534         path += "/"
1535         _, err = Stat(path)
1536         if err != nil {
1537                 t.Fatalf("stat %s failed: %s", path, err)
1538         }
1539 }
1540
1541 func TestNilProcessStateString(t *testing.T) {
1542         var ps *ProcessState
1543         s := ps.String()
1544         if s != "<nil>" {
1545                 t.Errorf("(*ProcessState)(nil).String() = %q, want %q", s, "<nil>")
1546         }
1547 }
1548
1549 func TestSameFile(t *testing.T) {
1550         defer chtmpdir(t)()
1551         fa, err := Create("a")
1552         if err != nil {
1553                 t.Fatalf("Create(a): %v", err)
1554         }
1555         defer Remove(fa.Name())
1556         fa.Close()
1557         fb, err := Create("b")
1558         if err != nil {
1559                 t.Fatalf("Create(b): %v", err)
1560         }
1561         defer Remove(fb.Name())
1562         fb.Close()
1563
1564         ia1, err := Stat("a")
1565         if err != nil {
1566                 t.Fatalf("Stat(a): %v", err)
1567         }
1568         ia2, err := Stat("a")
1569         if err != nil {
1570                 t.Fatalf("Stat(a): %v", err)
1571         }
1572         if !SameFile(ia1, ia2) {
1573                 t.Errorf("files should be same")
1574         }
1575
1576         ib, err := Stat("b")
1577         if err != nil {
1578                 t.Fatalf("Stat(b): %v", err)
1579         }
1580         if SameFile(ia1, ib) {
1581                 t.Errorf("files should be different")
1582         }
1583 }
1584
1585 func TestDevNullFile(t *testing.T) {
1586         f, err := Open(DevNull)
1587         if err != nil {
1588                 t.Fatalf("Open(%s): %v", DevNull, err)
1589         }
1590         defer f.Close()
1591         fi, err := f.Stat()
1592         if err != nil {
1593                 t.Fatalf("Stat(%s): %v", DevNull, err)
1594         }
1595         name := filepath.Base(DevNull)
1596         if fi.Name() != name {
1597                 t.Fatalf("wrong file name have %v want %v", fi.Name(), name)
1598         }
1599         if fi.Size() != 0 {
1600                 t.Fatalf("wrong file size have %d want 0", fi.Size())
1601         }
1602 }
1603
1604 var testLargeWrite = flag.Bool("large_write", false, "run TestLargeWriteToConsole test that floods console with output")
1605
1606 func TestLargeWriteToConsole(t *testing.T) {
1607         if !*testLargeWrite {
1608                 t.Skip("skipping console-flooding test; enable with -large_write")
1609         }
1610         b := make([]byte, 32000)
1611         for i := range b {
1612                 b[i] = '.'
1613         }
1614         b[len(b)-1] = '\n'
1615         n, err := Stdout.Write(b)
1616         if err != nil {
1617                 t.Fatalf("Write to os.Stdout failed: %v", err)
1618         }
1619         if n != len(b) {
1620                 t.Errorf("Write to os.Stdout should return %d; got %d", len(b), n)
1621         }
1622         n, err = Stderr.Write(b)
1623         if err != nil {
1624                 t.Fatalf("Write to os.Stderr failed: %v", err)
1625         }
1626         if n != len(b) {
1627                 t.Errorf("Write to os.Stderr should return %d; got %d", len(b), n)
1628         }
1629 }
1630
1631 func TestStatDirModeExec(t *testing.T) {
1632         const mode = 0111
1633
1634         path, err := ioutil.TempDir("", "go-build")
1635         if err != nil {
1636                 t.Fatalf("Failed to create temp directory: %v", err)
1637         }
1638         defer RemoveAll(path)
1639
1640         if err := Chmod(path, 0777); err != nil {
1641                 t.Fatalf("Chmod %q 0777: %v", path, err)
1642         }
1643
1644         dir, err := Stat(path)
1645         if err != nil {
1646                 t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
1647         }
1648         if dir.Mode()&mode != mode {
1649                 t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode()&mode, mode)
1650         }
1651 }
1652
1653 func TestStatStdin(t *testing.T) {
1654         switch runtime.GOOS {
1655         case "android", "plan9":
1656                 t.Skipf("%s doesn't have /bin/sh", runtime.GOOS)
1657         }
1658
1659         testenv.MustHaveExec(t)
1660
1661         if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
1662                 st, err := Stdin.Stat()
1663                 if err != nil {
1664                         t.Fatalf("Stat failed: %v", err)
1665                 }
1666                 fmt.Println(st.Mode() & ModeNamedPipe)
1667                 Exit(0)
1668         }
1669
1670         var cmd *osexec.Cmd
1671         if runtime.GOOS == "windows" {
1672                 cmd = osexec.Command("cmd", "/c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
1673         } else {
1674                 cmd = osexec.Command("/bin/sh", "-c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
1675         }
1676         cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
1677
1678         output, err := cmd.CombinedOutput()
1679         if err != nil {
1680                 t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
1681         }
1682
1683         // result will be like "prw-rw-rw"
1684         if len(output) < 1 || output[0] != 'p' {
1685                 t.Fatalf("Child process reports stdin is not pipe '%v'", string(output))
1686         }
1687 }
1688
1689 func TestReadAtEOF(t *testing.T) {
1690         f := newFile("TestReadAtEOF", t)
1691         defer Remove(f.Name())
1692         defer f.Close()
1693
1694         _, err := f.ReadAt(make([]byte, 10), 0)
1695         switch err {
1696         case io.EOF:
1697                 // all good
1698         case nil:
1699                 t.Fatalf("ReadAt succeeded")
1700         default:
1701                 t.Fatalf("ReadAt failed: %s", err)
1702         }
1703 }
1704
1705 func TestLongPath(t *testing.T) {
1706         tmpdir := newDir("TestLongPath", t)
1707         defer func(d string) {
1708                 if err := RemoveAll(d); err != nil {
1709                         t.Fatalf("RemoveAll failed: %v", err)
1710                 }
1711         }(tmpdir)
1712
1713         // Test the boundary of 247 and fewer bytes (normal) and 248 and more bytes (adjusted).
1714         sizes := []int{247, 248, 249, 400}
1715         for len(tmpdir) < 400 {
1716                 tmpdir += "/dir3456789"
1717         }
1718         for _, sz := range sizes {
1719                 t.Run(fmt.Sprintf("length=%d", sz), func(t *testing.T) {
1720                         sizedTempDir := tmpdir[:sz-1] + "x" // Ensure it does not end with a slash.
1721
1722                         // The various sized runs are for this call to trigger the boundary
1723                         // condition.
1724                         if err := MkdirAll(sizedTempDir, 0755); err != nil {
1725                                 t.Fatalf("MkdirAll failed: %v", err)
1726                         }
1727                         data := []byte("hello world\n")
1728                         if err := ioutil.WriteFile(sizedTempDir+"/foo.txt", data, 0644); err != nil {
1729                                 t.Fatalf("ioutil.WriteFile() failed: %v", err)
1730                         }
1731                         if err := Rename(sizedTempDir+"/foo.txt", sizedTempDir+"/bar.txt"); err != nil {
1732                                 t.Fatalf("Rename failed: %v", err)
1733                         }
1734                         mtime := time.Now().Truncate(time.Minute)
1735                         if err := Chtimes(sizedTempDir+"/bar.txt", mtime, mtime); err != nil {
1736                                 t.Fatalf("Chtimes failed: %v", err)
1737                         }
1738                         names := []string{"bar.txt"}
1739                         if testenv.HasSymlink() {
1740                                 if err := Symlink(sizedTempDir+"/bar.txt", sizedTempDir+"/symlink.txt"); err != nil {
1741                                         t.Fatalf("Symlink failed: %v", err)
1742                                 }
1743                                 names = append(names, "symlink.txt")
1744                         }
1745                         if testenv.HasLink() {
1746                                 if err := Link(sizedTempDir+"/bar.txt", sizedTempDir+"/link.txt"); err != nil {
1747                                         t.Fatalf("Link failed: %v", err)
1748                                 }
1749                                 names = append(names, "link.txt")
1750                         }
1751                         for _, wantSize := range []int64{int64(len(data)), 0} {
1752                                 for _, name := range names {
1753                                         path := sizedTempDir + "/" + name
1754                                         dir, err := Stat(path)
1755                                         if err != nil {
1756                                                 t.Fatalf("Stat(%q) failed: %v", path, err)
1757                                         }
1758                                         filesize := size(path, t)
1759                                         if dir.Size() != filesize || filesize != wantSize {
1760                                                 t.Errorf("Size(%q) is %d, len(ReadFile()) is %d, want %d", path, dir.Size(), filesize, wantSize)
1761                                         }
1762                                 }
1763                                 if err := Truncate(sizedTempDir+"/bar.txt", 0); err != nil {
1764                                         t.Fatalf("Truncate failed: %v", err)
1765                                 }
1766                         }
1767                 })
1768         }
1769 }
1770
1771 func testKillProcess(t *testing.T, processKiller func(p *Process)) {
1772         testenv.MustHaveExec(t)
1773
1774         // Re-exec the test binary itself to emulate "sleep 1".
1775         cmd := osexec.Command(Args[0], "-test.run", "TestSleep")
1776         err := cmd.Start()
1777         if err != nil {
1778                 t.Fatalf("Failed to start test process: %v", err)
1779         }
1780         go func() {
1781                 time.Sleep(100 * time.Millisecond)
1782                 processKiller(cmd.Process)
1783         }()
1784         err = cmd.Wait()
1785         if err == nil {
1786                 t.Errorf("Test process succeeded, but expected to fail")
1787         }
1788 }
1789
1790 // TestSleep emulates "sleep 1". It is a helper for testKillProcess, so we
1791 // don't have to rely on an external "sleep" command being available.
1792 func TestSleep(t *testing.T) {
1793         if testing.Short() {
1794                 t.Skip("Skipping in short mode")
1795         }
1796         time.Sleep(time.Second)
1797 }
1798
1799 func TestKillStartProcess(t *testing.T) {
1800         testKillProcess(t, func(p *Process) {
1801                 err := p.Kill()
1802                 if err != nil {
1803                         t.Fatalf("Failed to kill test process: %v", err)
1804                 }
1805         })
1806 }
1807
1808 func TestGetppid(t *testing.T) {
1809         if runtime.GOOS == "plan9" {
1810                 // TODO: golang.org/issue/8206
1811                 t.Skipf("skipping test on plan9; see issue 8206")
1812         }
1813
1814         testenv.MustHaveExec(t)
1815
1816         if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
1817                 fmt.Print(Getppid())
1818                 Exit(0)
1819         }
1820
1821         cmd := osexec.Command(Args[0], "-test.run=TestGetppid")
1822         cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
1823
1824         // verify that Getppid() from the forked process reports our process id
1825         output, err := cmd.CombinedOutput()
1826         if err != nil {
1827                 t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
1828         }
1829
1830         childPpid := string(output)
1831         ourPid := fmt.Sprintf("%d", Getpid())
1832         if childPpid != ourPid {
1833                 t.Fatalf("Child process reports parent process id '%v', expected '%v'", childPpid, ourPid)
1834         }
1835 }
1836
1837 func TestKillFindProcess(t *testing.T) {
1838         testKillProcess(t, func(p *Process) {
1839                 p2, err := FindProcess(p.Pid)
1840                 if err != nil {
1841                         t.Fatalf("Failed to find test process: %v", err)
1842                 }
1843                 err = p2.Kill()
1844                 if err != nil {
1845                         t.Fatalf("Failed to kill test process: %v", err)
1846                 }
1847         })
1848 }
1849
1850 var nilFileMethodTests = []struct {
1851         name string
1852         f    func(*File) error
1853 }{
1854         {"Chdir", func(f *File) error { return f.Chdir() }},
1855         {"Close", func(f *File) error { return f.Close() }},
1856         {"Chmod", func(f *File) error { return f.Chmod(0) }},
1857         {"Chown", func(f *File) error { return f.Chown(0, 0) }},
1858         {"Read", func(f *File) error { _, err := f.Read(make([]byte, 0)); return err }},
1859         {"ReadAt", func(f *File) error { _, err := f.ReadAt(make([]byte, 0), 0); return err }},
1860         {"Readdir", func(f *File) error { _, err := f.Readdir(1); return err }},
1861         {"Readdirnames", func(f *File) error { _, err := f.Readdirnames(1); return err }},
1862         {"Seek", func(f *File) error { _, err := f.Seek(0, io.SeekStart); return err }},
1863         {"Stat", func(f *File) error { _, err := f.Stat(); return err }},
1864         {"Sync", func(f *File) error { return f.Sync() }},
1865         {"Truncate", func(f *File) error { return f.Truncate(0) }},
1866         {"Write", func(f *File) error { _, err := f.Write(make([]byte, 0)); return err }},
1867         {"WriteAt", func(f *File) error { _, err := f.WriteAt(make([]byte, 0), 0); return err }},
1868         {"WriteString", func(f *File) error { _, err := f.WriteString(""); return err }},
1869 }
1870
1871 // Test that all File methods give ErrInvalid if the receiver is nil.
1872 func TestNilFileMethods(t *testing.T) {
1873         for _, tt := range nilFileMethodTests {
1874                 var file *File
1875                 got := tt.f(file)
1876                 if got != ErrInvalid {
1877                         t.Errorf("%v should fail when f is nil; got %v", tt.name, got)
1878                 }
1879         }
1880 }
1881
1882 func mkdirTree(t *testing.T, root string, level, max int) {
1883         if level >= max {
1884                 return
1885         }
1886         level++
1887         for i := 'a'; i < 'c'; i++ {
1888                 dir := filepath.Join(root, string(i))
1889                 if err := Mkdir(dir, 0700); err != nil {
1890                         t.Fatal(err)
1891                 }
1892                 mkdirTree(t, dir, level, max)
1893         }
1894 }
1895
1896 // Test that simultaneous RemoveAll do not report an error.
1897 // As long as it gets removed, we should be happy.
1898 func TestRemoveAllRace(t *testing.T) {
1899         if runtime.GOOS == "windows" {
1900                 // Windows has very strict rules about things like
1901                 // removing directories while someone else has
1902                 // them open. The racing doesn't work out nicely
1903                 // like it does on Unix.
1904                 t.Skip("skipping on windows")
1905         }
1906
1907         n := runtime.GOMAXPROCS(16)
1908         defer runtime.GOMAXPROCS(n)
1909         root, err := ioutil.TempDir("", "issue")
1910         if err != nil {
1911                 t.Fatal(err)
1912         }
1913         mkdirTree(t, root, 1, 6)
1914         hold := make(chan struct{})
1915         var wg sync.WaitGroup
1916         for i := 0; i < 4; i++ {
1917                 wg.Add(1)
1918                 go func() {
1919                         defer wg.Done()
1920                         <-hold
1921                         err := RemoveAll(root)
1922                         if err != nil {
1923                                 t.Errorf("unexpected error: %T, %q", err, err)
1924                         }
1925                 }()
1926         }
1927         close(hold) // let workers race to remove root
1928         wg.Wait()
1929 }