[52/77] Use scalar_int_mode in extract/store_bit_field

[official-gcc.git] / libgo / go / net / dial_test.go

// Copyright 2011 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

import (
        "bufio"
        "context"
        "internal/testenv"
        "io"
        "net/internal/socktest"
        "runtime"
        "sync"
        "testing"
        "time"
)

var prohibitionaryDialArgTests = []struct {
        network string
        address string
}{
        {"tcp6", "127.0.0.1"},
        {"tcp6", "::ffff:127.0.0.1"},
}

func TestProhibitionaryDialArg(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        switch runtime.GOOS {
        case "plan9":
                t.Skipf("not supported on %s", runtime.GOOS)
        }
        if !supportsIPv4map {
                t.Skip("mapping ipv4 address inside ipv6 address not supported")
        }

        ln, err := Listen("tcp", "[::]:0")
        if err != nil {
                t.Fatal(err)
        }
        defer ln.Close()

        _, port, err := SplitHostPort(ln.Addr().String())
        if err != nil {
                t.Fatal(err)
        }

        for i, tt := range prohibitionaryDialArgTests {
                c, err := Dial(tt.network, JoinHostPort(tt.address, port))
                if err == nil {
                        c.Close()
                        t.Errorf("#%d: %v", i, err)
                }
        }
}

func TestDialLocal(t *testing.T) {
        ln, err := newLocalListener("tcp")
        if err != nil {
                t.Fatal(err)
        }
        defer ln.Close()
        _, port, err := SplitHostPort(ln.Addr().String())
        if err != nil {
                t.Fatal(err)
        }
        c, err := Dial("tcp", JoinHostPort("", port))
        if err != nil {
                t.Fatal(err)
        }
        c.Close()
}

func TestDialTimeoutFDLeak(t *testing.T) {
        switch runtime.GOOS {
        case "plan9":
                t.Skipf("%s does not have full support of socktest", runtime.GOOS)
        case "openbsd":
                testenv.SkipFlaky(t, 15157)
        }

        const T = 100 * time.Millisecond

        switch runtime.GOOS {
        case "plan9", "windows":
                origTestHookDialChannel := testHookDialChannel
                testHookDialChannel = func() { time.Sleep(2 * T) }
                defer func() { testHookDialChannel = origTestHookDialChannel }()
                if runtime.GOOS == "plan9" {
                        break
                }
                fallthrough
        default:
                sw.Set(socktest.FilterConnect, func(so *socktest.Status) (socktest.AfterFilter, error) {
                        time.Sleep(2 * T)
                        return nil, errTimeout
                })
                defer sw.Set(socktest.FilterConnect, nil)
        }

        // Avoid tracking open-close jitterbugs between netFD and
        // socket that leads to confusion of information inside
        // socktest.Switch.
        // It may happen when the Dial call bumps against TCP
        // simultaneous open. See selfConnect in tcpsock_posix.go.
        defer func() { sw.Set(socktest.FilterClose, nil) }()
        var mu sync.Mutex
        var attempts int
        sw.Set(socktest.FilterClose, func(so *socktest.Status) (socktest.AfterFilter, error) {
                mu.Lock()
                attempts++
                mu.Unlock()
                return nil, nil
        })

        const N = 100
        var wg sync.WaitGroup
        wg.Add(N)
        for i := 0; i < N; i++ {
                go func() {
                        defer wg.Done()
                        // This dial never starts to send any SYN
                        // segment because of above socket filter and
                        // test hook.
                        c, err := DialTimeout("tcp", "127.0.0.1:0", T)
                        if err == nil {
                                t.Errorf("unexpectedly established: tcp:%s->%s", c.LocalAddr(), c.RemoteAddr())
                                c.Close()
                        }
                }()
        }
        wg.Wait()
        if attempts < N {
                t.Errorf("got %d; want >= %d", attempts, N)
        }
}

