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