code review 5298073: os: use error, io.EOF

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 59 matching lines @@
         file, err := Open(name)
         defer file.Close()
         if err != nil {
                 t.Fatal("open failed:", err)
         }
         var buf [100]byte
         len := 0
         for {
                 n, e := file.Read(buf[0:])
                 len += n
-                if e == EOF {
+                if e == io.EOF {
                         break
                 }
                 if e != nil {
                         t.Fatal("read failed:", err)
                 }
         }
         return int64(len)
 }
 
 func equal(name1, name2 string) (r bool) {
@@ skipping 159 matching lines @@
         testReaddir(".", dot, t)
         testReaddir(sysdir.name, sysdir.files, t)
 }
 
 // Read the directory one entry at a time.
 func smallReaddirnames(file *File, length int, t *testing.T) []string {
         names := make([]string, length)
         count := 0
         for {
                 d, err := file.Readdirnames(1)
-                if err == EOF {
+                if err == io.EOF {
                         break
                 }
                 if err != nil {
                         t.Fatalf("readdirnames %q failed: %v", file.Name(), err)
                 }
                 if len(d) == 0 {
                         t.Fatalf("readdirnames %q returned empty slice and no error", file.Name())
                 }
                 names[count] = d[0]
                 count++
@@ skipping 50 matching lines @@
                 f, err := Create(filepath.Join(dir, fmt.Sprintf("%d", i)))
                 if err != nil {
                         t.Fatalf("Create: %v", err)
                 }
                 f.Write([]byte(strings.Repeat("X", i)))
                 f.Close()
         }
 
         var d *File
         openDir := func() {
-                var err Error
+                var err error
                 d, err = Open(dir)
                 if err != nil {
                         t.Fatalf("Open directory: %v", err)
                 }
         }
 
-        readDirExpect := func(n, want int, wantErr Error) {
+        readDirExpect := func(n, want int, wantErr error) {
                 fi, err := d.Readdir(n)
                 if err != wantErr {
                         t.Fatalf("Readdir of %d got error %v, want %v", n, err, wantErr)
                 }
                 if g, e := len(fi), want; g != e {
                         t.Errorf("Readdir of %d got %d files, want %d", n, g, e)
                 }
         }
 
-        readDirNamesExpect := func(n, want int, wantErr Error) {
+        readDirNamesExpect := func(n, want int, wantErr error) {
                 fi, err := d.Readdirnames(n)
                 if err != wantErr {
                         t.Fatalf("Readdirnames of %d got error %v, want %v", n, err, wantErr)
                 }
                 if g, e := len(fi), want; g != e {
                         t.Errorf("Readdirnames of %d got %d files, want %d", n, g, e)
                 }
         }
 
-        for _, fn := range []func(int, int, Error){readDirExpect, readDirNamesExpect} {
+        for _, fn := range []func(int, int, error){readDirExpect, readDirNamesExpect} {
                 // Test the slurp case
                 openDir()
                 fn(0, 105, nil)
                 fn(0, 0, nil)
                 d.Close()
 
                 // Slurp with -1 instead
                 openDir()
                 fn(-1, 105, nil)
                 fn(-2, 0, nil)
                 fn(0, 0, nil)
                 d.Close()
 
                 // Test the bounded case
                 openDir()
                 fn(1, 1, nil)
                 fn(2, 2, nil)
                 fn(105, 102, nil) // and tests buffer >100 case
-                fn(3, 0, EOF)
+                fn(3, 0, io.EOF)
                 d.Close()
         }
 }
 
 func TestHardLink(t *testing.T) {
         // Hardlinks are not supported under windows or Plan 9.
         if syscall.OS == "windows" || syscall.OS == "plan9" {
                 return
         }
         from, to := "hardlinktestfrom", "hardlinktestto"
@@ skipping 446 matching lines @@
                 {5, 0, 5},
                 {0, 2, int64(len(data))},
                 {0, 0, 0},
                 {-1, 2, int64(len(data)) - 1},
                 {1 << 33, 0, 1 << 33},
                 {1 << 33, 2, 1<<33 + int64(len(data))},
         }
         for i, tt := range tests {
                 off, err := f.Seek(tt.in, tt.whence)
                 if off != tt.out || err != nil {
-                        if e, ok := err.(*PathError); ok && e.Error == EINVAL && tt.out > 1<<32 {
+                        if e, ok := err.(*PathError); ok && e.Err == EINVAL && tt.out > 1<<32 {
                                 // Reiserfs rejects the big seeks.
                                 // http://code.google.com/p/go/issues/detail?id=91
                                 break
                         }
                         t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
                 }
         }
 }
 
 type openErrorTest struct {
         path  string
         mode  int
-        error Error
+        error error
 }
 
 var openErrorTests = []openErrorTest{
         {
                 sfdir + "/no-such-file",
                 O_RDONLY,
                 ENOENT,
         },
         {
                 sfdir,
@@ skipping 12 matching lines @@
                 f, err := OpenFile(tt.path, tt.mode, 0)
                 if err == nil {
                         t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode)
                         f.Close()
                         continue
                 }
                 perr, ok := err.(*PathError)
                 if !ok {
                         t.Errorf("Open(%q, %d) returns error of %T type; want *os.PathError", tt.path, tt.mode, err)
                 }
-                if perr.Error != tt.error {
+                if perr.Err != tt.error {
                         if syscall.OS == "plan9" {
-                                syscallErrStr := perr.Error.String()
-                                expectedErrStr := strings.Replace(tt.error.String(), "file ", "", 1)
+                                syscallErrStr := perr.Err.Error()
+                                expectedErrStr := strings.Replace(tt.error.Error(), "file ", "", 1)
                                 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.Error.String(), tt.error.String())
+                                t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Err.Error(), tt.error.Error())
                         }
                 }
         }
 }
 
 func run(t *testing.T, cmd []string) string {
         // Run /bin/hostname and collect output.
         r, w, err := Pipe()
         if err != nil {
                 t.Fatal(err)
@@ skipping 167 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>")
         }
 }