func TestDialerDualStackFDLeak(t *testing.T) {
        switch runtime.GOOS {
        case "plan9":
                t.Skipf("%s does not have full support of socktest", runtime.GOOS)
        case "windows":
                t.Skipf("not implemented a way to cancel dial racers in TCP SYN-SENT state on %s", runtime.GOOS)
        case "openbsd":
                testenv.SkipFlaky(t, 15157)
        }
        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        closedPortDelay, expectClosedPortDelay := dialClosedPort()
        if closedPortDelay > expectClosedPortDelay {
                t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
        }

        before := sw.Sockets()
        origTestHookLookupIP := testHookLookupIP
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupLocalhost
        handler := func(dss *dualStackServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        c.Close()
                }
        }
        dss, err := newDualStackServer()
        if err != nil {
                t.Fatal(err)
        }
        if err := dss.buildup(handler); err != nil {
                dss.teardown()
                t.Fatal(err)
        }

        const N = 10
        var wg sync.WaitGroup
        wg.Add(N)
        d := &Dialer{DualStack: true, Timeout: 100*time.Millisecond + closedPortDelay}
        for i := 0; i < N; i++ {
                go func() {
                        defer wg.Done()
                        c, err := d.Dial("tcp", JoinHostPort("localhost", dss.port))
                        if err != nil {
                                t.Error(err)
                                return
                        }
                        c.Close()
                }()
        }
        wg.Wait()
        dss.teardown()
        after := sw.Sockets()
        if len(after) != len(before) {
                t.Errorf("got %d; want %d", len(after), len(before))
        }
}

// Define a pair of blackholed (IPv4, IPv6) addresses, for which dialTCP is
// expected to hang until the timeout elapses. These addresses are reserved
// for benchmarking by RFC 6890.
const (
        slowDst4 = "198.18.0.254"
        slowDst6 = "2001:2::254"
)

// In some environments, the slow IPs may be explicitly unreachable, and fail
// more quickly than expected. This test hook prevents dialTCP from returning
// before the deadline.
func slowDialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
        c, err := doDialTCP(ctx, net, laddr, raddr)
        if ParseIP(slowDst4).Equal(raddr.IP) || ParseIP(slowDst6).Equal(raddr.IP) {
                // Wait for the deadline, or indefinitely if none exists.
                <-ctx.Done()
        }
        return c, err
}

func dialClosedPort() (actual, expected time.Duration) {
        // Estimate the expected time for this platform.
        // On Windows, dialing a closed port takes roughly 1 second,
        // but other platforms should be instantaneous.
        if runtime.GOOS == "windows" {
                expected = 1500 * time.Millisecond
        } else {
                expected = 95 * time.Millisecond
        }

        l, err := Listen("tcp", "127.0.0.1:0")
        if err != nil {
                return 999 * time.Hour, expected
        }
        addr := l.Addr().String()
        l.Close()
        // On OpenBSD, interference from TestSelfConnect is mysteriously
        // causing the first attempt to hang for a few seconds, so we throw
        // away the first result and keep the second.
        for i := 1; ; i++ {
                startTime := time.Now()
                c, err := Dial("tcp", addr)
                if err == nil {
                        c.Close()
                }
                elapsed := time.Now().Sub(startTime)
                if i == 2 {
                        return elapsed, expected
                }
        }
}

