github.com/bgentry/go@v0.0.0-20150121062915-6cf5a733d54d/src/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 "io" 13 "io/ioutil" 14 . "os" 15 osexec "os/exec" 16 "path/filepath" 17 "reflect" 18 "runtime" 19 "sort" 20 "strings" 21 "sync" 22 "syscall" 23 "testing" 24 "text/template" 25 "time" 26 ) 27 28 var supportsSymlinks = true 29 30 var dot = []string{ 31 "dir_unix.go", 32 "env.go", 33 "error.go", 34 "file.go", 35 "os_test.go", 36 "types.go", 37 "stat_darwin.go", 38 "stat_linux.go", 39 } 40 41 type sysDir struct { 42 name string 43 files []string 44 } 45 46 var sysdir = func() (sd *sysDir) { 47 switch runtime.GOOS { 48 case "android": 49 sd = &sysDir{ 50 "/system/etc", 51 []string{ 52 "audio_policy.conf", 53 "system_fonts.xml", 54 }, 55 } 56 case "windows": 57 sd = &sysDir{ 58 Getenv("SystemRoot") + "\\system32\\drivers\\etc", 59 []string{ 60 "networks", 61 "protocol", 62 "services", 63 }, 64 } 65 case "plan9": 66 sd = &sysDir{ 67 "/lib/ndb", 68 []string{ 69 "common", 70 "local", 71 }, 72 } 73 default: 74 sd = &sysDir{ 75 "/etc", 76 []string{ 77 "group", 78 "hosts", 79 "passwd", 80 }, 81 } 82 } 83 return 84 }() 85 86 func size(name string, t *testing.T) int64 { 87 file, err := Open(name) 88 if err != nil { 89 t.Fatal("open failed:", err) 90 } 91 defer file.Close() 92 var buf [100]byte 93 len := 0 94 for { 95 n, e := file.Read(buf[0:]) 96 len += n 97 if e == io.EOF { 98 break 99 } 100 if e != nil { 101 t.Fatal("read failed:", err) 102 } 103 } 104 return int64(len) 105 } 106 107 func equal(name1, name2 string) (r bool) { 108 switch runtime.GOOS { 109 case "windows": 110 r = strings.ToLower(name1) == strings.ToLower(name2) 111 default: 112 r = name1 == name2 113 } 114 return 115 } 116 117 func newFile(testName string, t *testing.T) (f *File) { 118 // Use a local file system, not NFS. 119 // On Unix, override $TMPDIR in case the user 120 // has it set to an NFS-mounted directory. 121 dir := "" 122 if runtime.GOOS != "android" && runtime.GOOS != "windows" { 123 dir = "/tmp" 124 } 125 f, err := ioutil.TempFile(dir, "_Go_"+testName) 126 if err != nil { 127 t.Fatalf("TempFile %s: %s", testName, err) 128 } 129 return 130 } 131 132 func newDir(testName string, t *testing.T) (name string) { 133 // Use a local file system, not NFS. 134 // On Unix, override $TMPDIR in case the user 135 // has it set to an NFS-mounted directory. 136 dir := "" 137 if runtime.GOOS != "android" && runtime.GOOS != "windows" { 138 dir = "/tmp" 139 } 140 name, err := ioutil.TempDir(dir, "_Go_"+testName) 141 if err != nil { 142 t.Fatalf("TempDir %s: %s", testName, err) 143 } 144 return 145 } 146 147 var sfdir = sysdir.name 148 var sfname = sysdir.files[0] 149 150 func TestStat(t *testing.T) { 151 path := sfdir + "/" + sfname 152 dir, err := Stat(path) 153 if err != nil { 154 t.Fatal("stat failed:", err) 155 } 156 if !equal(sfname, dir.Name()) { 157 t.Error("name should be ", sfname, "; is", dir.Name()) 158 } 159 filesize := size(path, t) 160 if dir.Size() != filesize { 161 t.Error("size should be", filesize, "; is", dir.Size()) 162 } 163 } 164 165 func TestFstat(t *testing.T) { 166 path := sfdir + "/" + sfname 167 file, err1 := Open(path) 168 if err1 != nil { 169 t.Fatal("open failed:", err1) 170 } 171 defer file.Close() 172 dir, err2 := file.Stat() 173 if err2 != nil { 174 t.Fatal("fstat failed:", err2) 175 } 176 if !equal(sfname, dir.Name()) { 177 t.Error("name should be ", sfname, "; is", dir.Name()) 178 } 179 filesize := size(path, t) 180 if dir.Size() != filesize { 181 t.Error("size should be", filesize, "; is", dir.Size()) 182 } 183 } 184 185 func TestLstat(t *testing.T) { 186 path := sfdir + "/" + sfname 187 dir, err := Lstat(path) 188 if err != nil { 189 t.Fatal("lstat failed:", err) 190 } 191 if !equal(sfname, dir.Name()) { 192 t.Error("name should be ", sfname, "; is", dir.Name()) 193 } 194 filesize := size(path, t) 195 if dir.Size() != filesize { 196 t.Error("size should be", filesize, "; is", dir.Size()) 197 } 198 } 199 200 // Read with length 0 should not return EOF. 201 func TestRead0(t *testing.T) { 202 path := sfdir + "/" + sfname 203 f, err := Open(path) 204 if err != nil { 205 t.Fatal("open failed:", err) 206 } 207 defer f.Close() 208 209 b := make([]byte, 0) 210 n, err := f.Read(b) 211 if n != 0 || err != nil { 212 t.Errorf("Read(0) = %d, %v, want 0, nil", n, err) 213 } 214 b = make([]byte, 100) 215 n, err = f.Read(b) 216 if n <= 0 || err != nil { 217 t.Errorf("Read(100) = %d, %v, want >0, nil", n, err) 218 } 219 } 220 221 func testReaddirnames(dir string, contents []string, t *testing.T) { 222 file, err := Open(dir) 223 if err != nil { 224 t.Fatalf("open %q failed: %v", dir, err) 225 } 226 defer file.Close() 227 s, err2 := file.Readdirnames(-1) 228 if err2 != nil { 229 t.Fatalf("readdirnames %q failed: %v", dir, err2) 230 } 231 for _, m := range contents { 232 found := false 233 for _, n := range s { 234 if n == "." || n == ".." { 235 t.Errorf("got %s in directory", n) 236 } 237 if equal(m, n) { 238 if found { 239 t.Error("present twice:", m) 240 } 241 found = true 242 } 243 } 244 if !found { 245 t.Error("could not find", m) 246 } 247 } 248 } 249 250 func testReaddir(dir string, contents []string, t *testing.T) { 251 file, err := Open(dir) 252 if err != nil { 253 t.Fatalf("open %q failed: %v", dir, err) 254 } 255 defer file.Close() 256 s, err2 := file.Readdir(-1) 257 if err2 != nil { 258 t.Fatalf("readdir %q failed: %v", dir, err2) 259 } 260 for _, m := range contents { 261 found := false 262 for _, n := range s { 263 if equal(m, n.Name()) { 264 if found { 265 t.Error("present twice:", m) 266 } 267 found = true 268 } 269 } 270 if !found { 271 t.Error("could not find", m) 272 } 273 } 274 } 275 276 func TestReaddirnames(t *testing.T) { 277 testReaddirnames(".", dot, t) 278 testReaddirnames(sysdir.name, sysdir.files, t) 279 } 280 281 func TestReaddir(t *testing.T) { 282 testReaddir(".", dot, t) 283 testReaddir(sysdir.name, sysdir.files, t) 284 } 285 286 // Read the directory one entry at a time. 287 func smallReaddirnames(file *File, length int, t *testing.T) []string { 288 names := make([]string, length) 289 count := 0 290 for { 291 d, err := file.Readdirnames(1) 292 if err == io.EOF { 293 break 294 } 295 if err != nil { 296 t.Fatalf("readdirnames %q failed: %v", file.Name(), err) 297 } 298 if len(d) == 0 { 299 t.Fatalf("readdirnames %q returned empty slice and no error", file.Name()) 300 } 301 names[count] = d[0] 302 count++ 303 } 304 return names[0:count] 305 } 306 307 // Check that reading a directory one entry at a time gives the same result 308 // as reading it all at once. 309 func TestReaddirnamesOneAtATime(t *testing.T) { 310 // big directory that doesn't change often. 311 dir := "/usr/bin" 312 switch runtime.GOOS { 313 case "android": 314 dir = "/system/bin" 315 case "plan9": 316 dir = "/bin" 317 case "windows": 318 dir = Getenv("SystemRoot") + "\\system32" 319 } 320 file, err := Open(dir) 321 if err != nil { 322 t.Fatalf("open %q failed: %v", dir, err) 323 } 324 defer file.Close() 325 all, err1 := file.Readdirnames(-1) 326 if err1 != nil { 327 t.Fatalf("readdirnames %q failed: %v", dir, err1) 328 } 329 file1, err2 := Open(dir) 330 if err2 != nil { 331 t.Fatalf("open %q failed: %v", dir, err2) 332 } 333 defer file1.Close() 334 small := smallReaddirnames(file1, len(all)+100, t) // +100 in case we screw up 335 if len(small) < len(all) { 336 t.Fatalf("len(small) is %d, less than %d", len(small), len(all)) 337 } 338 for i, n := range all { 339 if small[i] != n { 340 t.Errorf("small read %q mismatch: %v", small[i], n) 341 } 342 } 343 } 344 345 func TestReaddirNValues(t *testing.T) { 346 if testing.Short() { 347 t.Skip("test.short; skipping") 348 } 349 dir, err := ioutil.TempDir("", "") 350 if err != nil { 351 t.Fatalf("TempDir: %v", err) 352 } 353 defer RemoveAll(dir) 354 for i := 1; i <= 105; i++ { 355 f, err := Create(filepath.Join(dir, fmt.Sprintf("%d", i))) 356 if err != nil { 357 t.Fatalf("Create: %v", err) 358 } 359 f.Write([]byte(strings.Repeat("X", i))) 360 f.Close() 361 } 362 363 var d *File 364 openDir := func() { 365 var err error 366 d, err = Open(dir) 367 if err != nil { 368 t.Fatalf("Open directory: %v", err) 369 } 370 } 371 372 readDirExpect := func(n, want int, wantErr error) { 373 fi, err := d.Readdir(n) 374 if err != wantErr { 375 t.Fatalf("Readdir of %d got error %v, want %v", n, err, wantErr) 376 } 377 if g, e := len(fi), want; g != e { 378 t.Errorf("Readdir of %d got %d files, want %d", n, g, e) 379 } 380 } 381 382 readDirNamesExpect := func(n, want int, wantErr error) { 383 fi, err := d.Readdirnames(n) 384 if err != wantErr { 385 t.Fatalf("Readdirnames of %d got error %v, want %v", n, err, wantErr) 386 } 387 if g, e := len(fi), want; g != e { 388 t.Errorf("Readdirnames of %d got %d files, want %d", n, g, e) 389 } 390 } 391 392 for _, fn := range []func(int, int, error){readDirExpect, readDirNamesExpect} { 393 // Test the slurp case 394 openDir() 395 fn(0, 105, nil) 396 fn(0, 0, nil) 397 d.Close() 398 399 // Slurp with -1 instead 400 openDir() 401 fn(-1, 105, nil) 402 fn(-2, 0, nil) 403 fn(0, 0, nil) 404 d.Close() 405 406 // Test the bounded case 407 openDir() 408 fn(1, 1, nil) 409 fn(2, 2, nil) 410 fn(105, 102, nil) // and tests buffer >100 case 411 fn(3, 0, io.EOF) 412 d.Close() 413 } 414 } 415 416 func touch(t *testing.T, name string) { 417 f, err := Create(name) 418 if err != nil { 419 t.Fatal(err) 420 } 421 if err := f.Close(); err != nil { 422 t.Fatal(err) 423 } 424 } 425 426 func TestReaddirStatFailures(t *testing.T) { 427 switch runtime.GOOS { 428 case "windows", "plan9": 429 // Windows and Plan 9 already do this correctly, 430 // but are structured with different syscalls such 431 // that they don't use Lstat, so the hook below for 432 // testing it wouldn't work. 433 t.Skipf("skipping test on %v", runtime.GOOS) 434 } 435 dir, err := ioutil.TempDir("", "") 436 if err != nil { 437 t.Fatalf("TempDir: %v", err) 438 } 439 defer RemoveAll(dir) 440 touch(t, filepath.Join(dir, "good1")) 441 touch(t, filepath.Join(dir, "x")) // will disappear or have an error 442 touch(t, filepath.Join(dir, "good2")) 443 defer func() { 444 *LstatP = Lstat 445 }() 446 var xerr error // error to return for x 447 *LstatP = func(path string) (FileInfo, error) { 448 if xerr != nil && strings.HasSuffix(path, "x") { 449 return nil, xerr 450 } 451 return Lstat(path) 452 } 453 readDir := func() ([]FileInfo, error) { 454 d, err := Open(dir) 455 if err != nil { 456 t.Fatal(err) 457 } 458 defer d.Close() 459 return d.Readdir(-1) 460 } 461 mustReadDir := func(testName string) []FileInfo { 462 fis, err := readDir() 463 if err != nil { 464 t.Fatalf("%s: Readdir: %v", testName, err) 465 } 466 return fis 467 } 468 names := func(fis []FileInfo) []string { 469 s := make([]string, len(fis)) 470 for i, fi := range fis { 471 s[i] = fi.Name() 472 } 473 sort.Strings(s) 474 return s 475 } 476 477 if got, want := names(mustReadDir("inital readdir")), 478 []string{"good1", "good2", "x"}; !reflect.DeepEqual(got, want) { 479 t.Errorf("initial readdir got %q; want %q", got, want) 480 } 481 482 xerr = ErrNotExist 483 if got, want := names(mustReadDir("with x disappearing")), 484 []string{"good1", "good2"}; !reflect.DeepEqual(got, want) { 485 t.Errorf("with x disappearing, got %q; want %q", got, want) 486 } 487 488 xerr = errors.New("some real error") 489 if _, err := readDir(); err != xerr { 490 t.Errorf("with a non-ErrNotExist error, got error %v; want %v", err, xerr) 491 } 492 } 493 494 func TestHardLink(t *testing.T) { 495 // Hardlinks are not supported under windows or Plan 9. 496 if runtime.GOOS == "plan9" { 497 return 498 } 499 from, to := "hardlinktestfrom", "hardlinktestto" 500 Remove(from) // Just in case. 501 file, err := Create(to) 502 if err != nil { 503 t.Fatalf("open %q failed: %v", to, err) 504 } 505 defer Remove(to) 506 if err = file.Close(); err != nil { 507 t.Errorf("close %q failed: %v", to, err) 508 } 509 err = Link(to, from) 510 if err != nil { 511 t.Fatalf("link %q, %q failed: %v", to, from, err) 512 } 513 defer Remove(from) 514 tostat, err := Stat(to) 515 if err != nil { 516 t.Fatalf("stat %q failed: %v", to, err) 517 } 518 fromstat, err := Stat(from) 519 if err != nil { 520 t.Fatalf("stat %q failed: %v", from, err) 521 } 522 if !SameFile(tostat, fromstat) { 523 t.Errorf("link %q, %q did not create hard link", to, from) 524 } 525 } 526 527 func TestSymlink(t *testing.T) { 528 switch runtime.GOOS { 529 case "android", "nacl", "plan9": 530 t.Skipf("skipping on %s", runtime.GOOS) 531 case "windows": 532 if !supportsSymlinks { 533 t.Skipf("skipping on %s", runtime.GOOS) 534 } 535 } 536 from, to := "symlinktestfrom", "symlinktestto" 537 Remove(from) // Just in case. 538 file, err := Create(to) 539 if err != nil { 540 t.Fatalf("open %q failed: %v", to, err) 541 } 542 defer Remove(to) 543 if err = file.Close(); err != nil { 544 t.Errorf("close %q failed: %v", to, err) 545 } 546 err = Symlink(to, from) 547 if err != nil { 548 t.Fatalf("symlink %q, %q failed: %v", to, from, err) 549 } 550 defer Remove(from) 551 tostat, err := Lstat(to) 552 if err != nil { 553 t.Fatalf("stat %q failed: %v", to, err) 554 } 555 if tostat.Mode()&ModeSymlink != 0 { 556 t.Fatalf("stat %q claims to have found a symlink", to) 557 } 558 fromstat, err := Stat(from) 559 if err != nil { 560 t.Fatalf("stat %q failed: %v", from, err) 561 } 562 if !SameFile(tostat, fromstat) { 563 t.Errorf("symlink %q, %q did not create symlink", to, from) 564 } 565 fromstat, err = Lstat(from) 566 if err != nil { 567 t.Fatalf("lstat %q failed: %v", from, err) 568 } 569 if fromstat.Mode()&ModeSymlink == 0 { 570 t.Fatalf("symlink %q, %q did not create symlink", to, from) 571 } 572 fromstat, err = Stat(from) 573 if err != nil { 574 t.Fatalf("stat %q failed: %v", from, err) 575 } 576 if fromstat.Mode()&ModeSymlink != 0 { 577 t.Fatalf("stat %q did not follow symlink", from) 578 } 579 s, err := Readlink(from) 580 if err != nil { 581 t.Fatalf("readlink %q failed: %v", from, err) 582 } 583 if s != to { 584 t.Fatalf("after symlink %q != %q", s, to) 585 } 586 file, err = Open(from) 587 if err != nil { 588 t.Fatalf("open %q failed: %v", from, err) 589 } 590 file.Close() 591 } 592 593 func TestLongSymlink(t *testing.T) { 594 switch runtime.GOOS { 595 case "plan9", "nacl": 596 t.Skipf("skipping on %s", runtime.GOOS) 597 case "windows": 598 if !supportsSymlinks { 599 t.Skipf("skipping on %s", runtime.GOOS) 600 } 601 } 602 s := "0123456789abcdef" 603 // Long, but not too long: a common limit is 255. 604 s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s 605 from := "longsymlinktestfrom" 606 Remove(from) // Just in case. 607 err := Symlink(s, from) 608 if err != nil { 609 t.Fatalf("symlink %q, %q failed: %v", s, from, err) 610 } 611 defer Remove(from) 612 r, err := Readlink(from) 613 if err != nil { 614 t.Fatalf("readlink %q failed: %v", from, err) 615 } 616 if r != s { 617 t.Fatalf("after symlink %q != %q", r, s) 618 } 619 } 620 621 func TestRename(t *testing.T) { 622 from, to := "renamefrom", "renameto" 623 Remove(to) // Just in case. 624 file, err := Create(from) 625 if err != nil { 626 t.Fatalf("open %q failed: %v", to, err) 627 } 628 if err = file.Close(); err != nil { 629 t.Errorf("close %q failed: %v", to, err) 630 } 631 err = Rename(from, to) 632 if err != nil { 633 t.Fatalf("rename %q, %q failed: %v", to, from, err) 634 } 635 defer Remove(to) 636 _, err = Stat(to) 637 if err != nil { 638 t.Errorf("stat %q failed: %v", to, err) 639 } 640 } 641 642 func exec(t *testing.T, dir, cmd string, args []string, expect string) { 643 r, w, err := Pipe() 644 if err != nil { 645 t.Fatalf("Pipe: %v", err) 646 } 647 defer r.Close() 648 attr := &ProcAttr{Dir: dir, Files: []*File{nil, w, Stderr}} 649 p, err := StartProcess(cmd, args, attr) 650 if err != nil { 651 t.Fatalf("StartProcess: %v", err) 652 } 653 w.Close() 654 655 var b bytes.Buffer 656 io.Copy(&b, r) 657 output := b.String() 658 659 fi1, _ := Stat(strings.TrimSpace(output)) 660 fi2, _ := Stat(expect) 661 if !SameFile(fi1, fi2) { 662 t.Errorf("exec %q returned %q wanted %q", 663 strings.Join(append([]string{cmd}, args...), " "), output, expect) 664 } 665 p.Wait() 666 } 667 668 func TestStartProcess(t *testing.T) { 669 switch runtime.GOOS { 670 case "android", "nacl": 671 t.Skipf("skipping on %s", runtime.GOOS) 672 } 673 674 var dir, cmd string 675 var args []string 676 if runtime.GOOS == "windows" { 677 cmd = Getenv("COMSPEC") 678 dir = Getenv("SystemRoot") 679 args = []string{"/c", "cd"} 680 } else { 681 cmd = "/bin/pwd" 682 dir = "/" 683 args = []string{} 684 } 685 cmddir, cmdbase := filepath.Split(cmd) 686 args = append([]string{cmdbase}, args...) 687 // Test absolute executable path. 688 exec(t, dir, cmd, args, dir) 689 // Test relative executable path. 690 exec(t, cmddir, cmdbase, args, cmddir) 691 } 692 693 func checkMode(t *testing.T, path string, mode FileMode) { 694 dir, err := Stat(path) 695 if err != nil { 696 t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err) 697 } 698 if dir.Mode()&0777 != mode { 699 t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode(), mode) 700 } 701 } 702 703 func TestChmod(t *testing.T) { 704 // Chmod is not supported under windows. 705 if runtime.GOOS == "windows" { 706 return 707 } 708 f := newFile("TestChmod", t) 709 defer Remove(f.Name()) 710 defer f.Close() 711 712 if err := Chmod(f.Name(), 0456); err != nil { 713 t.Fatalf("chmod %s 0456: %s", f.Name(), err) 714 } 715 checkMode(t, f.Name(), 0456) 716 717 if err := f.Chmod(0123); err != nil { 718 t.Fatalf("chmod %s 0123: %s", f.Name(), err) 719 } 720 checkMode(t, f.Name(), 0123) 721 } 722 723 func checkSize(t *testing.T, f *File, size int64) { 724 dir, err := f.Stat() 725 if err != nil { 726 t.Fatalf("Stat %q (looking for size %d): %s", f.Name(), size, err) 727 } 728 if dir.Size() != size { 729 t.Errorf("Stat %q: size %d want %d", f.Name(), dir.Size(), size) 730 } 731 } 732 733 func TestFTruncate(t *testing.T) { 734 f := newFile("TestFTruncate", t) 735 defer Remove(f.Name()) 736 defer f.Close() 737 738 checkSize(t, f, 0) 739 f.Write([]byte("hello, world\n")) 740 checkSize(t, f, 13) 741 f.Truncate(10) 742 checkSize(t, f, 10) 743 f.Truncate(1024) 744 checkSize(t, f, 1024) 745 f.Truncate(0) 746 checkSize(t, f, 0) 747 _, err := f.Write([]byte("surprise!")) 748 if err == nil { 749 checkSize(t, f, 13+9) // wrote at offset past where hello, world was. 750 } 751 } 752 753 func TestTruncate(t *testing.T) { 754 f := newFile("TestTruncate", t) 755 defer Remove(f.Name()) 756 defer f.Close() 757 758 checkSize(t, f, 0) 759 f.Write([]byte("hello, world\n")) 760 checkSize(t, f, 13) 761 Truncate(f.Name(), 10) 762 checkSize(t, f, 10) 763 Truncate(f.Name(), 1024) 764 checkSize(t, f, 1024) 765 Truncate(f.Name(), 0) 766 checkSize(t, f, 0) 767 _, err := f.Write([]byte("surprise!")) 768 if err == nil { 769 checkSize(t, f, 13+9) // wrote at offset past where hello, world was. 770 } 771 } 772 773 // Use TempDir (via newFile) to make sure we're on a local file system, 774 // so that timings are not distorted by latency and caching. 775 // On NFS, timings can be off due to caching of meta-data on 776 // NFS servers (Issue 848). 777 func TestChtimes(t *testing.T) { 778 f := newFile("TestChtimes", t) 779 defer Remove(f.Name()) 780 781 f.Write([]byte("hello, world\n")) 782 f.Close() 783 784 testChtimes(t, f.Name()) 785 } 786 787 // Use TempDir (via newDir) to make sure we're on a local file system, 788 // so that timings are not distorted by latency and caching. 789 // On NFS, timings can be off due to caching of meta-data on 790 // NFS servers (Issue 848). 791 func TestChtimesDir(t *testing.T) { 792 name := newDir("TestChtimes", t) 793 defer RemoveAll(name) 794 795 testChtimes(t, name) 796 } 797 798 func testChtimes(t *testing.T, name string) { 799 st, err := Stat(name) 800 if err != nil { 801 t.Fatalf("Stat %s: %s", name, err) 802 } 803 preStat := st 804 805 // Move access and modification time back a second 806 at := Atime(preStat) 807 mt := preStat.ModTime() 808 err = Chtimes(name, at.Add(-time.Second), mt.Add(-time.Second)) 809 if err != nil { 810 t.Fatalf("Chtimes %s: %s", name, err) 811 } 812 813 st, err = Stat(name) 814 if err != nil { 815 t.Fatalf("second Stat %s: %s", name, err) 816 } 817 postStat := st 818 819 /* Plan 9, NaCl: 820 Mtime is the time of the last change of content. Similarly, atime is set whenever the 821 contents are accessed; also, it is set whenever mtime is set. 822 */ 823 pat := Atime(postStat) 824 pmt := postStat.ModTime() 825 if !pat.Before(at) && runtime.GOOS != "plan9" && runtime.GOOS != "nacl" { 826 t.Errorf("AccessTime didn't go backwards; was=%d, after=%d", at, pat) 827 } 828 829 if !pmt.Before(mt) { 830 t.Errorf("ModTime didn't go backwards; was=%d, after=%d", mt, pmt) 831 } 832 } 833 834 func TestChdirAndGetwd(t *testing.T) { 835 // TODO(brainman): file.Chdir() is not implemented on windows. 836 if runtime.GOOS == "windows" { 837 return 838 } 839 fd, err := Open(".") 840 if err != nil { 841 t.Fatalf("Open .: %s", err) 842 } 843 // These are chosen carefully not to be symlinks on a Mac 844 // (unlike, say, /var, /etc), except /tmp, which we handle below. 845 dirs := []string{"/", "/usr/bin", "/tmp"} 846 // /usr/bin does not usually exist on Plan 9 or Android. 847 switch runtime.GOOS { 848 case "android": 849 dirs = []string{"/", "/system/bin"} 850 case "plan9": 851 dirs = []string{"/", "/usr"} 852 } 853 oldwd := Getenv("PWD") 854 for mode := 0; mode < 2; mode++ { 855 for _, d := range dirs { 856 if mode == 0 { 857 err = Chdir(d) 858 } else { 859 fd1, err := Open(d) 860 if err != nil { 861 t.Errorf("Open %s: %s", d, err) 862 continue 863 } 864 err = fd1.Chdir() 865 fd1.Close() 866 } 867 if d == "/tmp" { 868 Setenv("PWD", "/tmp") 869 } 870 pwd, err1 := Getwd() 871 Setenv("PWD", oldwd) 872 err2 := fd.Chdir() 873 if err2 != nil { 874 // We changed the current directory and cannot go back. 875 // Don't let the tests continue; they'll scribble 876 // all over some other directory. 877 fmt.Fprintf(Stderr, "fchdir back to dot failed: %s\n", err2) 878 Exit(1) 879 } 880 if err != nil { 881 fd.Close() 882 t.Fatalf("Chdir %s: %s", d, err) 883 } 884 if err1 != nil { 885 fd.Close() 886 t.Fatalf("Getwd in %s: %s", d, err1) 887 } 888 if pwd != d { 889 fd.Close() 890 t.Fatalf("Getwd returned %q want %q", pwd, d) 891 } 892 } 893 } 894 fd.Close() 895 } 896 897 func TestSeek(t *testing.T) { 898 f := newFile("TestSeek", t) 899 defer Remove(f.Name()) 900 defer f.Close() 901 902 const data = "hello, world\n" 903 io.WriteString(f, data) 904 905 type test struct { 906 in int64 907 whence int 908 out int64 909 } 910 var tests = []test{ 911 {0, 1, int64(len(data))}, 912 {0, 0, 0}, 913 {5, 0, 5}, 914 {0, 2, int64(len(data))}, 915 {0, 0, 0}, 916 {-1, 2, int64(len(data)) - 1}, 917 {1 << 33, 0, 1 << 33}, 918 {1 << 33, 2, 1<<33 + int64(len(data))}, 919 } 920 for i, tt := range tests { 921 off, err := f.Seek(tt.in, tt.whence) 922 if off != tt.out || err != nil { 923 if e, ok := err.(*PathError); ok && e.Err == syscall.EINVAL && tt.out > 1<<32 { 924 // Reiserfs rejects the big seeks. 925 // http://code.google.com/p/go/issues/detail?id=91 926 break 927 } 928 t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out) 929 } 930 } 931 } 932 933 type openErrorTest struct { 934 path string 935 mode int 936 error error 937 } 938 939 var openErrorTests = []openErrorTest{ 940 { 941 sfdir + "/no-such-file", 942 O_RDONLY, 943 syscall.ENOENT, 944 }, 945 { 946 sfdir, 947 O_WRONLY, 948 syscall.EISDIR, 949 }, 950 { 951 sfdir + "/" + sfname + "/no-such-file", 952 O_WRONLY, 953 syscall.ENOTDIR, 954 }, 955 } 956 957 func TestOpenError(t *testing.T) { 958 for _, tt := range openErrorTests { 959 f, err := OpenFile(tt.path, tt.mode, 0) 960 if err == nil { 961 t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode) 962 f.Close() 963 continue 964 } 965 perr, ok := err.(*PathError) 966 if !ok { 967 t.Errorf("Open(%q, %d) returns error of %T type; want *PathError", tt.path, tt.mode, err) 968 } 969 if perr.Err != tt.error { 970 if runtime.GOOS == "plan9" { 971 syscallErrStr := perr.Err.Error() 972 expectedErrStr := strings.Replace(tt.error.Error(), "file ", "", 1) 973 if !strings.HasSuffix(syscallErrStr, expectedErrStr) { 974 // Some Plan 9 file servers incorrectly return 975 // EACCES rather than EISDIR when a directory is 976 // opened for write. 977 if tt.error == syscall.EISDIR && strings.HasSuffix(syscallErrStr, syscall.EACCES.Error()) { 978 continue 979 } 980 t.Errorf("Open(%q, %d) = _, %q; want suffix %q", tt.path, tt.mode, syscallErrStr, expectedErrStr) 981 } 982 continue 983 } 984 if runtime.GOOS == "dragonfly" { 985 // DragonFly incorrectly returns EACCES rather 986 // EISDIR when a directory is opened for write. 987 if tt.error == syscall.EISDIR && perr.Err == syscall.EACCES { 988 continue 989 } 990 } 991 t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Err.Error(), tt.error.Error()) 992 } 993 } 994 } 995 996 func TestOpenNoName(t *testing.T) { 997 f, err := Open("") 998 if err == nil { 999 t.Fatal(`Open("") succeeded`) 1000 f.Close() 1001 } 1002 } 1003 1004 func run(t *testing.T, cmd []string) string { 1005 // Run /bin/hostname and collect output. 1006 r, w, err := Pipe() 1007 if err != nil { 1008 t.Fatal(err) 1009 } 1010 defer r.Close() 1011 p, err := StartProcess("/bin/hostname", []string{"hostname"}, &ProcAttr{Files: []*File{nil, w, Stderr}}) 1012 if err != nil { 1013 t.Fatal(err) 1014 } 1015 w.Close() 1016 1017 var b bytes.Buffer 1018 io.Copy(&b, r) 1019 _, err = p.Wait() 1020 if err != nil { 1021 t.Fatalf("run hostname Wait: %v", err) 1022 } 1023 err = p.Kill() 1024 if err == nil { 1025 t.Errorf("expected an error from Kill running 'hostname'") 1026 } 1027 output := b.String() 1028 if n := len(output); n > 0 && output[n-1] == '\n' { 1029 output = output[0 : n-1] 1030 } 1031 if output == "" { 1032 t.Fatalf("%v produced no output", cmd) 1033 } 1034 1035 return output 1036 } 1037 1038 func TestHostname(t *testing.T) { 1039 // There is no other way to fetch hostname on windows, but via winapi. 1040 // On Plan 9 it can be taken from #c/sysname as Hostname() does. 1041 switch runtime.GOOS { 1042 case "android", "nacl", "plan9", "windows": 1043 t.Skipf("skipping on %s", runtime.GOOS) 1044 } 1045 1046 // Check internal Hostname() against the output of /bin/hostname. 1047 // Allow that the internal Hostname returns a Fully Qualified Domain Name 1048 // and the /bin/hostname only returns the first component 1049 hostname, err := Hostname() 1050 if err != nil { 1051 t.Fatalf("%v", err) 1052 } 1053 want := run(t, []string{"/bin/hostname"}) 1054 if hostname != want { 1055 i := strings.Index(hostname, ".") 1056 if i < 0 || hostname[0:i] != want { 1057 t.Errorf("Hostname() = %q, want %q", hostname, want) 1058 } 1059 } 1060 } 1061 1062 func TestReadAt(t *testing.T) { 1063 f := newFile("TestReadAt", t) 1064 defer Remove(f.Name()) 1065 defer f.Close() 1066 1067 const data = "hello, world\n" 1068 io.WriteString(f, data) 1069 1070 b := make([]byte, 5) 1071 n, err := f.ReadAt(b, 7) 1072 if err != nil || n != len(b) { 1073 t.Fatalf("ReadAt 7: %d, %v", n, err) 1074 } 1075 if string(b) != "world" { 1076 t.Fatalf("ReadAt 7: have %q want %q", string(b), "world") 1077 } 1078 } 1079 1080 func TestWriteAt(t *testing.T) { 1081 f := newFile("TestWriteAt", t) 1082 defer Remove(f.Name()) 1083 defer f.Close() 1084 1085 const data = "hello, world\n" 1086 io.WriteString(f, data) 1087 1088 n, err := f.WriteAt([]byte("WORLD"), 7) 1089 if err != nil || n != 5 { 1090 t.Fatalf("WriteAt 7: %d, %v", n, err) 1091 } 1092 1093 b, err := ioutil.ReadFile(f.Name()) 1094 if err != nil { 1095 t.Fatalf("ReadFile %s: %v", f.Name(), err) 1096 } 1097 if string(b) != "hello, WORLD\n" { 1098 t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n") 1099 } 1100 } 1101 1102 func writeFile(t *testing.T, fname string, flag int, text string) string { 1103 f, err := OpenFile(fname, flag, 0666) 1104 if err != nil { 1105 t.Fatalf("Open: %v", err) 1106 } 1107 n, err := io.WriteString(f, text) 1108 if err != nil { 1109 t.Fatalf("WriteString: %d, %v", n, err) 1110 } 1111 f.Close() 1112 data, err := ioutil.ReadFile(fname) 1113 if err != nil { 1114 t.Fatalf("ReadFile: %v", err) 1115 } 1116 return string(data) 1117 } 1118 1119 func TestAppend(t *testing.T) { 1120 const f = "append.txt" 1121 defer Remove(f) 1122 s := writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new") 1123 if s != "new" { 1124 t.Fatalf("writeFile: have %q want %q", s, "new") 1125 } 1126 s = writeFile(t, f, O_APPEND|O_RDWR, "|append") 1127 if s != "new|append" { 1128 t.Fatalf("writeFile: have %q want %q", s, "new|append") 1129 } 1130 s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "|append") 1131 if s != "new|append|append" { 1132 t.Fatalf("writeFile: have %q want %q", s, "new|append|append") 1133 } 1134 err := Remove(f) 1135 if err != nil { 1136 t.Fatalf("Remove: %v", err) 1137 } 1138 s = writeFile(t, f, O_CREATE|O_APPEND|O_RDWR, "new&append") 1139 if s != "new&append" { 1140 t.Fatalf("writeFile: after append have %q want %q", s, "new&append") 1141 } 1142 s = writeFile(t, f, O_CREATE|O_RDWR, "old") 1143 if s != "old&append" { 1144 t.Fatalf("writeFile: after create have %q want %q", s, "old&append") 1145 } 1146 s = writeFile(t, f, O_CREATE|O_TRUNC|O_RDWR, "new") 1147 if s != "new" { 1148 t.Fatalf("writeFile: after truncate have %q want %q", s, "new") 1149 } 1150 } 1151 1152 func TestStatDirWithTrailingSlash(t *testing.T) { 1153 // Create new temporary directory and arrange to clean it up. 1154 path, err := ioutil.TempDir("", "/_TestStatDirWithSlash_") 1155 if err != nil { 1156 t.Fatalf("TempDir: %s", err) 1157 } 1158 defer RemoveAll(path) 1159 1160 // Stat of path should succeed. 1161 _, err = Stat(path) 1162 if err != nil { 1163 t.Fatalf("stat %s failed: %s", path, err) 1164 } 1165 1166 // Stat of path+"/" should succeed too. 1167 path += "/" 1168 _, err = Stat(path) 1169 if err != nil { 1170 t.Fatalf("stat %s failed: %s", path, err) 1171 } 1172 } 1173 1174 func TestNilProcessStateString(t *testing.T) { 1175 var ps *ProcessState 1176 s := ps.String() 1177 if s != "<nil>" { 1178 t.Errorf("(*ProcessState)(nil).String() = %q, want %q", s, "<nil>") 1179 } 1180 } 1181 1182 func TestSameFile(t *testing.T) { 1183 fa, err := Create("a") 1184 if err != nil { 1185 t.Fatalf("Create(a): %v", err) 1186 } 1187 defer Remove(fa.Name()) 1188 fa.Close() 1189 fb, err := Create("b") 1190 if err != nil { 1191 t.Fatalf("Create(b): %v", err) 1192 } 1193 defer Remove(fb.Name()) 1194 fb.Close() 1195 1196 ia1, err := Stat("a") 1197 if err != nil { 1198 t.Fatalf("Stat(a): %v", err) 1199 } 1200 ia2, err := Stat("a") 1201 if err != nil { 1202 t.Fatalf("Stat(a): %v", err) 1203 } 1204 if !SameFile(ia1, ia2) { 1205 t.Errorf("files should be same") 1206 } 1207 1208 ib, err := Stat("b") 1209 if err != nil { 1210 t.Fatalf("Stat(b): %v", err) 1211 } 1212 if SameFile(ia1, ib) { 1213 t.Errorf("files should be different") 1214 } 1215 } 1216 1217 func TestDevNullFile(t *testing.T) { 1218 f, err := Open(DevNull) 1219 if err != nil { 1220 t.Fatalf("Open(%s): %v", DevNull, err) 1221 } 1222 defer f.Close() 1223 fi, err := f.Stat() 1224 if err != nil { 1225 t.Fatalf("Stat(%s): %v", DevNull, err) 1226 } 1227 name := filepath.Base(DevNull) 1228 if fi.Name() != name { 1229 t.Fatalf("wrong file name have %v want %v", fi.Name(), name) 1230 } 1231 if fi.Size() != 0 { 1232 t.Fatalf("wrong file size have %d want 0", fi.Size()) 1233 } 1234 } 1235 1236 var testLargeWrite = flag.Bool("large_write", false, "run TestLargeWriteToConsole test that floods console with output") 1237 1238 func TestLargeWriteToConsole(t *testing.T) { 1239 if !*testLargeWrite { 1240 t.Skip("skipping console-flooding test; enable with -large_write") 1241 } 1242 b := make([]byte, 32000) 1243 for i := range b { 1244 b[i] = '.' 1245 } 1246 b[len(b)-1] = '\n' 1247 n, err := Stdout.Write(b) 1248 if err != nil { 1249 t.Fatalf("Write to os.Stdout failed: %v", err) 1250 } 1251 if n != len(b) { 1252 t.Errorf("Write to os.Stdout should return %d; got %d", len(b), n) 1253 } 1254 n, err = Stderr.Write(b) 1255 if err != nil { 1256 t.Fatalf("Write to os.Stderr failed: %v", err) 1257 } 1258 if n != len(b) { 1259 t.Errorf("Write to os.Stderr should return %d; got %d", len(b), n) 1260 } 1261 } 1262 1263 func TestStatDirModeExec(t *testing.T) { 1264 const mode = 0111 1265 1266 path, err := ioutil.TempDir("", "go-build") 1267 if err != nil { 1268 t.Fatalf("Failed to create temp directory: %v", err) 1269 } 1270 defer RemoveAll(path) 1271 1272 if err := Chmod(path, 0777); err != nil { 1273 t.Fatalf("Chmod %q 0777: %v", path, err) 1274 } 1275 1276 dir, err := Stat(path) 1277 if err != nil { 1278 t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err) 1279 } 1280 if dir.Mode()&mode != mode { 1281 t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode()&mode, mode) 1282 } 1283 } 1284 1285 func TestReadAtEOF(t *testing.T) { 1286 f := newFile("TestReadAtEOF", t) 1287 defer Remove(f.Name()) 1288 defer f.Close() 1289 1290 _, err := f.ReadAt(make([]byte, 10), 0) 1291 switch err { 1292 case io.EOF: 1293 // all good 1294 case nil: 1295 t.Fatalf("ReadAt succeeded") 1296 default: 1297 t.Fatalf("ReadAt failed: %s", err) 1298 } 1299 } 1300 1301 func testKillProcess(t *testing.T, processKiller func(p *Process)) { 1302 switch runtime.GOOS { 1303 case "android", "nacl": 1304 t.Skipf("skipping on %s", runtime.GOOS) 1305 } 1306 1307 dir, err := ioutil.TempDir("", "go-build") 1308 if err != nil { 1309 t.Fatalf("Failed to create temp directory: %v", err) 1310 } 1311 defer RemoveAll(dir) 1312 1313 src := filepath.Join(dir, "main.go") 1314 f, err := Create(src) 1315 if err != nil { 1316 t.Fatalf("Failed to create %v: %v", src, err) 1317 } 1318 st := template.Must(template.New("source").Parse(` 1319 package main 1320 import "time" 1321 func main() { 1322 time.Sleep(time.Second) 1323 } 1324 `)) 1325 err = st.Execute(f, nil) 1326 if err != nil { 1327 f.Close() 1328 t.Fatalf("Failed to execute template: %v", err) 1329 } 1330 f.Close() 1331 1332 exe := filepath.Join(dir, "main.exe") 1333 output, err := osexec.Command("go", "build", "-o", exe, src).CombinedOutput() 1334 if err != nil { 1335 t.Fatalf("Failed to build exe %v: %v %v", exe, err, string(output)) 1336 } 1337 1338 cmd := osexec.Command(exe) 1339 err = cmd.Start() 1340 if err != nil { 1341 t.Fatalf("Failed to start test process: %v", err) 1342 } 1343 go func() { 1344 time.Sleep(100 * time.Millisecond) 1345 processKiller(cmd.Process) 1346 }() 1347 err = cmd.Wait() 1348 if err == nil { 1349 t.Errorf("Test process succeeded, but expected to fail") 1350 } 1351 } 1352 1353 func TestKillStartProcess(t *testing.T) { 1354 testKillProcess(t, func(p *Process) { 1355 err := p.Kill() 1356 if err != nil { 1357 t.Fatalf("Failed to kill test process: %v", err) 1358 } 1359 }) 1360 } 1361 1362 func TestGetppid(t *testing.T) { 1363 switch runtime.GOOS { 1364 case "nacl": 1365 t.Skip("skipping on nacl") 1366 case "plan9": 1367 // TODO: golang.org/issue/8206 1368 t.Skipf("skipping test on plan9; see issue 8206") 1369 } 1370 1371 if Getenv("GO_WANT_HELPER_PROCESS") == "1" { 1372 fmt.Print(Getppid()) 1373 Exit(0) 1374 } 1375 1376 cmd := osexec.Command(Args[0], "-test.run=TestGetppid") 1377 cmd.Env = append(Environ(), "GO_WANT_HELPER_PROCESS=1") 1378 1379 // verify that Getppid() from the forked process reports our process id 1380 output, err := cmd.CombinedOutput() 1381 if err != nil { 1382 t.Fatalf("Failed to spawn child process: %v %q", err, string(output)) 1383 } 1384 1385 childPpid := string(output) 1386 ourPid := fmt.Sprintf("%d", Getpid()) 1387 if childPpid != ourPid { 1388 t.Fatalf("Child process reports parent process id '%v', expected '%v'", childPpid, ourPid) 1389 } 1390 } 1391 1392 func TestKillFindProcess(t *testing.T) { 1393 testKillProcess(t, func(p *Process) { 1394 p2, err := FindProcess(p.Pid) 1395 if err != nil { 1396 t.Fatalf("Failed to find test process: %v", err) 1397 } 1398 err = p2.Kill() 1399 if err != nil { 1400 t.Fatalf("Failed to kill test process: %v", err) 1401 } 1402 }) 1403 } 1404 1405 var nilFileMethodTests = []struct { 1406 name string 1407 f func(*File) error 1408 }{ 1409 {"Chdir", func(f *File) error { return f.Chdir() }}, 1410 {"Close", func(f *File) error { return f.Close() }}, 1411 {"Chmod", func(f *File) error { return f.Chmod(0) }}, 1412 {"Chown", func(f *File) error { return f.Chown(0, 0) }}, 1413 {"Read", func(f *File) error { _, err := f.Read(make([]byte, 0)); return err }}, 1414 {"ReadAt", func(f *File) error { _, err := f.ReadAt(make([]byte, 0), 0); return err }}, 1415 {"Readdir", func(f *File) error { _, err := f.Readdir(1); return err }}, 1416 {"Readdirnames", func(f *File) error { _, err := f.Readdirnames(1); return err }}, 1417 {"Seek", func(f *File) error { _, err := f.Seek(0, 0); return err }}, 1418 {"Stat", func(f *File) error { _, err := f.Stat(); return err }}, 1419 {"Sync", func(f *File) error { return f.Sync() }}, 1420 {"Truncate", func(f *File) error { return f.Truncate(0) }}, 1421 {"Write", func(f *File) error { _, err := f.Write(make([]byte, 0)); return err }}, 1422 {"WriteAt", func(f *File) error { _, err := f.WriteAt(make([]byte, 0), 0); return err }}, 1423 {"WriteString", func(f *File) error { _, err := f.WriteString(""); return err }}, 1424 } 1425 1426 // Test that all File methods give ErrInvalid if the receiver is nil. 1427 func TestNilFileMethods(t *testing.T) { 1428 for _, tt := range nilFileMethodTests { 1429 var file *File 1430 got := tt.f(file) 1431 if got != ErrInvalid { 1432 t.Errorf("%v should fail when f is nil; got %v", tt.name, got) 1433 } 1434 } 1435 } 1436 1437 func mkdirTree(t *testing.T, root string, level, max int) { 1438 if level >= max { 1439 return 1440 } 1441 level++ 1442 for i := 'a'; i < 'c'; i++ { 1443 dir := filepath.Join(root, string(i)) 1444 if err := Mkdir(dir, 0700); err != nil { 1445 t.Fatal(err) 1446 } 1447 mkdirTree(t, dir, level, max) 1448 } 1449 } 1450 1451 // Test that simultaneous RemoveAll do not report an error. 1452 // As long as it gets removed, we should be happy. 1453 func TestRemoveAllRace(t *testing.T) { 1454 if runtime.GOOS == "windows" { 1455 // Windows has very strict rules about things like 1456 // removing directories while someone else has 1457 // them open. The racing doesn't work out nicely 1458 // like it does on Unix. 1459 t.Skip("skipping on windows") 1460 } 1461 1462 n := runtime.GOMAXPROCS(16) 1463 defer runtime.GOMAXPROCS(n) 1464 root, err := ioutil.TempDir("", "issue") 1465 if err != nil { 1466 t.Fatal(err) 1467 } 1468 mkdirTree(t, root, 1, 6) 1469 hold := make(chan struct{}) 1470 var wg sync.WaitGroup 1471 for i := 0; i < 4; i++ { 1472 wg.Add(1) 1473 go func() { 1474 defer wg.Done() 1475 <-hold 1476 err := RemoveAll(root) 1477 if err != nil { 1478 t.Errorf("unexpected error: %T, %q", err, err) 1479 } 1480 }() 1481 } 1482 close(hold) // let workers race to remove root 1483 wg.Wait() 1484 }