net: pass a testing.TB to newLocal* helpers

Passing in an explicit testing.TB gives two benefits:

1. It allows the helper to fail the test itself, instead of returning
   an error to the caller. A non-nil error invariably fails the
   calling test, and none of these callers bother to add detail to the
   error when logging it anyway so returning the error just added
   noise to the test bodies.

2. It allows the helper to use t.Cleanup to perform any needed cleanup
   tasks, which will be used in CL 370695 to clean up temp directories
   used as namespaces for unix socket paths.

For #34611

Change-Id: I805e701687c12de2caca955649369294229c10b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/370696
Trust: Bryan Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Bryan Mills <bcmills@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/net/conn_test.go b/src/net/conn_test.go
index e3cb0c5ec7e3afd549b53dc1d869b153ac390490..3403eddfd3ff7c8d41ecda191e73c95a711f73f6 100644 (file)
--- a/src/net/conn_test.go
+++ b/src/net/conn_test.go
@@ -26,10 +26,7 @@ func TestConnAndListener(t *testing.T) {
                        continue
                }
 
-               ls, err := newLocalServer(network)
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := newLocalServer(t, network)
                defer ls.teardown()
                ch := make(chan error, 1)
                handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }

diff --git a/src/net/dial_test.go b/src/net/dial_test.go
index 36843870aa2795732940be4e949efbb7c9b988d5..e0c9cdc2aec425a9cc10c56a69d3b3644402e881 100644 (file)
--- a/src/net/dial_test.go
+++ b/src/net/dial_test.go
@@ -59,10 +59,7 @@ func TestProhibitionaryDialArg(t *testing.T) {
 }
 
 func TestDialLocal(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
        _, port, err := SplitHostPort(ln.Addr().String())
        if err != nil {
@@ -619,13 +616,9 @@ func TestDialerLocalAddr(t *testing.T) {
                        c.Close()
                }
        }
-       var err error
        var lss [2]*localServer
        for i, network := range []string{"tcp4", "tcp6"} {
-               lss[i], err = newLocalServer(network)
-               if err != nil {
-                       t.Fatal(err)
-               }
+               lss[i] = newLocalServer(t, network)
                defer lss[i].teardown()
                if err := lss[i].buildup(handler); err != nil {
                        t.Fatal(err)
@@ -725,10 +718,7 @@ func TestDialerKeepAlive(t *testing.T) {
                        c.Close()
                }
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -826,10 +816,7 @@ func TestCancelAfterDial(t *testing.T) {
                t.Skip("avoiding time.Sleep")
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
 
        var wg sync.WaitGroup
        wg.Add(1)
@@ -932,11 +919,7 @@ func TestDialerControl(t *testing.T) {
                        if !testableNetwork(network) {
                                continue
                        }
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Error(err)
-                               continue
-                       }
+                       ln := newLocalListener(t, network)
                        defer ln.Close()
                        d := Dialer{Control: controlOnConnSetup}
                        c, err := d.Dial(network, ln.Addr().String())
@@ -952,11 +935,7 @@ func TestDialerControl(t *testing.T) {
                        if !testableNetwork(network) {
                                continue
                        }
-                       c1, err := newLocalPacketListener(network)
-                       if err != nil {
-                               t.Error(err)
-                               continue
-                       }
+                       c1 := newLocalPacketListener(t, network)
                        if network == "unixgram" {
                                defer os.Remove(c1.LocalAddr().String())
                        }
@@ -992,10 +971,7 @@ func (contextWithNonZeroDeadline) Deadline() (time.Time, bool) {
 }
 
 func TestDialWithNonZeroDeadline(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
        _, port, err := SplitHostPort(ln.Addr().String())
        if err != nil {

diff --git a/src/net/dial_unix_test.go b/src/net/dial_unix_test.go
index 64dca70eb85128385946150856074ce84cae05d3..4170367c4bd663f2ca96454d4e486ba0f564dd44 100644 (file)
--- a/src/net/dial_unix_test.go
+++ b/src/net/dial_unix_test.go
@@ -31,10 +31,7 @@ func TestDialContextCancelRace(t *testing.T) {
                testHookCanceledDial = oldTestHookCanceledDial
        }()
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        listenerDone := make(chan struct{})
        go func() {
                defer close(listenerDone)

diff --git a/src/net/error_test.go b/src/net/error_test.go
index 30f8af3aeeadcba8d6dfce42c7b675c499571661..4a191673e2fcb22101a2d7a58c4459166d17a2d0 100644 (file)
--- a/src/net/error_test.go
+++ b/src/net/error_test.go
@@ -553,10 +553,7 @@ third:
 }
 
 func TestCloseError(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
        if err != nil {
@@ -664,10 +661,7 @@ func TestAcceptError(t *testing.T) {
                        c.Close()
                }
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        if err := ls.buildup(handler); err != nil {
                ls.teardown()
                t.Fatal(err)
@@ -773,10 +767,7 @@ func TestFileError(t *testing.T) {
                t.Error("should fail")
        }
 
-       ln, err = newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln = newLocalListener(t, "tcp")
 
        for i := 0; i < 3; i++ {
                f, err := ln.(*TCPListener).File()

diff --git a/src/net/file_test.go b/src/net/file_test.go
index e86c15fac735fac0bbc2b055875c4083c60ba172..ea2a218dfbc562146c5904f51b6309e34411b47c 100644 (file)
--- a/src/net/file_test.go
+++ b/src/net/file_test.go
@@ -44,10 +44,7 @@ func TestFileConn(t *testing.T) {
                var network, address string
                switch tt.network {
                case "udp":
-                       c, err := newLocalPacketListener(tt.network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       c := newLocalPacketListener(t, tt.network)
                        defer c.Close()
                        network = c.LocalAddr().Network()
                        address = c.LocalAddr().String()
@@ -61,10 +58,7 @@ func TestFileConn(t *testing.T) {
                                var b [1]byte
                                c.Read(b[:])
                        }
-                       ls, err := newLocalServer(tt.network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ls := newLocalServer(t, tt.network)
                        defer ls.teardown()
                        if err := ls.buildup(handler); err != nil {
                                t.Fatal(err)
@@ -148,17 +142,17 @@ func TestFileListener(t *testing.T) {
                        continue
                }
 
-               ln1, err := newLocalListener(tt.network)
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ln1 := newLocalListener(t, tt.network)
                switch tt.network {
                case "unix", "unixpacket":
                        defer os.Remove(ln1.Addr().String())
                }
                addr := ln1.Addr()
 
-               var f *os.File
+               var (
+                       f   *os.File
+                       err error
+               )
                switch ln1 := ln1.(type) {
                case *TCPListener:
                        f, err = ln1.File()
@@ -240,17 +234,17 @@ func TestFilePacketConn(t *testing.T) {
                        continue
                }
 
-               c1, err := newLocalPacketListener(tt.network)
-               if err != nil {
-                       t.Fatal(err)
-               }
+               c1 := newLocalPacketListener(t, tt.network)
                switch tt.network {
                case "unixgram":
                        defer os.Remove(c1.LocalAddr().String())
                }
                addr := c1.LocalAddr()
 
-               var f *os.File
+               var (
+                       f   *os.File
+                       err error
+               )
                switch c1 := c1.(type) {
                case *UDPConn:
                        f, err = c1.File()
@@ -314,10 +308,7 @@ func TestFileCloseRace(t *testing.T) {
                c.Read(b[:])
        }
 
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)

diff --git a/src/net/listen_test.go b/src/net/listen_test.go
index 7aaebe8fa195d47bc91bb1136323607fa5a00e8b..09ffbb31a1ab498eac1eeab3e47654e6a4e5ab3f 100644 (file)
--- a/src/net/listen_test.go
+++ b/src/net/listen_test.go
@@ -697,10 +697,7 @@ func multicastRIBContains(ip IP) (bool, error) {
 
 // Issue 21856.
 func TestClosingListener(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        addr := ln.Addr()
 
        go func() {
@@ -738,15 +735,13 @@ func TestListenConfigControl(t *testing.T) {
                        if !testableNetwork(network) {
                                continue
                        }
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Error(err)
-                               continue
-                       }
+                       ln := newLocalListener(t, network)
                        address := ln.Addr().String()
+                       // TODO: This is racy. The selected address could be reused in between
+                       // this Close and the subsequent Listen.
                        ln.Close()
                        lc := ListenConfig{Control: controlOnConnSetup}
-                       ln, err = lc.Listen(context.Background(), network, address)
+                       ln, err := lc.Listen(context.Background(), network, address)
                        if err != nil {
                                t.Error(err)
                                continue
@@ -759,18 +754,16 @@ func TestListenConfigControl(t *testing.T) {
                        if !testableNetwork(network) {
                                continue
                        }
-                       c, err := newLocalPacketListener(network)
-                       if err != nil {
-                               t.Error(err)
-                               continue
-                       }
+                       c := newLocalPacketListener(t, network)
                        address := c.LocalAddr().String()
+                       // TODO: This is racy. The selected address could be reused in between
+                       // this Close and the subsequent ListenPacket.
                        c.Close()
                        if network == "unixgram" {
                                os.Remove(address)
                        }
                        lc := ListenConfig{Control: controlOnConnSetup}
-                       c, err = lc.ListenPacket(context.Background(), network, address)
+                       c, err := lc.ListenPacket(context.Background(), network, address)
                        if err != nil {
                                t.Error(err)
                                continue

diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go
index 70ecc69f66f171722be57ea5cc4b1e477e079984..0868871b7b3c21a6d94c6690ebccd3a063e56fc9 100644 (file)
--- a/src/net/mockserver_test.go
+++ b/src/net/mockserver_test.go
@@ -11,6 +11,7 @@ import (
        "fmt"
        "os"
        "sync"
+       "testing"
        "time"
 )
 
@@ -26,29 +27,44 @@ func testUnixAddr() string {
        return addr
 }
 
-func newLocalListener(network string) (Listener, error) {
+func newLocalListener(t testing.TB, network string) Listener {
+       listen := func(net, addr string) Listener {
+               ln, err := Listen(net, addr)
+               if err != nil {
+                       t.Helper()
+                       t.Fatal(err)
+               }
+               return ln
+       }
+
        switch network {
        case "tcp":
                if supportsIPv4() {
+                       if !supportsIPv6() {
+                               return listen("tcp4", "127.0.0.1:0")
+                       }
                        if ln, err := Listen("tcp4", "127.0.0.1:0"); err == nil {
-                               return ln, nil
+                               return ln
                        }
                }
                if supportsIPv6() {
-                       return Listen("tcp6", "[::1]:0")
+                       return listen("tcp6", "[::1]:0")
                }
        case "tcp4":
                if supportsIPv4() {
-                       return Listen("tcp4", "127.0.0.1:0")
+                       return listen("tcp4", "127.0.0.1:0")
                }
        case "tcp6":
                if supportsIPv6() {
-                       return Listen("tcp6", "[::1]:0")
+                       return listen("tcp6", "[::1]:0")
                }
        case "unix", "unixpacket":
-               return Listen(network, testUnixAddr())
+               return listen(network, testUnixAddr())
        }
-       return nil, fmt.Errorf("%s is not supported", network)
+
+       t.Helper()
+       t.Fatalf("%s is not supported", network)
+       return nil
 }
 
 func newDualStackListener() (lns []*TCPListener, err error) {
@@ -119,12 +135,10 @@ func (ls *localServer) teardown() error {
        return nil
 }
 
-func newLocalServer(network string) (*localServer, error) {
-       ln, err := newLocalListener(network)
-       if err != nil {
-               return nil, err
-       }
-       return &localServer{Listener: ln, done: make(chan bool)}, nil
+func newLocalServer(t testing.TB, network string) *localServer {
+       t.Helper()
+       ln := newLocalListener(t, network)
+       return &localServer{Listener: ln, done: make(chan bool)}
 }
 
 type streamListener struct {
@@ -133,8 +147,8 @@ type streamListener struct {
        done chan bool // signal that indicates server stopped
 }
 
-func (sl *streamListener) newLocalServer() (*localServer, error) {
-       return &localServer{Listener: sl.Listener, done: make(chan bool)}, nil
+func (sl *streamListener) newLocalServer() *localServer {
+       return &localServer{Listener: sl.Listener, done: make(chan bool)}
 }
 
 type dualStackServer struct {
@@ -286,27 +300,39 @@ func transceiver(c Conn, wb []byte, ch chan<- error) {
        }
 }
 
-func newLocalPacketListener(network string) (PacketConn, error) {
+func newLocalPacketListener(t testing.TB, network string) PacketConn {
+       listenPacket := func(net, addr string) PacketConn {
+               c, err := ListenPacket(net, addr)
+               if err != nil {
+                       t.Helper()
+                       t.Fatal(err)
+               }
+               return c
+       }
+
        switch network {
        case "udp":
                if supportsIPv4() {
-                       return ListenPacket("udp4", "127.0.0.1:0")
+                       return listenPacket("udp4", "127.0.0.1:0")
                }
                if supportsIPv6() {
-                       return ListenPacket("udp6", "[::1]:0")
+                       return listenPacket("udp6", "[::1]:0")
                }
        case "udp4":
                if supportsIPv4() {
-                       return ListenPacket("udp4", "127.0.0.1:0")
+                       return listenPacket("udp4", "127.0.0.1:0")
                }
        case "udp6":
                if supportsIPv6() {
-                       return ListenPacket("udp6", "[::1]:0")
+                       return listenPacket("udp6", "[::1]:0")
                }
        case "unixgram":
-               return ListenPacket(network, testUnixAddr())
+               return listenPacket(network, testUnixAddr())
        }
-       return nil, fmt.Errorf("%s is not supported", network)
+
+       t.Helper()
+       t.Fatalf("%s is not supported", network)
+       return nil
 }
 
 func newDualStackPacketListener() (cs []*UDPConn, err error) {
@@ -371,20 +397,18 @@ func (ls *localPacketServer) teardown() error {
        return nil
 }
 
-func newLocalPacketServer(network string) (*localPacketServer, error) {
-       c, err := newLocalPacketListener(network)
-       if err != nil {
-               return nil, err
-       }
-       return &localPacketServer{PacketConn: c, done: make(chan bool)}, nil
+func newLocalPacketServer(t testing.TB, network string) *localPacketServer {
+       t.Helper()
+       c := newLocalPacketListener(t, network)
+       return &localPacketServer{PacketConn: c, done: make(chan bool)}
 }
 
 type packetListener struct {
        PacketConn
 }
 
-func (pl *packetListener) newLocalServer() (*localPacketServer, error) {
-       return &localPacketServer{PacketConn: pl.PacketConn, done: make(chan bool)}, nil
+func (pl *packetListener) newLocalServer() *localPacketServer {
+       return &localPacketServer{PacketConn: pl.PacketConn, done: make(chan bool)}
 }
 
 func packetTransponder(c PacketConn, ch chan<- error) {

diff --git a/src/net/net_test.go b/src/net/net_test.go
index 5d9c3c67e681daa7b75cf7b94ab41f93c5e364f7..7b169916f1b4bd0c5feab13e7c25f1faa8f4f85a 100644 (file)
--- a/src/net/net_test.go
+++ b/src/net/net_test.go
@@ -33,10 +33,7 @@ func TestCloseRead(t *testing.T) {
                        }
                        t.Parallel()
 
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ln := newLocalListener(t, network)
                        switch network {
                        case "unix", "unixpacket":
                                defer os.Remove(ln.Addr().String())
@@ -132,10 +129,7 @@ func TestCloseWrite(t *testing.T) {
                                }
                        }
 
-                       ls, err := newLocalServer(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ls := newLocalServer(t, network)
                        defer ls.teardown()
                        if err := ls.buildup(handler); err != nil {
                                t.Fatal(err)
@@ -189,10 +183,7 @@ func TestConnClose(t *testing.T) {
                        }
                        t.Parallel()
 
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ln := newLocalListener(t, network)
                        switch network {
                        case "unix", "unixpacket":
                                defer os.Remove(ln.Addr().String())
@@ -234,10 +225,7 @@ func TestListenerClose(t *testing.T) {
                        }
                        t.Parallel()
 
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ln := newLocalListener(t, network)
                        switch network {
                        case "unix", "unixpacket":
                                defer os.Remove(ln.Addr().String())
@@ -275,10 +263,7 @@ func TestPacketConnClose(t *testing.T) {
                        }
                        t.Parallel()
 
-                       c, err := newLocalPacketListener(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       c := newLocalPacketListener(t, network)
                        switch network {
                        case "unixgram":
                                defer os.Remove(c.LocalAddr().String())
@@ -303,18 +288,17 @@ func TestPacketConnClose(t *testing.T) {
 func TestListenCloseListen(t *testing.T) {
        const maxTries = 10
        for tries := 0; tries < maxTries; tries++ {
-               ln, err := newLocalListener("tcp")
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ln := newLocalListener(t, "tcp")
                addr := ln.Addr().String()
+               // TODO: This is racy. The selected address could be reused in between this
+               // Close and the subsequent Listen.
                if err := ln.Close(); err != nil {
                        if perr := parseCloseError(err, false); perr != nil {
                                t.Error(perr)
                        }
                        t.Fatal(err)
                }
-               ln, err = Listen("tcp", addr)
+               ln, err := Listen("tcp", addr)
                if err == nil {
                        // Success. (This test didn't always make it here earlier.)
                        ln.Close()
@@ -360,10 +344,7 @@ func TestAcceptIgnoreAbortedConnRequest(t *testing.T) {
                }
                c.Close()
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -390,10 +371,7 @@ func TestZeroByteRead(t *testing.T) {
                        }
                        t.Parallel()
 
-                       ln, err := newLocalListener(network)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ln := newLocalListener(t, network)
                        connc := make(chan Conn, 1)
                        go func() {
                                defer ln.Close()
@@ -442,10 +420,7 @@ func TestZeroByteRead(t *testing.T) {
 // runs peer1 and peer2 concurrently. withTCPConnPair returns when
 // both have completed.
 func withTCPConnPair(t *testing.T, peer1, peer2 func(c *TCPConn) error) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
        errc := make(chan error, 2)
        go func() {

diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go
index 9f7d8ee4ef5071cda2ac4c0340b0ffccb1f47561..baf3ac6679018605261fef17171a147412edbfd1 100644 (file)
--- a/src/net/protoconn_test.go
+++ b/src/net/protoconn_test.go
@@ -73,10 +73,7 @@ func TestTCPConnSpecificMethods(t *testing.T) {
        }
        ch := make(chan error, 1)
        handler := func(ls *localServer, ln Listener) { ls.transponder(ls.Listener, ch) }
-       ls, err := (&streamListener{Listener: ln}).newLocalServer()
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := (&streamListener{Listener: ln}).newLocalServer()
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)

diff --git a/src/net/rawconn_test.go b/src/net/rawconn_test.go
index 645d82a1a6ab4321994272f7a16ede94e00549c0..d1ef79d7157a3b87b8d82ab3312bbc12150f3180 100644 (file)
--- a/src/net/rawconn_test.go
+++ b/src/net/rawconn_test.go
@@ -64,10 +64,7 @@ func TestRawConnReadWrite(t *testing.T) {
                                return
                        }
                }
-               ls, err := newLocalServer("tcp")
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := newLocalServer(t, "tcp")
                defer ls.teardown()
                if err := ls.buildup(handler); err != nil {
                        t.Fatal(err)
@@ -102,10 +99,7 @@ func TestRawConnReadWrite(t *testing.T) {
                        t.Skipf("not supported on %s", runtime.GOOS)
                }
 
-               ln, err := newLocalListener("tcp")
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ln := newLocalListener(t, "tcp")
                defer ln.Close()
 
                c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -180,10 +174,7 @@ func TestRawConnControl(t *testing.T) {
        }
 
        t.Run("TCP", func(t *testing.T) {
-               ln, err := newLocalListener("tcp")
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ln := newLocalListener(t, "tcp")
                defer ln.Close()
 
                cc1, err := ln.(*TCPListener).SyscallConn()

diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go
index 492333d0c85714477f038d134df11c362843eee3..6edfb67dd7dda9347ca009e7120c6a00282c556b 100644 (file)
--- a/src/net/sendfile_test.go
+++ b/src/net/sendfile_test.go
@@ -27,10 +27,7 @@ const (
 )
 
 func TestSendfile(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        errc := make(chan error, 1)
@@ -97,10 +94,7 @@ func TestSendfile(t *testing.T) {
 }
 
 func TestSendfileParts(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        errc := make(chan error, 1)
@@ -155,10 +149,7 @@ func TestSendfileParts(t *testing.T) {
 }
 
 func TestSendfileSeeked(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        const seekTo = 65 << 10
@@ -225,10 +216,7 @@ func TestSendfilePipe(t *testing.T) {
 
        t.Parallel()
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        r, w, err := os.Pipe()
@@ -317,10 +305,7 @@ func TestSendfilePipe(t *testing.T) {
 
 // Issue 43822: tests that returns EOF when conn write timeout.
 func TestSendfileOnWriteTimeoutExceeded(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        errc := make(chan error, 1)

diff --git a/src/net/server_test.go b/src/net/server_test.go
index ae1c1619edd0458d558a9b8c3bb37e5eba720172..be12c1a12d7cb4c065309dcca05932373eb8d0ae 100644 (file)
--- a/src/net/server_test.go
+++ b/src/net/server_test.go
@@ -77,10 +77,7 @@ func TestTCPServer(t *testing.T) {
                                }
                        }()
                        for i := 0; i < N; i++ {
-                               ls, err := (&streamListener{Listener: ln}).newLocalServer()
-                               if err != nil {
-                                       t.Fatal(err)
-                               }
+                               ls := (&streamListener{Listener: ln}).newLocalServer()
                                lss = append(lss, ls)
                                tpchs = append(tpchs, make(chan error, 1))
                        }
@@ -162,10 +159,7 @@ func TestUnixAndUnixpacketServer(t *testing.T) {
                        }
                }()
                for i := 0; i < N; i++ {
-                       ls, err := (&streamListener{Listener: ln}).newLocalServer()
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ls := (&streamListener{Listener: ln}).newLocalServer()
                        lss = append(lss, ls)
                        tpchs = append(tpchs, make(chan error, 1))
                }
@@ -270,10 +264,7 @@ func TestUDPServer(t *testing.T) {
                        t.Fatal(err)
                }
 
-               ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&packetListener{PacketConn: c1}).newLocalServer()
                defer ls.teardown()
                tpch := make(chan error, 1)
                handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) }
@@ -348,10 +339,7 @@ func TestUnixgramServer(t *testing.T) {
                        t.Fatal(err)
                }
 
-               ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&packetListener{PacketConn: c1}).newLocalServer()
                defer ls.teardown()
                tpch := make(chan error, 1)
                handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) }

diff --git a/src/net/splice_test.go b/src/net/splice_test.go
index 43e0b926f7a4ec00e3d1a78f2742cf68a2480b13..38d51451b63a04d7f9f4f703780b85e6c7745f26 100644 (file)
--- a/src/net/splice_test.go
+++ b/src/net/splice_test.go
@@ -46,20 +46,14 @@ type spliceTestCase struct {
 }
 
 func (tc spliceTestCase) test(t *testing.T) {
-       clientUp, serverUp, err := spliceTestSocketPair(tc.upNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientUp, serverUp := spliceTestSocketPair(t, tc.upNet)
        defer serverUp.Close()
        cleanup, err := startSpliceClient(clientUp, "w", tc.chunkSize, tc.totalSize)
        if err != nil {
                t.Fatal(err)
        }
        defer cleanup()
-       clientDown, serverDown, err := spliceTestSocketPair(tc.downNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientDown, serverDown := spliceTestSocketPair(t, tc.downNet)
        defer serverDown.Close()
        cleanup, err = startSpliceClient(clientDown, "r", tc.chunkSize, tc.totalSize)
        if err != nil {
@@ -103,15 +97,9 @@ func (tc spliceTestCase) test(t *testing.T) {
 }
 
 func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) {
-       clientUp, serverUp, err := spliceTestSocketPair(upNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientUp, serverUp := spliceTestSocketPair(t, upNet)
        defer clientUp.Close()
-       clientDown, serverDown, err := spliceTestSocketPair(downNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientDown, serverDown := spliceTestSocketPair(t, downNet)
        defer clientDown.Close()
 
        serverUp.Close()
@@ -140,7 +128,7 @@ func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) {
        }()
 
        buf := make([]byte, 3)
-       _, err = io.ReadFull(clientDown, buf)
+       _, err := io.ReadFull(clientDown, buf)
        if err != nil {
                t.Errorf("clientDown: %v", err)
        }
@@ -150,15 +138,9 @@ func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) {
 }
 
 func testSpliceIssue25985(t *testing.T, upNet, downNet string) {
-       front, err := newLocalListener(upNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       front := newLocalListener(t, upNet)
        defer front.Close()
-       back, err := newLocalListener(downNet)
-       if err != nil {
-               t.Fatal(err)
-       }
+       back := newLocalListener(t, downNet)
        defer back.Close()
 
        var wg sync.WaitGroup
@@ -210,16 +192,10 @@ func testSpliceIssue25985(t *testing.T, upNet, downNet string) {
 }
 
 func testSpliceNoUnixpacket(t *testing.T) {
-       clientUp, serverUp, err := spliceTestSocketPair("unixpacket")
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientUp, serverUp := spliceTestSocketPair(t, "unixpacket")
        defer clientUp.Close()
        defer serverUp.Close()
-       clientDown, serverDown, err := spliceTestSocketPair("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientDown, serverDown := spliceTestSocketPair(t, "tcp")
        defer clientDown.Close()
        defer serverDown.Close()
        // If splice called poll.Splice here, we'd get err == syscall.EINVAL
@@ -247,10 +223,7 @@ func testSpliceNoUnixgram(t *testing.T) {
                t.Fatal(err)
        }
        defer up.Close()
-       clientDown, serverDown, err := spliceTestSocketPair("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       clientDown, serverDown := spliceTestSocketPair(t, "tcp")
        defer clientDown.Close()
        defer serverDown.Close()
        // Analogous to testSpliceNoUnixpacket.
@@ -284,10 +257,7 @@ func (tc spliceTestCase) bench(b *testing.B) {
        // To benchmark the genericReadFrom code path, set this to false.
        useSplice := true
 
-       clientUp, serverUp, err := spliceTestSocketPair(tc.upNet)
-       if err != nil {
-               b.Fatal(err)
-       }
+       clientUp, serverUp := spliceTestSocketPair(b, tc.upNet)
        defer serverUp.Close()
 
        cleanup, err := startSpliceClient(clientUp, "w", tc.chunkSize, tc.chunkSize*b.N)
@@ -296,10 +266,7 @@ func (tc spliceTestCase) bench(b *testing.B) {
        }
        defer cleanup()
 
-       clientDown, serverDown, err := spliceTestSocketPair(tc.downNet)
-       if err != nil {
-               b.Fatal(err)
-       }
+       clientDown, serverDown := spliceTestSocketPair(b, tc.downNet)
        defer serverDown.Close()
 
        cleanup, err = startSpliceClient(clientDown, "r", tc.chunkSize, tc.chunkSize*b.N)
@@ -327,11 +294,9 @@ func (tc spliceTestCase) bench(b *testing.B) {
        }
 }
 
-func spliceTestSocketPair(net string) (client, server Conn, err error) {
-       ln, err := newLocalListener(net)
-       if err != nil {
-               return nil, nil, err
-       }
+func spliceTestSocketPair(t testing.TB, net string) (client, server Conn) {
+       t.Helper()
+       ln := newLocalListener(t, net)
        defer ln.Close()
        var cerr, serr error
        acceptDone := make(chan struct{})
@@ -345,15 +310,15 @@ func spliceTestSocketPair(net string) (client, server Conn, err error) {
                if server != nil {
                        server.Close()
                }
-               return nil, nil, cerr
+               t.Fatal(cerr)
        }
        if serr != nil {
                if client != nil {
                        client.Close()
                }
-               return nil, nil, serr
+               t.Fatal(serr)
        }
-       return client, server, nil
+       return client, server
 }
 
 func startSpliceClient(conn Conn, op string, chunkSize, totalSize int) (func(), error) {

diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go
index fdf5c330a990138decfb55349f213b30ad2fe7e6..ae65788a73dc5ea73ee11af2f29740d84b45ebda 100644 (file)
--- a/src/net/tcpsock_test.go
+++ b/src/net/tcpsock_test.go
@@ -387,10 +387,7 @@ func TestIPv6LinkLocalUnicastTCP(t *testing.T) {
                        t.Log(err)
                        continue
                }
-               ls, err := (&streamListener{Listener: ln}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&streamListener{Listener: ln}).newLocalServer()
                defer ls.teardown()
                ch := make(chan error, 1)
                handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
@@ -626,10 +623,7 @@ func TestTCPSelfConnect(t *testing.T) {
                t.Skip("known-broken test on windows")
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        var d Dialer
        c, err := d.Dial(ln.Addr().Network(), ln.Addr().String())
        if err != nil {
@@ -676,10 +670,7 @@ func TestTCPBig(t *testing.T) {
 
        for _, writev := range []bool{false, true} {
                t.Run(fmt.Sprintf("writev=%v", writev), func(t *testing.T) {
-                       ln, err := newLocalListener("tcp")
-                       if err != nil {
-                               t.Fatal(err)
-                       }
+                       ln := newLocalListener(t, "tcp")
                        defer ln.Close()
 
                        x := int(1 << 30)
@@ -723,10 +714,7 @@ func TestTCPBig(t *testing.T) {
 }
 
 func TestCopyPipeIntoTCP(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        errc := make(chan error, 1)
@@ -794,10 +782,7 @@ func TestCopyPipeIntoTCP(t *testing.T) {
 }
 
 func BenchmarkSetReadDeadline(b *testing.B) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               b.Fatal(err)
-       }
+       ln := newLocalListener(b, "tcp")
        defer ln.Close()
        var serv Conn
        done := make(chan error)

diff --git a/src/net/tcpsock_unix_test.go b/src/net/tcpsock_unix_test.go
index b1f2876d4ed82b7bb60f41f45098f71f0262a215..b14670bc6728bef8c3cd2b63589a1f280fd0234d 100644 (file)
--- a/src/net/tcpsock_unix_test.go
+++ b/src/net/tcpsock_unix_test.go
@@ -22,10 +22,7 @@ func TestTCPSpuriousConnSetupCompletion(t *testing.T) {
                t.Skip("skipping in short mode")
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        var wg sync.WaitGroup
        wg.Add(1)
        go func(ln Listener) {

diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go
index 515aa07ec3f2b5a392b51d5b9c9ea36b894081b3..cd6b95374795625d38c6e34fb40f1a479847577a 100644 (file)
--- a/src/net/timeout_test.go
+++ b/src/net/timeout_test.go
@@ -93,10 +93,7 @@ func TestDialTimeout(t *testing.T) {
 }
 
 func TestDialTimeoutMaxDuration(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer func() {
                if err := ln.Close(); err != nil {
                        t.Error(err)
@@ -147,10 +144,7 @@ func TestAcceptTimeout(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        var wg sync.WaitGroup
@@ -203,10 +197,7 @@ func TestAcceptTimeoutMustReturn(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        max := time.NewTimer(time.Second)
@@ -249,10 +240,7 @@ func TestAcceptTimeoutMustNotReturn(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        max := time.NewTimer(100 * time.Millisecond)
@@ -302,10 +290,7 @@ func TestReadTimeout(t *testing.T) {
                c.Write([]byte("READ TIMEOUT TEST"))
                defer c.Close()
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -354,10 +339,7 @@ func TestReadTimeoutMustNotReturn(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -421,10 +403,7 @@ func TestReadFromTimeout(t *testing.T) {
                        c.WriteTo([]byte("READFROM TIMEOUT TEST"), dst)
                }
        }
-       ls, err := newLocalPacketServer("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalPacketServer(t, "udp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -484,10 +463,7 @@ var writeTimeoutTests = []struct {
 func TestWriteTimeout(t *testing.T) {
        t.Parallel()
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        for i, tt := range writeTimeoutTests {
@@ -532,10 +508,7 @@ func TestWriteTimeoutMustNotReturn(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -598,10 +571,7 @@ var writeToTimeoutTests = []struct {
 func TestWriteToTimeout(t *testing.T) {
        t.Parallel()
 
-       c1, err := newLocalPacketListener("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c1 := newLocalPacketListener(t, "udp")
        defer c1.Close()
 
        host, _, err := SplitHostPort(c1.LocalAddr().String())
@@ -687,10 +657,7 @@ func nextTimeout(actual time.Duration) (next time.Duration, ok bool) {
 }
 
 func TestReadTimeoutFluctuation(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -746,10 +713,7 @@ func TestReadTimeoutFluctuation(t *testing.T) {
 }
 
 func TestReadFromTimeoutFluctuation(t *testing.T) {
-       c1, err := newLocalPacketListener("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c1 := newLocalPacketListener(t, "udp")
        defer c1.Close()
 
        c2, err := Dial(c1.LocalAddr().Network(), c1.LocalAddr().String())
@@ -810,10 +774,7 @@ func TestWriteTimeoutFluctuation(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -938,10 +899,7 @@ func testVariousDeadlines(t *testing.T) {
                        c.Close()
                }
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -1073,10 +1031,7 @@ func TestReadWriteProlongedTimeout(t *testing.T) {
                }()
                wg.Wait()
        }
-       ls, err := newLocalServer("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ls := newLocalServer(t, "tcp")
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
@@ -1103,10 +1058,7 @@ func TestReadWriteDeadlineRace(t *testing.T) {
                N = 50
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        c, err := Dial(ln.Addr().Network(), ln.Addr().String())
@@ -1156,10 +1108,7 @@ func TestReadWriteDeadlineRace(t *testing.T) {
 
 // Issue 35367.
 func TestConcurrentSetDeadline(t *testing.T) {
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        const goroutines = 8
@@ -1168,6 +1117,7 @@ func TestConcurrentSetDeadline(t *testing.T) {
 
        var c [conns]Conn
        for i := 0; i < conns; i++ {
+               var err error
                c[i], err = Dial(ln.Addr().Network(), ln.Addr().String())
                if err != nil {
                        t.Fatal(err)

diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 8ccdb365abace993967e5b95984297f349a03102..6f82554e56d0d4e66a834ff27bb11cc88cd5421e 100644 (file)
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -285,10 +285,7 @@ func TestIPv6LinkLocalUnicastUDP(t *testing.T) {
                        t.Log(err)
                        continue
                }
-               ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&packetListener{PacketConn: c1}).newLocalServer()
                defer ls.teardown()
                ch := make(chan error, 1)
                handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, ch) }
@@ -333,10 +330,7 @@ func TestUDPZeroBytePayload(t *testing.T) {
                testenv.SkipFlaky(t, 29225)
        }
 
-       c, err := newLocalPacketListener("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c := newLocalPacketListener(t, "udp")
        defer c.Close()
 
        for _, genericRead := range []bool{false, true} {
@@ -369,10 +363,7 @@ func TestUDPZeroByteBuffer(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       c, err := newLocalPacketListener("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c := newLocalPacketListener(t, "udp")
        defer c.Close()
 
        b := []byte("UDP ZERO BYTE BUFFER TEST")
@@ -406,10 +397,7 @@ func TestUDPReadSizeError(t *testing.T) {
                t.Skipf("not supported on %s", runtime.GOOS)
        }
 
-       c1, err := newLocalPacketListener("udp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c1 := newLocalPacketListener(t, "udp")
        defer c1.Close()
 
        c2, err := Dial("udp", c1.LocalAddr().String())

diff --git a/src/net/unixsock_test.go b/src/net/unixsock_test.go
index a75578235f8e7c147fe27988ae1003253dd10d38..5ad20a0151665ba3aeced105b27180da8528ef27 100644 (file)
--- a/src/net/unixsock_test.go
+++ b/src/net/unixsock_test.go
@@ -76,10 +76,7 @@ func TestUnixgramZeroBytePayload(t *testing.T) {
                t.Skip("unixgram test")
        }
 
-       c1, err := newLocalPacketListener("unixgram")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c1 := newLocalPacketListener(t, "unixgram")
        defer os.Remove(c1.LocalAddr().String())
        defer c1.Close()
 
@@ -126,10 +123,7 @@ func TestUnixgramZeroByteBuffer(t *testing.T) {
        // issue 4352: Recvfrom failed with "address family not
        // supported by protocol family" if zero-length buffer provided
 
-       c1, err := newLocalPacketListener("unixgram")
-       if err != nil {
-               t.Fatal(err)
-       }
+       c1 := newLocalPacketListener(t, "unixgram")
        defer os.Remove(c1.LocalAddr().String())
        defer c1.Close()
 
@@ -259,10 +253,7 @@ func TestUnixConnLocalAndRemoteNames(t *testing.T) {
                if err != nil {
                        t.Fatal(err)
                }
-               ls, err := (&streamListener{Listener: ln}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&streamListener{Listener: ln}).newLocalServer()
                defer ls.teardown()
                if err := ls.buildup(handler); err != nil {
                        t.Fatal(err)

diff --git a/src/net/unixsock_windows_test.go b/src/net/unixsock_windows_test.go
index dedd761c56744657ba5678e99c002337047f0254..e847a20de00f09b86df05f193c6cdddfc836c0d3 100644 (file)
--- a/src/net/unixsock_windows_test.go
+++ b/src/net/unixsock_windows_test.go
@@ -56,10 +56,7 @@ func TestUnixConnLocalWindows(t *testing.T) {
                if err != nil {
                        t.Fatal(err)
                }
-               ls, err := (&streamListener{Listener: ln}).newLocalServer()
-               if err != nil {
-                       t.Fatal(err)
-               }
+               ls := (&streamListener{Listener: ln}).newLocalServer()
                defer ls.teardown()
                if err := ls.buildup(handler); err != nil {
                        t.Fatal(err)

diff --git a/src/net/writev_test.go b/src/net/writev_test.go
index b75229586208693cf1773a30b815810185968b82..18795a457ac1f6a4066fc6b72a827f282c43820d 100644 (file)
--- a/src/net/writev_test.go
+++ b/src/net/writev_test.go
@@ -186,10 +186,7 @@ func TestWritevError(t *testing.T) {
                t.Skipf("skipping the test: windows does not have problem sending large chunks of data")
        }
 
-       ln, err := newLocalListener("tcp")
-       if err != nil {
-               t.Fatal(err)
-       }
+       ln := newLocalListener(t, "tcp")
        defer ln.Close()
 
        ch := make(chan Conn, 1)