func TestDialParallel(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        closedPortDelay, expectClosedPortDelay := dialClosedPort()
        if closedPortDelay > expectClosedPortDelay {
                t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
        }

        const instant time.Duration = 0
        const fallbackDelay = 200 * time.Millisecond

        // Some cases will run quickly when "connection refused" is fast,
        // or trigger the fallbackDelay on Windows. This value holds the
        // lesser of the two delays.
        var closedPortOrFallbackDelay time.Duration
        if closedPortDelay < fallbackDelay {
                closedPortOrFallbackDelay = closedPortDelay
        } else {
                closedPortOrFallbackDelay = fallbackDelay
        }

        origTestHookDialTCP := testHookDialTCP
        defer func() { testHookDialTCP = origTestHookDialTCP }()
        testHookDialTCP = slowDialTCP

        nCopies := func(s string, n int) []string {
                out := make([]string, n)
                for i := 0; i < n; i++ {
                        out[i] = s
                }
                return out
        }

        var testCases = []struct {
                primaries       []string
                fallbacks       []string
                teardownNetwork string
                expectOk        bool
                expectElapsed   time.Duration
        }{
                // These should just work on the first try.
                {[]string{"127.0.0.1"}, []string{}, "", true, instant},
                {[]string{"::1"}, []string{}, "", true, instant},
                {[]string{"127.0.0.1", "::1"}, []string{slowDst6}, "tcp6", true, instant},
                {[]string{"::1", "127.0.0.1"}, []string{slowDst4}, "tcp4", true, instant},
                // Primary is slow; fallback should kick in.
                {[]string{slowDst4}, []string{"::1"}, "", true, fallbackDelay},
                // Skip a "connection refused" in the primary thread.
                {[]string{"127.0.0.1", "::1"}, []string{}, "tcp4", true, closedPortDelay},
                {[]string{"::1", "127.0.0.1"}, []string{}, "tcp6", true, closedPortDelay},
                // Skip a "connection refused" in the fallback thread.
                {[]string{slowDst4, slowDst6}, []string{"::1", "127.0.0.1"}, "tcp6", true, fallbackDelay + closedPortDelay},
                // Primary refused, fallback without delay.
                {[]string{"127.0.0.1"}, []string{"::1"}, "tcp4", true, closedPortOrFallbackDelay},
                {[]string{"::1"}, []string{"127.0.0.1"}, "tcp6", true, closedPortOrFallbackDelay},
                // Everything is refused.
                {[]string{"127.0.0.1"}, []string{}, "tcp4", false, closedPortDelay},
                // Nothing to do; fail instantly.
                {[]string{}, []string{}, "", false, instant},
                // Connecting to tons of addresses should not trip the deadline.
                {nCopies("::1", 1000), []string{}, "", true, instant},
        }

        handler := func(dss *dualStackServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        c.Close()
                }
        }

        // Convert a list of IP strings into TCPAddrs.
        makeAddrs := func(ips []string, port string) addrList {
                var out addrList
                for _, ip := range ips {
                        addr, err := ResolveTCPAddr("tcp", JoinHostPort(ip, port))
                        if err != nil {
                                t.Fatal(err)
                        }
                        out = append(out, addr)
                }
                return out
        }

        for i, tt := range testCases {
                dss, err := newDualStackServer()
                if err != nil {
                        t.Fatal(err)
                }
                defer dss.teardown()
                if err := dss.buildup(handler); err != nil {
                        t.Fatal(err)
                }
                if tt.teardownNetwork != "" {
                        // Destroy one of the listening sockets, creating an unreachable port.
                        dss.teardownNetwork(tt.teardownNetwork)
                }

                primaries := makeAddrs(tt.primaries, dss.port)
                fallbacks := makeAddrs(tt.fallbacks, dss.port)
                d := Dialer{
                        FallbackDelay: fallbackDelay,
                }
                startTime := time.Now()
                dp := &dialParam{
                        Dialer:  d,
                        network: "tcp",
                        address: "?",
                }
                c, err := dialParallel(context.Background(), dp, primaries, fallbacks)
                elapsed := time.Since(startTime)

                if c != nil {
                        c.Close()
                }

                if tt.expectOk && err != nil {
                        t.Errorf("#%d: got %v; want nil", i, err)
                } else if !tt.expectOk && err == nil {
                        t.Errorf("#%d: got nil; want non-nil", i)
                }

                expectElapsedMin := tt.expectElapsed - 95*time.Millisecond
                expectElapsedMax := tt.expectElapsed + 95*time.Millisecond
                if !(elapsed >= expectElapsedMin) {
                        t.Errorf("#%d: got %v; want >= %v", i, elapsed, expectElapsedMin)
                } else if !(elapsed <= expectElapsedMax) {
                        t.Errorf("#%d: got %v; want <= %v", i, elapsed, expectElapsedMax)
                }

                // Repeat each case, ensuring that it can be canceled quickly.
                ctx, cancel := context.WithCancel(context.Background())
                var wg sync.WaitGroup
                wg.Add(1)
                go func() {
                        time.Sleep(5 * time.Millisecond)
                        cancel()
                        wg.Done()
                }()
                startTime = time.Now()
                c, err = dialParallel(ctx, dp, primaries, fallbacks)
                if c != nil {
                        c.Close()
                }
                elapsed = time.Now().Sub(startTime)
                if elapsed > 100*time.Millisecond {
                        t.Errorf("#%d (cancel): got %v; want <= 100ms", i, elapsed)
                }
                wg.Wait()
        }
}

