Update to current version of Go library (revision 94d654be2064).

[pf3gnuchains/gcc-fork.git] / libgo / go / netchan / netchan_test.go

diff --git a/libgo/go/netchan/netchan_test.go b/libgo/go/netchan/netchan_test.go
index 6d7d63f..1c84a9d 100644 (file)
--- a/libgo/go/netchan/netchan_test.go
+++ b/libgo/go/netchan/netchan_test.go
@@ -5,6 +5,7 @@
 package netchan
 
 import (
+       "net"
        "strings"
        "testing"
        "time"
@@ -23,7 +24,7 @@ func exportSend(exp *Exporter, n int, t *testing.T, done chan bool) {
        }
        go func() {
                for i := 0; i < n; i++ {
-                       ch <- base+i
+                       ch <- base + i
                }
                close(ch)
                if done != nil {
@@ -61,7 +62,7 @@ func importSend(imp *Importer, n int, t *testing.T, done chan bool) {
        }
        go func() {
                for i := 0; i < n; i++ {
-                       ch <- base+i
+                       ch <- base + i
                }
                close(ch)
                if done != nil {
@@ -94,27 +95,13 @@ func importReceive(imp *Importer, t *testing.T, done chan bool) {
 }
 
 func TestExportSendImportReceive(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        exportSend(exp, count, t, nil)
        importReceive(imp, t, nil)
 }
 
 func TestExportReceiveImportSend(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        expDone := make(chan bool)
        done := make(chan bool)
        go func() {
@@ -127,27 +114,13 @@ func TestExportReceiveImportSend(t *testing.T) {
 }
 
 func TestClosingExportSendImportReceive(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        exportSend(exp, closeCount, t, nil)
        importReceive(imp, t, nil)
 }
 
 func TestClosingImportSendExportReceive(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        expDone := make(chan bool)
        done := make(chan bool)
        go func() {
@@ -160,17 +133,10 @@ func TestClosingImportSendExportReceive(t *testing.T) {
 }
 
 func TestErrorForIllegalChannel(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        // Now export a channel.
        ch := make(chan int, 1)
-       err = exp.Export("aChannel", ch, Send)
+       err := exp.Export("aChannel", ch, Send)
        if err != nil {
                t.Fatal("export:", err)
        }
@@ -200,14 +166,7 @@ func TestErrorForIllegalChannel(t *testing.T) {
 
 // Not a great test but it does at least invoke Drain.
 func TestExportDrain(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        done := make(chan bool)
        go func() {
                exportSend(exp, closeCount, t, nil)
@@ -221,14 +180,7 @@ func TestExportDrain(t *testing.T) {
 
 // Not a great test but it does at least invoke Sync.
 func TestExportSync(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        done := make(chan bool)
        exportSend(exp, closeCount, t, nil)
        go importReceive(imp, t, done)
@@ -239,16 +191,9 @@ func TestExportSync(t *testing.T) {
 // Test hanging up the send side of an export.
 // TODO: test hanging up the receive side of an export.
 func TestExportHangup(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        ech := make(chan int)
-       err = exp.Export("exportedSend", ech, Send)
+       err := exp.Export("exportedSend", ech, Send)
        if err != nil {
                t.Fatal("export:", err)
        }
@@ -276,16 +221,9 @@ func TestExportHangup(t *testing.T) {
 // Test hanging up the send side of an import.
 // TODO: test hanging up the receive side of an import.
 func TestImportHangup(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
        ech := make(chan int)
-       err = exp.Export("exportedRecv", ech, Recv)
+       err := exp.Export("exportedRecv", ech, Recv)
        if err != nil {
                t.Fatal("export:", err)
        }
@@ -343,14 +281,7 @@ func exportLoopback(exp *Exporter, t *testing.T) {
 // This test checks that channel operations can proceed
 // even when other concurrent operations are blocked.
 func TestIndependentSends(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
 
        exportLoopback(exp, t)
 
@@ -377,23 +308,8 @@ type value struct {
 }
 
 func TestCrossConnect(t *testing.T) {
-       e1, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       i1, err := NewImporter("tcp", e1.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
-
-       e2, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       i2, err := NewImporter("tcp", e2.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       e1, i1 := pair(t)
+       e2, i2 := pair(t)
 
        crossExport(e1, e2, t)
        crossImport(i1, i2, t)
@@ -452,20 +368,13 @@ const flowCount = 100
 
 // test flow control from exporter to importer.
 func TestExportFlowControl(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
 
        sendDone := make(chan bool, 1)
        exportSend(exp, flowCount, t, sendDone)
 
        ch := make(chan int)
-       err = imp.ImportNValues("exportedSend", ch, Recv, 20, -1)
+       err := imp.ImportNValues("exportedSend", ch, Recv, 20, -1)
        if err != nil {
                t.Fatal("importReceive:", err)
        }
@@ -475,17 +384,10 @@ func TestExportFlowControl(t *testing.T) {
 
 // test flow control from importer to exporter.
 func TestImportFlowControl(t *testing.T) {
-       exp, err := NewExporter("tcp", "127.0.0.1:0")
-       if err != nil {
-               t.Fatal("new exporter:", err)
-       }
-       imp, err := NewImporter("tcp", exp.Addr().String())
-       if err != nil {
-               t.Fatal("new importer:", err)
-       }
+       exp, imp := pair(t)
 
        ch := make(chan int)
-       err = exp.Export("exportedRecv", ch, Recv)
+       err := exp.Export("exportedRecv", ch, Recv)
        if err != nil {
                t.Fatal("importReceive:", err)
        }
@@ -513,3 +415,11 @@ func testFlow(sendDone chan bool, ch <-chan int, N int, t *testing.T) {
                t.Fatalf("expected %d values; got %d", N, n)
        }
 }
+
+func pair(t *testing.T) (*Exporter, *Importer) {
+       c0, c1 := net.Pipe()
+       exp := NewExporter()
+       go exp.ServeConn(c0)
+       imp := NewImporter(c1)
+       return exp, imp
+}