code review 5157045: io: rename Copyn to CopyN.

src/pkg/io/io_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 io_test
 
 import (
         "bytes"
         . "io"
         "os"
         "strings"
         "testing"
 )
 
 // An version of bytes.Buffer without ReadFrom and WriteTo
 type Buffer struct {
         bytes.Buffer
         ReaderFrom // conflicts with and hides bytes.Buffer's ReaderFrom.
         WriterTo   // conflicts with and hides bytes.Buffer's WriterTo.
 }
 
-// Simple tests, primarily to verify the ReadFrom and WriteTo callouts inside Copy and Copyn.
+// Simple tests, primarily to verify the ReadFrom and WriteTo callouts inside Copy and CopyN.
 
 func TestCopy(t *testing.T) {
         rb := new(Buffer)
         wb := new(Buffer)
         rb.WriteString("hello, world.")
         Copy(wb, rb)
         if wb.String() != "hello, world." {
                 t.Errorf("Copy did not work properly")
         }
 }
@@ skipping 11 matching lines @@
 func TestCopyWriteTo(t *testing.T) {
         rb := new(bytes.Buffer) // implements WriteTo.
         wb := new(Buffer)
         rb.WriteString("hello, world.")
         Copy(wb, rb)
         if wb.String() != "hello, world." {
                 t.Errorf("Copy did not work properly")
         }
 }
 
-func TestCopyn(t *testing.T) {
-        rb := new(Buffer)
-        wb := new(Buffer)
-        rb.WriteString("hello, world.")
-        Copyn(wb, rb, 5)
+func TestCopyN(t *testing.T) {
+        rb := new(Buffer)
+        wb := new(Buffer)
+        rb.WriteString("hello, world.")
+        CopyN(wb, rb, 5)
         if wb.String() != "hello" {
-                t.Errorf("Copyn did not work properly")
-        }
-}
-
-func TestCopynReadFrom(t *testing.T) {
+                t.Errorf("CopyN did not work properly")
+        }
+}
+
+func TestCopyNReadFrom(t *testing.T) {
         rb := new(Buffer)
         wb := new(bytes.Buffer) // implements ReadFrom.
         rb.WriteString("hello")
-        Copyn(wb, rb, 5)
+        CopyN(wb, rb, 5)
         if wb.String() != "hello" {
-                t.Errorf("Copyn did not work properly")
-        }
-}
-
-func TestCopynWriteTo(t *testing.T) {
+                t.Errorf("CopyN did not work properly")
+        }
+}
+
+func TestCopyNWriteTo(t *testing.T) {
         rb := new(bytes.Buffer) // implements WriteTo.
         wb := new(Buffer)
         rb.WriteString("hello, world.")
-        Copyn(wb, rb, 5)
+        CopyN(wb, rb, 5)
         if wb.String() != "hello" {
-                t.Errorf("Copyn did not work properly")
+                t.Errorf("CopyN did not work properly")
         }
 }
 
 type noReadFrom struct {
         w Writer
 }
 
 func (w *noReadFrom) Write(p []byte) (n int, err os.Error) {
         return w.w.Write(p)
 }
 
-func TestCopynEOF(t *testing.T) {
+func TestCopyNEOF(t *testing.T) {
         // Test that EOF behavior is the same regardless of whether
-        // argument to Copyn has ReadFrom.
+        // argument to CopyN has ReadFrom.
 
         b := new(bytes.Buffer)
 
-        n, err := Copyn(&noReadFrom{b}, strings.NewReader("foo"), 3)
+        n, err := CopyN(&noReadFrom{b}, strings.NewReader("foo"), 3)
         if n != 3 || err != nil {
-                t.Errorf("Copyn(noReadFrom, foo, 3) = %d, %v; want 3, nil", n, err)
-        }
-
-        n, err = Copyn(&noReadFrom{b}, strings.NewReader("foo"), 4)
+                t.Errorf("CopyN(noReadFrom, foo, 3) = %d, %v; want 3, nil", n, err)
+        }
+
+        n, err = CopyN(&noReadFrom{b}, strings.NewReader("foo"), 4)
         if n != 3 || err != os.EOF {
-                t.Errorf("Copyn(noReadFrom, foo, 4) = %d, %v; want 3, EOF", n, err)
-        }
-
-        n, err = Copyn(b, strings.NewReader("foo"), 3) // b has read from
+                t.Errorf("CopyN(noReadFrom, foo, 4) = %d, %v; want 3, EOF", n, err)
+        }
+
+        n, err = CopyN(b, strings.NewReader("foo"), 3) // b has read from
         if n != 3 || err != nil {
-                t.Errorf("Copyn(bytes.Buffer, foo, 3) = %d, %v; want 3, nil", n, err)
-        }
-
-        n, err = Copyn(b, strings.NewReader("foo"), 4) // b has read from
+                t.Errorf("CopyN(bytes.Buffer, foo, 3) = %d, %v; want 3, nil", n, err)
+        }
+
+        n, err = CopyN(b, strings.NewReader("foo"), 4) // b has read from
         if n != 3 || err != os.EOF {
-                t.Errorf("Copyn(bytes.Buffer, foo, 4) = %d, %v; want 3, EOF", n, err)
+                t.Errorf("CopyN(bytes.Buffer, foo, 4) = %d, %v; want 3, EOF", n, err)
         }
 }
 
 func TestReadAtLeast(t *testing.T) {
         var rb bytes.Buffer
         testReadAtLeast(t, &rb)
 }
 
 // A version of bytes.Buffer that returns n > 0, os.EOF on Read
 // when the input is exhausted.
@@ skipping 71 matching lines @@
                 t.Errorf("r.Read at EOF = %d, %v want 0, EOF", n, err)
         }
         rb = bytes.NewBuffer(src)
         pr, pw := Pipe()
         pr.Close()
         r = TeeReader(rb, pw)
         if n, err := ReadFull(r, dst); n != 0 || err != os.EPIPE {
                 t.Errorf("closed tee: ReadFull(r, dst) = %d, %v; want 0, EPIPE", n, err)
         }
 }