func lookupSlowFast(ctx context.Context, fn func(context.Context, string) ([]IPAddr, error), host string) ([]IPAddr, error) {
        switch host {
        case "slow6loopback4":
                // Returns a slow IPv6 address, and a local IPv4 address.
                return []IPAddr{
                        {IP: ParseIP(slowDst6)},
                        {IP: ParseIP("127.0.0.1")},
                }, nil
        default:
                return fn(ctx, host)
        }
}

func TestDialerFallbackDelay(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        origTestHookLookupIP := testHookLookupIP
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupSlowFast

        origTestHookDialTCP := testHookDialTCP
        defer func() { testHookDialTCP = origTestHookDialTCP }()
        testHookDialTCP = slowDialTCP

        var testCases = []struct {
                dualstack     bool
                delay         time.Duration
                expectElapsed time.Duration
        }{
                // Use a very brief delay, which should fallback immediately.
                {true, 1 * time.Nanosecond, 0},
                // Use a 200ms explicit timeout.
                {true, 200 * time.Millisecond, 200 * time.Millisecond},
                // The default is 300ms.
                {true, 0, 300 * time.Millisecond},
        }

        handler := func(dss *dualStackServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        c.Close()
                }
        }
        dss, err := newDualStackServer()
        if err != nil {
                t.Fatal(err)
        }
        defer dss.teardown()
        if err := dss.buildup(handler); err != nil {
                t.Fatal(err)
        }

        for i, tt := range testCases {
                d := &Dialer{DualStack: tt.dualstack, FallbackDelay: tt.delay}

                startTime := time.Now()
                c, err := d.Dial("tcp", JoinHostPort("slow6loopback4", dss.port))
                elapsed := time.Now().Sub(startTime)
                if err == nil {
                        c.Close()
                } else if tt.dualstack {
                        t.Error(err)
                }
                expectMin := tt.expectElapsed - 1*time.Millisecond
                expectMax := tt.expectElapsed + 95*time.Millisecond
                if !(elapsed >= expectMin) {
                        t.Errorf("#%d: got %v; want >= %v", i, elapsed, expectMin)
                }
                if !(elapsed <= expectMax) {
                        t.Errorf("#%d: got %v; want <= %v", i, elapsed, expectMax)
                }
        }
}

func TestDialParallelSpuriousConnection(t *testing.T) {
        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        var wg sync.WaitGroup
        wg.Add(2)
        handler := func(dss *dualStackServer, ln Listener) {
                // Accept one connection per address.
                c, err := ln.Accept()
                if err != nil {
                        t.Fatal(err)
                }
                // The client should close itself, without sending data.
                c.SetReadDeadline(time.Now().Add(1 * time.Second))
                var b [1]byte
                if _, err := c.Read(b[:]); err != io.EOF {
                        t.Errorf("got %v; want %v", err, io.EOF)
                }
                c.Close()
                wg.Done()
        }
        dss, err := newDualStackServer()
        if err != nil {
                t.Fatal(err)
        }
        defer dss.teardown()
        if err := dss.buildup(handler); err != nil {
                t.Fatal(err)
        }

        const fallbackDelay = 100 * time.Millisecond

        origTestHookDialTCP := testHookDialTCP
        defer func() { testHookDialTCP = origTestHookDialTCP }()
        testHookDialTCP = func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
                // Sleep long enough for Happy Eyeballs to kick in, and inhibit cancelation.
                // This forces dialParallel to juggle two successful connections.
                time.Sleep(fallbackDelay * 2)

                // Now ignore the provided context (which will be canceled) and use a
                // different one to make sure this completes with a valid connection,
                // which we hope to be closed below:
                return doDialTCP(context.Background(), net, laddr, raddr)
        }

        d := Dialer{
                FallbackDelay: fallbackDelay,
        }
        dp := &dialParam{
                Dialer:  d,
                network: "tcp",
                address: "?",
        }

        makeAddr := func(ip string) addrList {
                addr, err := ResolveTCPAddr("tcp", JoinHostPort(ip, dss.port))
                if err != nil {
                        t.Fatal(err)
                }
                return addrList{addr}
        }

        // dialParallel returns one connection (and closes the other.)
        c, err := dialParallel(context.Background(), dp, makeAddr("127.0.0.1"), makeAddr("::1"))
        if err != nil {
                t.Fatal(err)
        }
        c.Close()

        // The server should've seen both connections.
        wg.Wait()
}

