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