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