1 files changed, 65 insertions, 65 deletions

diff --git a/src/pkg/io/pipe_test.go b/src/pkg/io/pipe_test.go
index df83c3ade..793bed459 100644
--- a/src/pkg/io/pipe_test.go
+++ b/src/pkg/io/pipe_test.go
@@ -5,118 +5,118 @@
 package io_test
 
 import (
-	"fmt";
-	. "io";
-	"os";
-	"strings";
-	"testing";
-	"time";
+	"fmt"
+	. "io"
+	"os"
+	"strings"
+	"testing"
+	"time"
 )
 
 func checkWrite(t *testing.T, w Writer, data []byte, c chan int) {
-	n, err := w.Write(data);
+	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;
+	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, strings.Bytes("hello, world"), c);
-	n, err := r.Read(buf);
+	c := make(chan int)
+	r, w := Pipe()
+	var buf = make([]byte, 64)
+	go checkWrite(t, w, strings.Bytes("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();
+	<-c
+	r.Close()
+	w.Close()
 }
 
 func reader(t *testing.T, r Reader, c chan int) {
-	var buf = make([]byte, 64);
+	var buf = make([]byte, 64)
 	for {
-		n, err := r.Read(buf);
+		n, err := r.Read(buf)
 		if err == os.EOF {
-			c <- 0;
-			break;
+			c <- 0
+			break
 		}
 		if err != nil {
 			t.Errorf("read: %v", err)
 		}
-		c <- n;
+		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);
+	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);
+		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;
+		nn := <-c
 		if nn != n {
 			t.Errorf("wrote %d, read got %d", n, nn)
 		}
 	}
-	w.Close();
-	nn := <-c;
+	w.Close()
+	nn := <-c
 	if nn != 0 {
 		t.Errorf("final read got %d", nn)
 	}
 }
 
 type pipeReturn struct {
-	n	int;
-	err	os.Error;
+	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};
+	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);
+	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;
+	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]);
+		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;
+		expect := n
 		if n == 128 {
 			expect = 1
 		} else if n == 256 {
-			expect = 0;
+			expect = 0
 			if err != os.EOF {
 				t.Fatalf("read at end: %v", err)
 			}
@@ -124,9 +124,9 @@ func TestPipe3(t *testing.T) {
 		if nn != expect {
 			t.Fatalf("read %d, expected %d, got %d", n, expect, nn)
 		}
-		tot += nn;
+		tot += nn
 	}
-	pr := <-c;
+	pr := <-c
 	if pr.n != 128 || pr.err != nil {
 		t.Fatalf("write 128: %d, %v", pr.n, pr.err)
 	}
@@ -143,14 +143,14 @@ func TestPipe3(t *testing.T) {
 // Test read after/before writer close.
 
 type closer interface {
-	CloseWithError(os.Error) os.Error;
-	Close() os.Error;
+	CloseWithError(os.Error) os.Error
+	Close() os.Error
 }
 
 type pipeTest struct {
-	async		bool;
-	err		os.Error;
-	closeWithError	bool;
+	async          bool
+	err            os.Error
+	closeWithError bool
 }
 
 func (p pipeTest) String() string {
@@ -167,8 +167,8 @@ var pipeTests = []pipeTest{
 }
 
 func delayClose(t *testing.T, cl closer, ch chan int, tt pipeTest) {
-	time.Sleep(1e6);	// 1 ms
-	var err os.Error;
+	time.Sleep(1e6) // 1 ms
+	var err os.Error
 	if tt.closeWithError {
 		err = cl.CloseWithError(tt.err)
 	} else {
@@ -177,22 +177,22 @@ func delayClose(t *testing.T, cl closer, ch chan int, tt pipeTest) {
 	if err != nil {
 		t.Errorf("delayClose: %v", err)
 	}
-	ch <- 0;
+	ch <- 0
 }
 
 func TestPipeReadClose(t *testing.T) {
 	for _, tt := range pipeTests {
-		c := make(chan int, 1);
-		r, w := Pipe();
+		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;
+		var buf = make([]byte, 64)
+		n, err := r.Read(buf)
+		<-c
+		want := tt.err
 		if want == nil {
 			want = os.EOF
 		}
@@ -212,16 +212,16 @@ func TestPipeReadClose(t *testing.T) {
 
 func TestPipeWriteClose(t *testing.T) {
 	for _, tt := range pipeTests {
-		c := make(chan int, 1);
-		r, w := Pipe();
+		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;
+		n, err := WriteString(w, "hello, world")
+		<-c
+		expect := tt.err
 		if expect == nil {
 			expect = os.EPIPE
 		}