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 "js", "nacl", "plan9":
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, hostname string) {
1525         cmd := osexec.Command("hostname")
1526         out, err := cmd.CombinedOutput()
1527         if err != nil {
1528                 t.Fatalf("Failed to execute hostname command: %v %s", err, out)
1529         }
1530         want := strings.Trim(string(out), "\r\n")
1531         if hostname != want {
1532                 t.Fatalf("Hostname() = %q != system hostname of %q", hostname, want)
1533         }
1534 }
1535
1536 func TestHostname(t *testing.T) {
1537         hostname, err := Hostname()
1538         if err != nil {
1539                 t.Fatal(err)
1540         }
1541         if hostname == "" {
1542                 t.Fatal("Hostname returned empty string and no error")
1543         }
1544         if strings.Contains(hostname, "\x00") {
1545                 t.Fatalf("unexpected zero byte in hostname: %q", hostname)
1546         }
1547
1548         // There is no other way to fetch hostname on windows, but via winapi.
1549         // On Plan 9 it can be taken from #c/sysname as Hostname() does.
1550         switch runtime.GOOS {
1551         case "android", "plan9":
1552                 // No /bin/hostname to verify against.
1553                 return
1554         case "windows":
1555                 testWindowsHostname(t, hostname)
1556                 return
1557         }
1558
1559         testenv.MustHaveExec(t)
1560
1561         // Check internal Hostname() against the output of /bin/hostname.
1562         // Allow that the internal Hostname returns a Fully Qualified Domain Name
1563         // and the /bin/hostname only returns the first component
1564         var want string
1565         if runtime.GOOS == "aix" {
1566                 want = runBinHostname(t, []string{"hostname", "-s"})
1567         } else {
1568                 want = runBinHostname(t, []string{"hostname"})
1569         }
1570         if hostname != want {
1571                 i := strings.Index(hostname, ".")
1572                 if i < 0 || hostname[0:i] != want {
1573                         t.Errorf("Hostname() = %q, want %q", hostname, want)
1574                 }
1575         }
1576 }
1577
1578 func TestReadAt(t *testing.T) {
1579         f := newFile("TestReadAt", t)
1580         defer Remove(f.Name())
1581         defer f.Close()
1582
1583         const data = "hello, world\n"
1584         io.WriteString(f, data)
1585
1586         b := make([]byte, 5)
1587         n, err := f.ReadAt(b, 7)
1588         if err != nil || n != len(b) {
1589                 t.Fatalf("ReadAt 7: %d, %v", n, err)
1590         }
1591         if string(b) != "world" {
1592                 t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
1593         }
1594 }
1595
1596 // Verify that ReadAt doesn't affect seek offset.
1597 // In the Plan 9 kernel, there used to be a bug in the implementation of
1598 // the pread syscall, where the channel offset was erroneously updated after
1599 // calling pread on a file.
1600 func TestReadAtOffset(t *testing.T) {
1601         f := newFile("TestReadAtOffset", t)
1602         defer Remove(f.Name())
1603         defer f.Close()
1604
1605         const data = "hello, world\n"
1606         io.WriteString(f, data)
1607
1608         f.Seek(0, 0)
1609         b := make([]byte, 5)
1610
1611         n, err := f.ReadAt(b, 7)
1612         if err != nil || n != len(b) {
1613                 t.Fatalf("ReadAt 7: %d, %v", n, err)
1614         }
1615         if string(b) != "world" {
1616                 t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
1617         }
1618
1619         n, err = f.Read(b)
1620         if err != nil || n != len(b) {
1621                 t.Fatalf("Read: %d, %v", n, err)
1622         }
1623         if string(b) != "hello" {
1624                 t.Fatalf("Read: have %q want %q", string(b), "hello")
1625         }
1626 }
1627
1628 // Verify that ReadAt doesn't allow negative offset.
1629 func TestReadAtNegativeOffset(t *testing.T) {
1630         f := newFile("TestReadAtNegativeOffset", t)
1631         defer Remove(f.Name())
1632         defer f.Close()
1633
1634         const data = "hello, world\n"
1635         io.WriteString(f, data)
1636
1637         f.Seek(0, 0)
1638         b := make([]byte, 5)
1639
1640         n, err := f.ReadAt(b, -10)
1641
1642         const wantsub = "negative offset"
1643         if !strings.Contains(fmt.Sprint(err), wantsub) || n != 0 {
1644                 t.Errorf("ReadAt(-10) = %v, %v; want 0, ...%q...", n, err, wantsub)
1645         }
1646 }
1647
1648 func TestWriteAt(t *testing.T) {
1649         f := newFile("TestWriteAt", t)
1650         defer Remove(f.Name())
1651         defer f.Close()
1652
1653         const data = "hello, world\n"
1654         io.WriteString(f, data)
1655
1656         n, err := f.WriteAt([]byte("WORLD"), 7)
1657         if err != nil || n != 5 {
1658                 t.Fatalf("WriteAt 7: %d, %v", n, err)
1659         }
1660
1661         b, err := ioutil.ReadFile(f.Name())
1662         if err != nil {
1663                 t.Fatalf("ReadFile %s: %v", f.Name(), err)
1664         }
1665         if string(b) != "hello, WORLD\n" {
1666                 t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n")
1667         }
1668 }
1669
1670 // Verify that WriteAt doesn't allow negative offset.
1671 func TestWriteAtNegativeOffset(t *testing.T) {
1672         f := newFile("TestWriteAtNegativeOffset", t)
1673         defer Remove(f.Name())
1674         defer f.Close()
1675
1676         n, err := f.WriteAt([]byte("WORLD"), -10)
1677
1678         const wantsub = "negative offset"
1679         if !strings.Contains(fmt.Sprint(err), wantsub) || n != 0 {
1680                 t.Errorf("WriteAt(-10) = %v, %v; want 0, ...%q...", n, err, wantsub)
1681         }
1682 }
1683
1684 func writeFile(t *testing.T, fname string, flag int, text string) string {
1685         f, err := OpenFile(fname, flag, 0666)
1686         if err != nil {
1687                 t.Fatalf("Open: %v", err)
1688         }
1689         n, err := io.WriteString(f, text)
1690         if err != nil {
1691                 t.Fatalf("WriteString: %d, %v", n, err)
1692         }
1693         f.Close()
1694         data, err := ioutil.ReadFile(fname)
1695         if err != nil {
1696                 t.Fatalf("ReadFile: %v", err)
1697         }
1698         return string(data)
1699 }
1700
1701 func TestAppend(t *testing.T) {
1702         defer chtmpdir(t)()
1703         const f = "append.txt"
1704         defer Remove(f)
1705         s := writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
1706         if s != "new" {
1707                 t.Fatalf("writeFile: have %q want %q", s, "new")
1708         }
1709         s = writeFile(t, f, O_APPEND|O_RDWR, "|append")
1710         if s != "new|append" {
1711                 t.Fatalf("writeFile: have %q want %q", s, "new|append")
1712         }
1713         s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "|append")
1714         if s != "new|append|append" {
1715                 t.Fatalf("writeFile: have %q want %q", s, "new|append|append")
1716         }
1717         err := Remove(f)
1718         if err != nil {
1719                 t.Fatalf("Remove: %v", err)
1720         }
1721         s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "new&append")
1722         if s != "new&append" {
1723                 t.Fatalf("writeFile: after append have %q want %q", s, "new&append")
1724         }
1725         s = writeFile(t, f, O_CREATE|O_RDWR, "old")
1726         if s != "old&append" {
1727                 t.Fatalf("writeFile: after create have %q want %q", s, "old&append")
1728         }
1729         s = writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new")
1730         if s != "new" {
1731                 t.Fatalf("writeFile: after truncate have %q want %q", s, "new")
1732         }
1733 }
1734
1735 func TestStatDirWithTrailingSlash(t *testing.T) {
1736         // Create new temporary directory and arrange to clean it up.
1737         path, err := ioutil.TempDir("", "/_TestStatDirWithSlash_")
1738         if err != nil {
1739                 t.Fatalf("TempDir: %s", err)
1740         }
1741         defer RemoveAll(path)
1742
1743         // Stat of path should succeed.
1744         _, err = Stat(path)
1745         if err != nil {
1746                 t.Fatalf("stat %s failed: %s", path, err)
1747         }
1748
1749         // Stat of path+"/" should succeed too.
1750         path += "/"
1751         _, err = Stat(path)
1752         if err != nil {
1753                 t.Fatalf("stat %s failed: %s", path, err)
1754         }
1755 }
1756
1757 func TestNilProcessStateString(t *testing.T) {
1758         var ps *ProcessState
1759         s := ps.String()
1760         if s != "<nil>" {
1761                 t.Errorf("(*ProcessState)(nil).String() = %q, want %q", s, "<nil>")
1762         }
1763 }
1764
1765 func TestSameFile(t *testing.T) {
1766         defer chtmpdir(t)()
1767         fa, err := Create("a")
1768         if err != nil {
1769                 t.Fatalf("Create(a): %v", err)
1770         }
1771         defer Remove(fa.Name())
1772         fa.Close()
1773         fb, err := Create("b")
1774         if err != nil {
1775                 t.Fatalf("Create(b): %v", err)
1776         }
1777         defer Remove(fb.Name())
1778         fb.Close()
1779
1780         ia1, err := Stat("a")
1781         if err != nil {
1782                 t.Fatalf("Stat(a): %v", err)
1783         }
1784         ia2, err := Stat("a")
1785         if err != nil {
1786                 t.Fatalf("Stat(a): %v", err)
1787         }
1788         if !SameFile(ia1, ia2) {
1789                 t.Errorf("files should be same")
1790         }
1791
1792         ib, err := Stat("b")
1793         if err != nil {
1794                 t.Fatalf("Stat(b): %v", err)
1795         }
1796         if SameFile(ia1, ib) {
1797                 t.Errorf("files should be different")
1798         }
1799 }
1800
1801 func testDevNullFileInfo(t *testing.T, statname, devNullName string, fi FileInfo, ignoreCase bool) {
1802         pre := fmt.Sprintf("%s(%q): ", statname, devNullName)
1803         name := filepath.Base(devNullName)
1804         if ignoreCase {
1805                 if strings.ToUpper(fi.Name()) != strings.ToUpper(name) {
1806                         t.Errorf(pre+"wrong file name have %v want %v", fi.Name(), name)
1807                 }
1808         } else {
1809                 if fi.Name() != name {
1810                         t.Errorf(pre+"wrong file name have %v want %v", fi.Name(), name)
1811                 }
1812         }
1813         if fi.Size() != 0 {
1814                 t.Errorf(pre+"wrong file size have %d want 0", fi.Size())
1815         }
1816         if fi.Mode()&ModeDevice == 0 {
1817                 t.Errorf(pre+"wrong file mode %q: ModeDevice is not set", fi.Mode())
1818         }
1819         if fi.Mode()&ModeCharDevice == 0 {
1820                 t.Errorf(pre+"wrong file mode %q: ModeCharDevice is not set", fi.Mode())
1821         }
1822         if fi.Mode().IsRegular() {
1823                 t.Errorf(pre+"wrong file mode %q: IsRegular returns true", fi.Mode())
1824         }
1825 }
1826
1827 func testDevNullFile(t *testing.T, devNullName string, ignoreCase bool) {
1828         f, err := Open(devNullName)
1829         if err != nil {
1830                 t.Fatalf("Open(%s): %v", devNullName, err)
1831         }
1832         defer f.Close()
1833
1834         fi, err := f.Stat()
1835         if err != nil {
1836                 t.Fatalf("Stat(%s): %v", devNullName, err)
1837         }
1838         testDevNullFileInfo(t, "f.Stat", devNullName, fi, ignoreCase)
1839
1840         fi, err = Stat(devNullName)
1841         if err != nil {
1842                 t.Fatalf("Stat(%s): %v", devNullName, err)
1843         }
1844         testDevNullFileInfo(t, "Stat", devNullName, fi, ignoreCase)
1845 }
1846
1847 func TestDevNullFile(t *testing.T) {
1848         testDevNullFile(t, DevNull, false)
1849 }
1850
1851 var testLargeWrite = flag.Bool("large_write", false, "run TestLargeWriteToConsole test that floods console with output")
1852
1853 func TestLargeWriteToConsole(t *testing.T) {
1854         if !*testLargeWrite {
1855                 t.Skip("skipping console-flooding test; enable with -large_write")
1856         }
1857         b := make([]byte, 32000)
1858         for i := range b {
1859                 b[i] = '.'
1860         }
1861         b[len(b)-1] = '\n'
1862         n, err := Stdout.Write(b)
1863         if err != nil {
1864                 t.Fatalf("Write to os.Stdout failed: %v", err)
1865         }
1866         if n != len(b) {
1867                 t.Errorf("Write to os.Stdout should return %d; got %d", len(b), n)
1868         }
1869         n, err = Stderr.Write(b)
1870         if err != nil {
1871                 t.Fatalf("Write to os.Stderr failed: %v", err)
1872         }
1873         if n != len(b) {
1874                 t.Errorf("Write to os.Stderr should return %d; got %d", len(b), n)
1875         }
1876 }
1877
1878 func TestStatDirModeExec(t *testing.T) {
1879         const mode = 0111
1880
1881         path, err := ioutil.TempDir("", "go-build")
1882         if err != nil {
1883                 t.Fatalf("Failed to create temp directory: %v", err)
1884         }
1885         defer RemoveAll(path)
1886
1887         if err := Chmod(path, 0777); err != nil {
1888                 t.Fatalf("Chmod %q 0777: %v", path, err)
1889         }
1890
1891         dir, err := Stat(path)
1892         if err != nil {
1893                 t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
1894         }
1895         if dir.Mode()&mode != mode {
1896                 t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode()&mode, mode)
1897         }
1898 }
1899
1900 func TestStatStdin(t *testing.T) {
1901         switch runtime.GOOS {
1902         case "android", "plan9":
1903                 t.Skipf("%s doesn't have /bin/sh", runtime.GOOS)
1904         }
1905
1906         testenv.MustHaveExec(t)
1907
1908         if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
1909                 st, err := Stdin.Stat()
1910                 if err != nil {
1911                         t.Fatalf("Stat failed: %v", err)
1912                 }
1913                 fmt.Println(st.Mode() & ModeNamedPipe)
1914                 Exit(0)
1915         }
1916
1917         fi, err := Stdin.Stat()
1918         if err != nil {
1919                 t.Fatal(err)
1920         }
1921         switch mode := fi.Mode(); {
1922         case mode&ModeCharDevice != 0 && mode&ModeDevice != 0:
1923         case mode&ModeNamedPipe != 0:
1924         default:
1925                 t.Fatalf("unexpected Stdin mode (%v), want ModeCharDevice or ModeNamedPipe", mode)
1926         }
1927
1928         var cmd *osexec.Cmd
1929         if runtime.GOOS == "windows" {
1930                 cmd = osexec.Command("cmd", "/c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
1931         } else {
1932                 cmd = osexec.Command("/bin/sh", "-c", "echo output | "+Args[0]+" -test.run=TestStatStdin")
1933         }
1934         cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
1935
1936         output, err := cmd.CombinedOutput()
1937         if err != nil {
1938                 t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
1939         }
1940
1941         // result will be like "prw-rw-rw"
1942         if len(output) < 1 || output[0] != 'p' {
1943                 t.Fatalf("Child process reports stdin is not pipe '%v'", string(output))
1944         }
1945 }
1946
1947 func TestStatRelativeSymlink(t *testing.T) {
1948         testenv.MustHaveSymlink(t)
1949
1950         tmpdir, err := ioutil.TempDir("", "TestStatRelativeSymlink")
1951         if err != nil {
1952                 t.Fatal(err)
1953         }
1954         defer RemoveAll(tmpdir)
1955
1956         target := filepath.Join(tmpdir, "target")
1957         f, err := Create(target)
1958         if err != nil {
1959                 t.Fatal(err)
1960         }
1961         defer f.Close()
1962
1963         st, err := f.Stat()
1964         if err != nil {
1965                 t.Fatal(err)
1966         }
1967
1968         link := filepath.Join(tmpdir, "link")
1969         err = Symlink(filepath.Base(target), link)
1970         if err != nil {
1971                 t.Fatal(err)
1972         }
1973
1974         st1, err := Stat(link)
1975         if err != nil {
1976                 t.Fatal(err)
1977         }
1978
1979         if !SameFile(st, st1) {
1980                 t.Error("Stat doesn't follow relative symlink")
1981         }
1982
1983         if runtime.GOOS == "windows" {
1984                 Remove(link)
1985                 err = Symlink(target[len(filepath.VolumeName(target)):], link)
1986                 if err != nil {
1987                         t.Fatal(err)
1988                 }
1989
1990                 st1, err := Stat(link)
1991                 if err != nil {
1992                         t.Fatal(err)
1993                 }
1994
1995                 if !SameFile(st, st1) {
1996                         t.Error("Stat doesn't follow relative symlink")
1997                 }
1998         }
1999 }
2000
2001 func TestReadAtEOF(t *testing.T) {
2002         f := newFile("TestReadAtEOF", t)
2003         defer Remove(f.Name())
2004         defer f.Close()
2005
2006         _, err := f.ReadAt(make([]byte, 10), 0)
2007         switch err {
2008         case io.EOF:
2009                 // all good
2010         case nil:
2011                 t.Fatalf("ReadAt succeeded")
2012         default:
2013                 t.Fatalf("ReadAt failed: %s", err)
2014         }
2015 }
2016
2017 func TestLongPath(t *testing.T) {
2018         tmpdir := newDir("TestLongPath", t)
2019         defer func(d string) {
2020                 if err := RemoveAll(d); err != nil {
2021                         t.Fatalf("RemoveAll failed: %v", err)
2022                 }
2023         }(tmpdir)
2024
2025         // Test the boundary of 247 and fewer bytes (normal) and 248 and more bytes (adjusted).
2026         sizes := []int{247, 248, 249, 400}
2027         for len(tmpdir) < 400 {
2028                 tmpdir += "/dir3456789"
2029         }
2030         for _, sz := range sizes {
2031                 t.Run(fmt.Sprintf("length=%d", sz), func(t *testing.T) {
2032                         sizedTempDir := tmpdir[:sz-1] + "x" // Ensure it does not end with a slash.
2033
2034                         // The various sized runs are for this call to trigger the boundary
2035                         // condition.
2036                         if err := MkdirAll(sizedTempDir, 0755); err != nil {
2037                                 t.Fatalf("MkdirAll failed: %v", err)
2038                         }
2039                         data := []byte("hello world\n")
2040                         if err := ioutil.WriteFile(sizedTempDir+"/foo.txt", data, 0644); err != nil {
2041                                 t.Fatalf("ioutil.WriteFile() failed: %v", err)
2042                         }
2043                         if err := Rename(sizedTempDir+"/foo.txt", sizedTempDir+"/bar.txt"); err != nil {
2044                                 t.Fatalf("Rename failed: %v", err)
2045                         }
2046                         mtime := time.Now().Truncate(time.Minute)
2047                         if err := Chtimes(sizedTempDir+"/bar.txt", mtime, mtime); err != nil {
2048                                 t.Fatalf("Chtimes failed: %v", err)
2049                         }
2050                         names := []string{"bar.txt"}
2051                         if testenv.HasSymlink() {
2052                                 if err := Symlink(sizedTempDir+"/bar.txt", sizedTempDir+"/symlink.txt"); err != nil {
2053                                         t.Fatalf("Symlink failed: %v", err)
2054                                 }
2055                                 names = append(names, "symlink.txt")
2056                         }
2057                         if testenv.HasLink() {
2058                                 if err := Link(sizedTempDir+"/bar.txt", sizedTempDir+"/link.txt"); err != nil {
2059                                         t.Fatalf("Link failed: %v", err)
2060                                 }
2061                                 names = append(names, "link.txt")
2062                         }
2063                         for _, wantSize := range []int64{int64(len(data)), 0} {
2064                                 for _, name := range names {
2065                                         path := sizedTempDir + "/" + name
2066                                         dir, err := Stat(path)
2067                                         if err != nil {
2068                                                 t.Fatalf("Stat(%q) failed: %v", path, err)
2069                                         }
2070                                         filesize := size(path, t)
2071                                         if dir.Size() != filesize || filesize != wantSize {
2072                                                 t.Errorf("Size(%q) is %d, len(ReadFile()) is %d, want %d", path, dir.Size(), filesize, wantSize)
2073                                         }
2074                                         err = Chmod(path, dir.Mode())
2075                                         if err != nil {
2076                                                 t.Fatalf("Chmod(%q) failed: %v", path, err)
2077                                         }
2078                                 }
2079                                 if err := Truncate(sizedTempDir+"/bar.txt", 0); err != nil {
2080                                         t.Fatalf("Truncate failed: %v", err)
2081                                 }
2082                         }
2083                 })
2084         }
2085 }
2086
2087 func testKillProcess(t *testing.T, processKiller func(p *Process)) {
2088         testenv.MustHaveExec(t)
2089
2090         // Re-exec the test binary itself to emulate "sleep 1".
2091         cmd := osexec.Command(Args[0], "-test.run", "TestSleep")
2092         err := cmd.Start()
2093         if err != nil {
2094                 t.Fatalf("Failed to start test process: %v", err)
2095         }
2096         go func() {
2097                 time.Sleep(100 * time.Millisecond)
2098                 processKiller(cmd.Process)
2099         }()
2100         err = cmd.Wait()
2101         if err == nil {
2102                 t.Errorf("Test process succeeded, but expected to fail")
2103         }
2104 }
2105
2106 // TestSleep emulates "sleep 1". It is a helper for testKillProcess, so we
2107 // don't have to rely on an external "sleep" command being available.
2108 func TestSleep(t *testing.T) {
2109         if testing.Short() {
2110                 t.Skip("Skipping in short mode")
2111         }
2112         time.Sleep(time.Second)
2113 }
2114
2115 func TestKillStartProcess(t *testing.T) {
2116         testKillProcess(t, func(p *Process) {
2117                 err := p.Kill()
2118                 if err != nil {
2119                         t.Fatalf("Failed to kill test process: %v", err)
2120                 }
2121         })
2122 }
2123
2124 func TestGetppid(t *testing.T) {
2125         if runtime.GOOS == "plan9" {
2126                 // TODO: golang.org/issue/8206
2127                 t.Skipf("skipping test on plan9; see issue 8206")
2128         }
2129
2130         testenv.MustHaveExec(t)
2131
2132         if Getenv("GO_WANT_HELPER_PROCESS") == "1" {
2133                 fmt.Print(Getppid())
2134                 Exit(0)
2135         }
2136
2137         cmd := osexec.Command(Args[0], "-test.run=TestGetppid")
2138         cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1")
2139
2140         // verify that Getppid() from the forked process reports our process id
2141         output, err := cmd.CombinedOutput()
2142         if err != nil {
2143                 t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
2144         }
2145
2146         childPpid := string(output)
2147         ourPid := fmt.Sprintf("%d", Getpid())
2148         if childPpid != ourPid {
2149                 t.Fatalf("Child process reports parent process id '%v', expected '%v'", childPpid, ourPid)
2150         }
2151 }
2152
2153 func TestKillFindProcess(t *testing.T) {
2154         testKillProcess(t, func(p *Process) {
2155                 p2, err := FindProcess(p.Pid)
2156                 if err != nil {
2157                         t.Fatalf("Failed to find test process: %v", err)
2158                 }
2159                 err = p2.Kill()
2160                 if err != nil {
2161                         t.Fatalf("Failed to kill test process: %v", err)
2162                 }
2163         })
2164 }
2165
2166 var nilFileMethodTests = []struct {
2167         name string
2168         f    func(*File) error
2169 }{
2170         {"Chdir", func(f *File) error { return f.Chdir() }},
2171         {"Close", func(f *File) error { return f.Close() }},
2172         {"Chmod", func(f *File) error { return f.Chmod(0) }},
2173         {"Chown", func(f *File) error { return f.Chown(0, 0) }},
2174         {"Read", func(f *File) error { _, err := f.Read(make([]byte, 0)); return err }},
2175         {"ReadAt", func(f *File) error { _, err := f.ReadAt(make([]byte, 0), 0); return err }},
2176         {"Readdir", func(f *File) error { _, err := f.Readdir(1); return err }},
2177         {"Readdirnames", func(f *File) error { _, err := f.Readdirnames(1); return err }},
2178         {"Seek", func(f *File) error { _, err := f.Seek(0, io.SeekStart); return err }},
2179         {"Stat", func(f *File) error { _, err := f.Stat(); return err }},
2180         {"Sync", func(f *File) error { return f.Sync() }},
2181         {"Truncate", func(f *File) error { return f.Truncate(0) }},
2182         {"Write", func(f *File) error { _, err := f.Write(make([]byte, 0)); return err }},
2183         {"WriteAt", func(f *File) error { _, err := f.WriteAt(make([]byte, 0), 0); return err }},
2184         {"WriteString", func(f *File) error { _, err := f.WriteString(""); return err }},
2185 }
2186
2187 // Test that all File methods give ErrInvalid if the receiver is nil.
2188 func TestNilFileMethods(t *testing.T) {
2189         for _, tt := range nilFileMethodTests {
2190                 var file *File
2191                 got := tt.f(file)
2192                 if got != ErrInvalid {
2193                         t.Errorf("%v should fail when f is nil; got %v", tt.name, got)
2194                 }
2195         }
2196 }
2197
2198 func mkdirTree(t *testing.T, root string, level, max int) {
2199         if level >= max {
2200                 return
2201         }
2202         level++
2203         for i := 'a'; i < 'c'; i++ {
2204                 dir := filepath.Join(root, string(i))
2205                 if err := Mkdir(dir, 0700); err != nil {
2206                         t.Fatal(err)
2207                 }
2208                 mkdirTree(t, dir, level, max)
2209         }
2210 }
2211
2212 // Test that simultaneous RemoveAll do not report an error.
2213 // As long as it gets removed, we should be happy.
2214 func TestRemoveAllRace(t *testing.T) {
2215         if runtime.GOOS == "windows" {
2216                 // Windows has very strict rules about things like
2217                 // removing directories while someone else has
2218                 // them open. The racing doesn't work out nicely
2219                 // like it does on Unix.
2220                 t.Skip("skipping on windows")
2221         }
2222
2223         n := runtime.GOMAXPROCS(16)
2224         defer runtime.GOMAXPROCS(n)
2225         root, err := ioutil.TempDir("", "issue")
2226         if err != nil {
2227                 t.Fatal(err)
2228         }
2229         mkdirTree(t, root, 1, 6)
2230         hold := make(chan struct{})
2231         var wg sync.WaitGroup
2232         for i := 0; i < 4; i++ {
2233                 wg.Add(1)
2234                 go func() {
2235                         defer wg.Done()
2236                         <-hold
2237                         err := RemoveAll(root)
2238                         if err != nil {
2239                                 t.Errorf("unexpected error: %T, %q", err, err)
2240                         }
2241                 }()
2242         }
2243         close(hold) // let workers race to remove root
2244         wg.Wait()
2245 }
2246
2247 // Test that reading from a pipe doesn't use up a thread.
2248 func TestPipeThreads(t *testing.T) {
2249         switch runtime.GOOS {
2250         case "freebsd":
2251                 t.Skip("skipping on FreeBSD; issue 19093")
2252         case "solaris":
2253                 t.Skip("skipping on Solaris; issue 19111")
2254         case "windows":
2255                 t.Skip("skipping on Windows; issue 19098")
2256         case "plan9":
2257                 t.Skip("skipping on Plan 9; does not support runtime poller")
2258         case "js":
2259                 t.Skip("skipping on js; no support for os.Pipe")
2260         }
2261
2262         threads := 100
2263
2264         // OpenBSD has a low default for max number of files.
2265         if runtime.GOOS == "openbsd" {
2266                 threads = 50
2267         }
2268
2269         r := make([]*File, threads)
2270         w := make([]*File, threads)
2271         for i := 0; i < threads; i++ {
2272                 rp, wp, err := Pipe()
2273                 if err != nil {
2274                         for j := 0; j < i; j++ {
2275                                 r[j].Close()
2276                                 w[j].Close()
2277                         }
2278                         t.Fatal(err)
2279                 }
2280                 r[i] = rp
2281                 w[i] = wp
2282         }
2283
2284         defer debug.SetMaxThreads(debug.SetMaxThreads(threads / 2))
2285
2286         creading := make(chan bool, threads)
2287         cdone := make(chan bool, threads)
2288         for i := 0; i < threads; i++ {
2289                 go func(i int) {
2290                         var b [1]byte
2291                         creading <- true
2292                         if _, err := r[i].Read(b[:]); err != nil {
2293                                 t.Error(err)
2294                         }
2295                         if err := r[i].Close(); err != nil {
2296                                 t.Error(err)
2297                         }
2298                         cdone <- true
2299                 }(i)
2300         }
2301
2302         for i := 0; i < threads; i++ {
2303                 <-creading
2304         }
2305
2306         // If we are still alive, it means that the 100 goroutines did
2307         // not require 100 threads.
2308
2309         for i := 0; i < threads; i++ {
2310                 if _, err := w[i].Write([]byte{0}); err != nil {
2311                         t.Error(err)
2312                 }
2313                 if err := w[i].Close(); err != nil {
2314                         t.Error(err)
2315                 }
2316                 <-cdone
2317         }
2318 }
2319
2320 func TestDoubleCloseError(t *testing.T) {
2321         path := sfdir + "/" + sfname
2322         file, err := Open(path)
2323         if err != nil {
2324                 t.Fatal(err)
2325         }
2326         if err := file.Close(); err != nil {
2327                 t.Fatalf("unexpected error from Close: %v", err)
2328         }
2329         if err := file.Close(); err == nil {
2330                 t.Error("second Close did not fail")
2331         } else if pe, ok := err.(*PathError); !ok {
2332                 t.Errorf("second Close returned unexpected error type %T; expected os.PathError", pe)
2333         } else if pe.Err != ErrClosed {
2334                 t.Errorf("second Close returned %q, wanted %q", err, ErrClosed)
2335         } else {
2336                 t.Logf("second close returned expected error %q", err)
2337         }
2338 }