func TestDialerPartialDeadline(t *testing.T) {
        now := time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC)
        var testCases = []struct {
                now            time.Time
                deadline       time.Time
                addrs          int
                expectDeadline time.Time
                expectErr      error
        }{
                // Regular division.
                {now, now.Add(12 * time.Second), 1, now.Add(12 * time.Second), nil},
                {now, now.Add(12 * time.Second), 2, now.Add(6 * time.Second), nil},
                {now, now.Add(12 * time.Second), 3, now.Add(4 * time.Second), nil},
                // Bump against the 2-second sane minimum.
                {now, now.Add(12 * time.Second), 999, now.Add(2 * time.Second), nil},
                // Total available is now below the sane minimum.
                {now, now.Add(1900 * time.Millisecond), 999, now.Add(1900 * time.Millisecond), nil},
                // Null deadline.
                {now, noDeadline, 1, noDeadline, nil},
                // Step the clock forward and cross the deadline.
                {now.Add(-1 * time.Millisecond), now, 1, now, nil},
                {now.Add(0 * time.Millisecond), now, 1, noDeadline, errTimeout},
                {now.Add(1 * time.Millisecond), now, 1, noDeadline, errTimeout},
        }
        for i, tt := range testCases {
                deadline, err := partialDeadline(tt.now, tt.deadline, tt.addrs)
                if err != tt.expectErr {
                        t.Errorf("#%d: got %v; want %v", i, err, tt.expectErr)
                }
                if deadline != tt.expectDeadline {
                        t.Errorf("#%d: got %v; want %v", i, deadline, tt.expectDeadline)
                }
        }
}

