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