code review 5416060: io: new FileInfo, FileMode types + update tree

src/pkg/os/os_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package os_test
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 390 matching lines @@
         }
         defer Remove(from)
         tostat, err := Stat(to)
         if err != nil {
                 t.Fatalf("stat %q failed: %v", to, err)
         }
         fromstat, err := Stat(from)
         if err != nil {
                 t.Fatalf("stat %q failed: %v", from, err)
         }
-        if !tostat.Same(fromstat) {
+        if !tostat.(*FileStat).SameFile(fromstat.(*FileStat)) {
                 t.Errorf("link %q, %q did not create hard link", to, from)
         }
 }
 
 func TestSymLink(t *testing.T) {
         // Symlinks are not supported under windows or Plan 9.
         if syscall.OS == "windows" || syscall.OS == "plan9" {
                 return
         }
         from, to := "symlinktestfrom", "symlinktestto"
@@ skipping 15 matching lines @@
         if err != nil {
                 t.Fatalf("stat %q failed: %v", to, err)
         }
         if tostat.Mode()&ModeSymlink != 0 {
                 t.Fatalf("stat %q claims to have found a symlink", to)
         }
         fromstat, err := Stat(from)
         if err != nil {
                 t.Fatalf("stat %q failed: %v", from, err)
         }
-        if !tostat.Same(fromstat) {
+        if !tostat.(*FileStat).SameFile(fromstat.(*FileStat)) {
                 t.Errorf("symlink %q, %q did not create symlink", to, from)
         }
         fromstat, err = Lstat(from)
         if err != nil {
                 t.Fatalf("lstat %q failed: %v", from, err)
         }
         if fromstat.Mode()&ModeSymlink == 0 {
                 t.Fatalf("symlink %q, %q did not create symlink", to, from)
         }
         fromstat, err = Stat(from)
@@ skipping 131 matching lines @@
                 t.Fatalf("chmod %s 0456: %s", f.Name(), err)
         }
         checkMode(t, f.Name(), 0456)
 
         if err := f.Chmod(0123); err != nil {
                 t.Fatalf("chmod %s 0123: %s", f.Name(), err)
         }
         checkMode(t, f.Name(), 0123)
 }
 
-func checkUidGid(t *testing.T, path string, uid, gid int) {
-        dir, err := Stat(path)
-        if err != nil {
-                t.Fatalf("Stat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err)
-        }
-        sys := dir.(*FileStat).Sys
-        if int(sys.Uid) != uid {
-                t.Errorf("Stat %q: uid %d want %d", path, sys.Uid, uid)
-        }
-        if int(sys.Gid) != gid {
-                t.Errorf("Stat %q: gid %d want %d", path, sys.Gid, gid)
-        }
-}
-
-func TestChown(t *testing.T) {
-        // Chown is not supported under windows or Plan 9.
-        // Plan9 provides a native ChownPlan9 version instead.
-        if syscall.OS == "windows" || syscall.OS == "plan9" {
-                return
-        }
-        // Use TempDir() to make sure we're on a local file system,
-        // so that the group ids returned by Getgroups will be allowed
-        // on the file.  On NFS, the Getgroups groups are
-        // basically useless.
-        f := newFile("TestChown", t)
-        defer Remove(f.Name())
-        defer f.Close()
-        dir, err := f.Stat()
-        if err != nil {
-                t.Fatalf("stat %s: %s", f.Name(), err)
-        }
-
-        // Can't change uid unless root, but can try
-        // changing the group id.  First try our current group.
-        gid := Getgid()
-        t.Log("gid:", gid)
-        if err = Chown(f.Name(), -1, gid); err != nil {
-                t.Fatalf("chown %s -1 %d: %s", f.Name(), gid, err)
-        }
-        sys := dir.(*FileStat).Sys
-        checkUidGid(t, f.Name(), int(sys.Uid), gid)
-
-        // Then try all the auxiliary groups.
-        groups, err := Getgroups()
-        if err != nil {
-                t.Fatalf("getgroups: %s", err)
-        }
-        t.Log("groups: ", groups)
-        for _, g := range groups {
-                if err = Chown(f.Name(), -1, g); err != nil {
-                        t.Fatalf("chown %s -1 %d: %s", f.Name(), g, err)
-                }
-                checkUidGid(t, f.Name(), int(sys.Uid), g)
-
-                // change back to gid to test fd.Chown
-                if err = f.Chown(-1, gid); err != nil {
-                        t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err)
-                }
-                checkUidGid(t, f.Name(), int(sys.Uid), gid)
-        }
-}
-
 func checkSize(t *testing.T, f *File, size int64) {
         dir, err := f.Stat()
         if err != nil {
                 t.Fatalf("Stat %q (looking for size %d): %s", f.Name(), size, err)
         }
         if dir.Size() != size {
                 t.Errorf("Stat %q: size %d want %d", f.Name(), dir.Size(), size)
         }
 }
 