func TestDialerLocalAddr(t *testing.T) {
        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        type test struct {
                network, raddr string
                laddr          Addr
                error
        }
        var tests = []test{
                {"tcp4", "127.0.0.1", nil, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{}, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, &AddrError{Err: "some error"}},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, nil},
                {"tcp4", "127.0.0.1", &TCPAddr{IP: IPv6loopback}, errNoSuitableAddress},
                {"tcp4", "127.0.0.1", &UDPAddr{}, &AddrError{Err: "some error"}},
                {"tcp4", "127.0.0.1", &UnixAddr{}, &AddrError{Err: "some error"}},

                {"tcp6", "::1", nil, nil},
                {"tcp6", "::1", &TCPAddr{}, nil},
                {"tcp6", "::1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
                {"tcp6", "::1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
                {"tcp6", "::1", &TCPAddr{IP: ParseIP("::")}, nil},
                {"tcp6", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, errNoSuitableAddress},
                {"tcp6", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, errNoSuitableAddress},
                {"tcp6", "::1", &TCPAddr{IP: IPv6loopback}, nil},
                {"tcp6", "::1", &UDPAddr{}, &AddrError{Err: "some error"}},
                {"tcp6", "::1", &UnixAddr{}, &AddrError{Err: "some error"}},

                {"tcp", "127.0.0.1", nil, nil},
                {"tcp", "127.0.0.1", &TCPAddr{}, nil},
                {"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
                {"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
                {"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, nil},
                {"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, nil},
                {"tcp", "127.0.0.1", &TCPAddr{IP: IPv6loopback}, errNoSuitableAddress},
                {"tcp", "127.0.0.1", &UDPAddr{}, &AddrError{Err: "some error"}},
                {"tcp", "127.0.0.1", &UnixAddr{}, &AddrError{Err: "some error"}},

                {"tcp", "::1", nil, nil},
                {"tcp", "::1", &TCPAddr{}, nil},
                {"tcp", "::1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
                {"tcp", "::1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
                {"tcp", "::1", &TCPAddr{IP: ParseIP("::")}, nil},
                {"tcp", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, errNoSuitableAddress},
                {"tcp", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, errNoSuitableAddress},
                {"tcp", "::1", &TCPAddr{IP: IPv6loopback}, nil},
                {"tcp", "::1", &UDPAddr{}, &AddrError{Err: "some error"}},
                {"tcp", "::1", &UnixAddr{}, &AddrError{Err: "some error"}},
        }

        if supportsIPv4map {
                tests = append(tests, test{
                        "tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, nil,
                })
        } else {
                tests = append(tests, test{
                        "tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, &AddrError{Err: "some error"},
                })
        }

        origTestHookLookupIP := testHookLookupIP
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupLocalhost
        handler := func(ls *localServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        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)
                }
                defer lss[i].teardown()
                if err := lss[i].buildup(handler); err != nil {
                        t.Fatal(err)
                }
        }

        for _, tt := range tests {
                d := &Dialer{LocalAddr: tt.laddr}
                var addr string
                ip := ParseIP(tt.raddr)
                if ip.To4() != nil {
                        addr = lss[0].Listener.Addr().String()
                }
                if ip.To16() != nil && ip.To4() == nil {
                        addr = lss[1].Listener.Addr().String()
                }
                c, err := d.Dial(tt.network, addr)
                if err == nil && tt.error != nil || err != nil && tt.error == nil {
                        t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error)
                }
                if err != nil {
                        if perr := parseDialError(err); perr != nil {
                                t.Error(perr)
                        }
                        continue
                }
                c.Close()
        }
}

func TestDialerDualStack(t *testing.T) {
        // This test is known to be flaky. Don't frighten regular
        // users about it; only fail on the build dashboard.
        if testenv.Builder() == "" {
                testenv.SkipFlaky(t, 13324)
        }
        if !supportsIPv4 || !supportsIPv6 {
                t.Skip("both IPv4 and IPv6 are required")
        }

        closedPortDelay, expectClosedPortDelay := dialClosedPort()
        if closedPortDelay > expectClosedPortDelay {
                t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
        }

        origTestHookLookupIP := testHookLookupIP
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupLocalhost
        handler := func(dss *dualStackServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        c.Close()
                }
        }

        var timeout = 150*time.Millisecond + closedPortDelay
        for _, dualstack := range []bool{false, true} {
                dss, err := newDualStackServer()
                if err != nil {
                        t.Fatal(err)
                }
                defer dss.teardown()
                if err := dss.buildup(handler); err != nil {
                        t.Fatal(err)
                }

                d := &Dialer{DualStack: dualstack, Timeout: timeout}
                for range dss.lns {
                        c, err := d.Dial("tcp", JoinHostPort("localhost", dss.port))
                        if err != nil {
                                t.Error(err)
                                continue
                        }
                        switch addr := c.LocalAddr().(*TCPAddr); {
                        case addr.IP.To4() != nil:
                                dss.teardownNetwork("tcp4")
                        case addr.IP.To16() != nil && addr.IP.To4() == nil:
                                dss.teardownNetwork("tcp6")
                        }
                        c.Close()
                }
        }
}

func TestDialerKeepAlive(t *testing.T) {
        handler := func(ls *localServer, ln Listener) {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                return
                        }
                        c.Close()
                }
        }
        ls, err := newLocalServer("tcp")
        if err != nil {
                t.Fatal(err)
        }
        defer ls.teardown()
        if err := ls.buildup(handler); err != nil {
                t.Fatal(err)
        }
        defer func() { testHookSetKeepAlive = func() {} }()

        for _, keepAlive := range []bool{false, true} {
                got := false
                testHookSetKeepAlive = func() { got = true }
                var d Dialer
                if keepAlive {
                        d.KeepAlive = 30 * time.Second
                }
                c, err := d.Dial("tcp", ls.Listener.Addr().String())
                if err != nil {
                        t.Fatal(err)
                }
                c.Close()
                if got != keepAlive {
                        t.Errorf("Dialer.KeepAlive = %v: SetKeepAlive called = %v, want %v", d.KeepAlive, got, !got)
                }
        }
}

func TestDialCancel(t *testing.T) {
        switch testenv.Builder() {
        case "linux-arm64-buildlet":
                t.Skip("skipping on linux-arm64-buildlet; incompatible network config? issue 15191")
        case "":
                testenv.MustHaveExternalNetwork(t)
        }

        if runtime.GOOS == "nacl" {
                // nacl doesn't have external network access.
                t.Skipf("skipping on %s", runtime.GOOS)
        }

        blackholeIPPort := JoinHostPort(slowDst4, "1234")
        if !supportsIPv4 {
                blackholeIPPort = JoinHostPort(slowDst6, "1234")
        }

        ticker := time.NewTicker(10 * time.Millisecond)
        defer ticker.Stop()

        const cancelTick = 5 // the timer tick we cancel the dial at
        const timeoutTick = 100

        var d Dialer
        cancel := make(chan struct{})
        d.Cancel = cancel
        errc := make(chan error, 1)
        connc := make(chan Conn, 1)
        go func() {
                if c, err := d.Dial("tcp", blackholeIPPort); err != nil {
                        errc <- err
                } else {
                        connc <- c
                }
        }()
        ticks := 0
        for {
                select {
                case <-ticker.C:
                        ticks++
                        if ticks == cancelTick {
                                close(cancel)
                        }
                        if ticks == timeoutTick {
                                t.Fatal("timeout waiting for dial to fail")
                        }
                case c := <-connc:
                        c.Close()
                        t.Fatal("unexpected successful connection")
                case err := <-errc:
                        if perr := parseDialError(err); perr != nil {
                                t.Error(perr)
                        }
                        if ticks < cancelTick {
                                t.Fatalf("dial error after %d ticks (%d before cancel sent): %v",
                                        ticks, cancelTick-ticks, err)
                        }
                        if oe, ok := err.(*OpError); !ok || oe.Err != errCanceled {
                                t.Fatalf("dial error = %v (%T); want OpError with Err == errCanceled", err, err)
                        }
                        return // success.
                }
        }
}

func TestCancelAfterDial(t *testing.T) {
        if testing.Short() {
                t.Skip("avoiding time.Sleep")
        }

        ln, err := newLocalListener("tcp")
        if err != nil {
                t.Fatal(err)
        }

        var wg sync.WaitGroup
        wg.Add(1)
        defer func() {
                ln.Close()
                wg.Wait()
        }()

        // Echo back the first line of each incoming connection.
        go func() {
                for {
                        c, err := ln.Accept()
                        if err != nil {
                                break
                        }
                        rb := bufio.NewReader(c)
                        line, err := rb.ReadString('\n')
                        if err != nil {
                                t.Error(err)
                                c.Close()
                                continue
                        }
                        if _, err := c.Write([]byte(line)); err != nil {
                                t.Error(err)
                        }
                        c.Close()
                }
                wg.Done()
        }()

        try := func() {
                cancel := make(chan struct{})
                d := &Dialer{Cancel: cancel}
                c, err := d.Dial("tcp", ln.Addr().String())

                // Immediately after dialing, request cancelation and sleep.
                // Before Issue 15078 was fixed, this would cause subsequent operations
                // to fail with an i/o timeout roughly 50% of the time.
                close(cancel)
                time.Sleep(10 * time.Millisecond)

                if err != nil {
                        t.Fatal(err)
                }
                defer c.Close()

                // Send some data to confirm that the connection is still alive.
                const message = "echo!\n"
                if _, err := c.Write([]byte(message)); err != nil {
                        t.Fatal(err)
                }

                // The server should echo the line, and close the connection.
                rb := bufio.NewReader(c)
                line, err := rb.ReadString('\n')
                if err != nil {
                        t.Fatal(err)
                }
                if line != message {
                        t.Errorf("got %q; want %q", line, message)
                }
                if _, err := rb.ReadByte(); err != io.EOF {
                        t.Errorf("got %v; want %v", err, io.EOF)
                }
        }

        // This bug manifested about 50% of the time, so try it a few times.
        for i := 0; i < 10; i++ {
                try()
        }
}