1 files changed, 0 insertions, 271 deletions
diff --git a/src/pkg/io/pipe_test.go b/src/pkg/io/pipe_test.go
deleted file mode 100644
index bd4b94f0a..000000000
--- a/src/pkg/io/pipe_test.go
+++ /dev/null
@@ -1,271 +0,0 @@
-// 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 (
-	"fmt"
-	. "io"
-	"os"
-	"testing"
-	"time"
-)
-
-func checkWrite(t *testing.T, w Writer, data []byte, c chan int) {
-	n, err := w.Write(data)
-	if err != nil {
-		t.Errorf("write: %v", err)
-	}
-	if n != len(data) {
-		t.Errorf("short write: %d != %d", n, len(data))
-	}
-	c <- 0
-}
-
-// Test a single read/write pair.
-func TestPipe1(t *testing.T) {
-	c := make(chan int)
-	r, w := Pipe()
-	var buf = make([]byte, 64)
-	go checkWrite(t, w, []byte("hello, world"), c)
-	n, err := r.Read(buf)
-	if err != nil {
-		t.Errorf("read: %v", err)
-	} else if n != 12 || string(buf[0:12]) != "hello, world" {
-		t.Errorf("bad read: got %q", buf[0:n])
-	}
-	<-c
-	r.Close()
-	w.Close()
-}
-
-func reader(t *testing.T, r Reader, c chan int) {
-	var buf = make([]byte, 64)
-	for {
-		n, err := r.Read(buf)
-		if err == os.EOF {
-			c <- 0
-			break
-		}
-		if err != nil {
-			t.Errorf("read: %v", err)
-		}
-		c <- n
-	}
-}
-
-// Test a sequence of read/write pairs.
-func TestPipe2(t *testing.T) {
-	c := make(chan int)
-	r, w := Pipe()
-	go reader(t, r, c)
-	var buf = make([]byte, 64)
-	for i := 0; i < 5; i++ {
-		p := buf[0 : 5+i*10]
-		n, err := w.Write(p)
-		if n != len(p) {
-			t.Errorf("wrote %d, got %d", len(p), n)
-		}
-		if err != nil {
-			t.Errorf("write: %v", err)
-		}
-		nn := <-c
-		if nn != n {
-			t.Errorf("wrote %d, read got %d", n, nn)
-		}
-	}
-	w.Close()
-	nn := <-c
-	if nn != 0 {
-		t.Errorf("final read got %d", nn)
-	}
-}
-
-type pipeReturn struct {
-	n   int
-	err os.Error
-}
-
-// Test a large write that requires multiple reads to satisfy.
-func writer(w WriteCloser, buf []byte, c chan pipeReturn) {
-	n, err := w.Write(buf)
-	w.Close()
-	c <- pipeReturn{n, err}
-}
-
-func TestPipe3(t *testing.T) {
-	c := make(chan pipeReturn)
-	r, w := Pipe()
-	var wdat = make([]byte, 128)
-	for i := 0; i < len(wdat); i++ {
-		wdat[i] = byte(i)
-	}
-	go writer(w, wdat, c)
-	var rdat = make([]byte, 1024)
-	tot := 0
-	for n := 1; n <= 256; n *= 2 {
-		nn, err := r.Read(rdat[tot : tot+n])
-		if err != nil && err != os.EOF {
-			t.Fatalf("read: %v", err)
-		}
-
-		// only final two reads should be short - 1 byte, then 0
-		expect := n
-		if n == 128 {
-			expect = 1
-		} else if n == 256 {
-			expect = 0
-			if err != os.EOF {
-				t.Fatalf("read at end: %v", err)
-			}
-		}
-		if nn != expect {
-			t.Fatalf("read %d, expected %d, got %d", n, expect, nn)
-		}
-		tot += nn
-	}
-	pr := <-c
-	if pr.n != 128 || pr.err != nil {
-		t.Fatalf("write 128: %d, %v", pr.n, pr.err)
-	}
-	if tot != 128 {
-		t.Fatalf("total read %d != 128", tot)
-	}
-	for i := 0; i < 128; i++ {
-		if rdat[i] != byte(i) {
-			t.Fatalf("rdat[%d] = %d", i, rdat[i])
-		}
-	}
-}
-
-// Test read after/before writer close.
-
-type closer interface {
-	CloseWithError(os.Error) os.Error
-	Close() os.Error
-}
-
-type pipeTest struct {
-	async          bool
-	err            os.Error
-	closeWithError bool
-}
-
-func (p pipeTest) String() string {
-	return fmt.Sprintf("async=%v err=%v closeWithError=%v", p.async, p.err, p.closeWithError)
-}
-
-var pipeTests = []pipeTest{
-	{true, nil, false},
-	{true, nil, true},
-	{true, ErrShortWrite, true},
-	{false, nil, false},
-	{false, nil, true},
-	{false, ErrShortWrite, true},
-}
-
-func delayClose(t *testing.T, cl closer, ch chan int, tt pipeTest) {
-	time.Sleep(1e6) // 1 ms
-	var err os.Error
-	if tt.closeWithError {
-		err = cl.CloseWithError(tt.err)
-	} else {
-		err = cl.Close()
-	}
-	if err != nil {
-		t.Errorf("delayClose: %v", err)
-	}
-	ch <- 0
-}
-
-func TestPipeReadClose(t *testing.T) {
-	for _, tt := range pipeTests {
-		c := make(chan int, 1)
-		r, w := Pipe()
-		if tt.async {
-			go delayClose(t, w, c, tt)
-		} else {
-			delayClose(t, w, c, tt)
-		}
-		var buf = make([]byte, 64)
-		n, err := r.Read(buf)
-		<-c
-		want := tt.err
-		if want == nil {
-			want = os.EOF
-		}
-		if err != want {
-			t.Errorf("read from closed pipe: %v want %v", err, want)
-		}
-		if n != 0 {
-			t.Errorf("read on closed pipe returned %d", n)
-		}
-		if err = r.Close(); err != nil {
-			t.Errorf("r.Close: %v", err)
-		}
-	}
-}
-
-// Test close on Read side during Read.
-func TestPipeReadClose2(t *testing.T) {
-	c := make(chan int, 1)
-	r, _ := Pipe()
-	go delayClose(t, r, c, pipeTest{})
-	n, err := r.Read(make([]byte, 64))
-	<-c
-	if n != 0 || err != os.EINVAL {
-		t.Errorf("read from closed pipe: %v, %v want %v, %v", n, err, 0, os.EINVAL)
-	}
-}
-
-// Test write after/before reader close.
-
-func TestPipeWriteClose(t *testing.T) {
-	for _, tt := range pipeTests {
-		c := make(chan int, 1)
-		r, w := Pipe()
-		if tt.async {
-			go delayClose(t, r, c, tt)
-		} else {
-			delayClose(t, r, c, tt)
-		}
-		n, err := WriteString(w, "hello, world")
-		<-c
-		expect := tt.err
-		if expect == nil {
-			expect = os.EPIPE
-		}
-		if err != expect {
-			t.Errorf("write on closed pipe: %v want %v", err, expect)
-		}
-		if n != 0 {
-			t.Errorf("write on closed pipe returned %d", n)
-		}
-		if err = w.Close(); err != nil {
-			t.Errorf("w.Close: %v", err)
-		}
-	}
-}
-
-func TestWriteEmpty(t *testing.T) {
-	r, w := Pipe()
-	go func() {
-		w.Write([]byte{})
-		w.Close()
-	}()
-	var b [2]byte
-	ReadFull(r, b[0:2])
-	r.Close()
-}
-
-func TestWriteNil(t *testing.T) {
-	r, w := Pipe()
-	go func() {
-		w.Write(nil)
-		w.Close()
-	}()
-	var b [2]byte
-	ReadFull(r, b[0:2])
-	r.Close()
-}