@@ skipping 42 matching lines @@
         defer Remove(f.Name())
         defer f.Close()
 
         f.Write([]byte("hello, world\n"))
         f.Close()
 
         st, err := Stat(f.Name())
         if err != nil {
                 t.Fatalf("Stat %s: %s", f.Name(), err)
         }
-        preStat := st.(*FileStat).Sys
+        preStat := st.(*FileStat)
 
         // Move access and modification time back a second
-        at := TimespecToTime(preStat.Atimespec)
-        mt := TimespecToTime(preStat.Mtimespec)
+        at := Atime(preStat)
+        mt := preStat.ModTime()
         err = Chtimes(f.Name(), at.Add(-time.Second), mt.Add(-time.Second))
         if err != nil {
                 t.Fatalf("Chtimes %s: %s", f.Name(), err)
         }
 
         st, err = Stat(f.Name())
         if err != nil {
                 t.Fatalf("second Stat %s: %s", f.Name(), err)
         }
-        postStat := st.(*FileStat).Sys
+        postStat := st.(*FileStat)
 
         /* Plan 9:
                 Mtime is the time of the last change of content.  Similarly, atime is set whenever the
             contents are accessed; also, it is set whenever mtime is set.
         */
-        pat := TimespecToTime(postStat.Atimespec)
-        pmt := TimespecToTime(postStat.Mtimespec)
+        pat := Atime(postStat)
+        pmt := postStat.ModTime()
         if !pat.Before(at) && syscall.OS != "plan9" {
                 t.Errorf("AccessTime didn't go backwards; was=%d, after=%d", at, pat)
         }
 
         if !pmt.Before(mt) {
                 t.Errorf("ModTime didn't go backwards; was=%d, after=%d", mt, pmt)
         }
 }
 
 func TestChdirAndGetwd(t *testing.T) {
@@ skipping 143 matching lines @@
                                 if !strings.HasSuffix(syscallErrStr, expectedErrStr) {
                                         t.Errorf("Open(%q, %d) = _, %q; want suffix %q", tt.path, tt.mode, syscallErrStr, expectedErrStr)
                                 }
                         } else {
                                 t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Err.Error(), tt.error.Error())
                         }
                 }
         }
 }
 
+func TestOpenNoName(t *testing.T) {
+        f, err := Open("")
+        if err == nil {
+                t.Fatal(`Open("") succeeded`)
+                f.Close()
+        }
+}
+
 func run(t *testing.T, cmd []string) string {
         // Run /bin/hostname and collect output.
         r, w, err := Pipe()
         if err != nil {
                 t.Fatal(err)
         }
         p, err := StartProcess("/bin/hostname", []string{"hostname"}, &ProcAttr{Files: []*File{nil, w, Stderr}})
         if err != nil {
                 t.Fatal(err)
         }
@@ skipping 157 matching lines @@
         }
 }
 
 func TestNilWaitmsgString(t *testing.T) {
         var w *Waitmsg
         s := w.String()
         if s != "<nil>" {
                 t.Errorf("(*Waitmsg)(nil).String() = %q, want %q", s, "<nil>")
         }
 }