code review 7308058: net: add unixgram dial test

src/pkg/net/conn_test.go

 // Copyright 2012 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 net_test
+// This file implements API tests across platforms and will never have a build
+// tag.
+
+package net
 
 import (
-        "io/ioutil"
-        "net"
         "os"
         "runtime"
         "testing"
         "time"
 )
-
-func testUnixAddr() string {
-        f, err := ioutil.TempFile("", "nettest")
-        if err != nil {
-                panic(err)
-        }
-        addr := f.Name()
-        f.Close()
-        os.Remove(addr)
-        return addr
-}
 
 var connTests = []struct {
         net  string
         addr string
 }{
         {"tcp", "127.0.0.1:0"},
         {"unix", testUnixAddr()},
         {"unixpacket", testUnixAddr()},
 }
 
 func TestConnAndListener(t *testing.T) {
         for _, tt := range connTests {
                 switch tt.net {
                 case "unix", "unixpacket":
                         switch runtime.GOOS {
                         case "plan9", "windows":
                                 continue
                         }
                         if tt.net == "unixpacket" && runtime.GOOS != "linux" {
                                 continue
                         }
                 }
 
-                ln, err := net.Listen(tt.net, tt.addr)
+                ln, err := Listen(tt.net, tt.addr)
                 if err != nil {
-                        t.Fatalf("net.Listen failed: %v", err)
+                        t.Fatalf("Listen failed: %v", err)
                 }
-                ln.Addr()
-                defer func(ln net.Listener, net, addr string) {
+                defer func(ln Listener, net, addr string) {
                         ln.Close()
                         switch net {
                         case "unix", "unixpacket":
                                 os.Remove(addr)
                         }
                 }(ln, tt.net, tt.addr)
+                ln.Addr()
 
                 done := make(chan int)
                 go transponder(t, ln, done)
 
-                c, err := net.Dial(tt.net, ln.Addr().String())
+                c, err := Dial(tt.net, ln.Addr().String())
                 if err != nil {
-                        t.Fatalf("net.Dial failed: %v", err)
+                        t.Fatalf("Dial failed: %v", err)
                 }
+                defer c.Close()
                 c.LocalAddr()
                 c.RemoteAddr()
                 c.SetDeadline(time.Now().Add(100 * time.Millisecond))
                 c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
                 c.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
-                defer c.Close()
 
                 if _, err := c.Write([]byte("CONN TEST")); err != nil {
-                        t.Fatalf("net.Conn.Write failed: %v", err)
+                        t.Fatalf("Conn.Write failed: %v", err)
                 }
                 rb := make([]byte, 128)
                 if _, err := c.Read(rb); err != nil {
-                        t.Fatalf("net.Conn.Read failed: %v", err)
+                        t.Fatalf("Conn.Read failed: %v", err)
                 }
 
                 <-done
         }
 }
 
-func transponder(t *testing.T, ln net.Listener, done chan<- int) {
+func transponder(t *testing.T, ln Listener, done chan<- int) {
         defer func() { done <- 1 }()
 
-        switch ln.(type) {
-        case *net.TCPListener:
-                ln.(*net.TCPListener).SetDeadline(time.Now().Add(100 * time.Millisecond))
-        case *net.UnixListener:
-                ln.(*net.UnixListener).SetDeadline(time.Now().Add(100 * time.Millisecond))
+        switch ln := ln.(type) {
+        case *TCPListener:
+                ln.SetDeadline(time.Now().Add(100 * time.Millisecond))
+        case *UnixListener:
+                ln.SetDeadline(time.Now().Add(100 * time.Millisecond))
         }
         c, err := ln.Accept()
         if err != nil {
-                t.Fatalf("net.Listener.Accept failed: %v", err)
+                t.Errorf("Listener.Accept failed: %v", err)
+                return
         }
+        defer c.Close()
         c.LocalAddr()
         c.RemoteAddr()
         c.SetDeadline(time.Now().Add(100 * time.Millisecond))
         c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
         c.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
-        defer c.Close()
 
         b := make([]byte, 128)
         n, err := c.Read(b)
         if err != nil {
-                t.Fatalf("net.Conn.Read failed: %v", err)
+                t.Errorf("Conn.Read failed: %v", err)
+                return
         }
         if _, err := c.Write(b[:n]); err != nil {
-                t.Fatalf("net.Conn.Write failed: %v", err)
+                t.Errorf("Conn.Write failed: %v", err)
+                return
         }
 }