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