Gecko [ 167.86.127.34 ]

Name	Size	Permission
http	[ DIR ]	drwxr-xr-x
internal	[ DIR ]	drwxr-xr-x
mail	[ DIR ]	drwxr-xr-x
rpc	[ DIR ]	drwxr-xr-x
smtp	[ DIR ]	drwxr-xr-x
testdata	[ DIR ]	drwxr-xr-x
textproto	[ DIR ]	drwxr-xr-x
url	[ DIR ]	drwxr-xr-x
addrselect.go	9.51 KB	-rw-r--r--
addrselect_test.go	6.2 KB	-rw-r--r--
cgo_aix.go	578 B	-rw-r--r--
cgo_android.go	268 B	-rw-r--r--
cgo_bsd.go	348 B	-rw-r--r--
cgo_linux.go	635 B	-rw-r--r--
cgo_netbsd.go	272 B	-rw-r--r--
cgo_openbsd.go	272 B	-rw-r--r--
cgo_resnew.go	577 B	-rw-r--r--
cgo_resold.go	571 B	-rw-r--r--
cgo_socknew.go	748 B	-rw-r--r--
cgo_sockold.go	838 B	-rw-r--r--
cgo_solaris.go	339 B	-rw-r--r--
cgo_stub.go	1.06 KB	-rw-r--r--
cgo_unix.go	9.53 KB	-rw-r--r--
cgo_unix_test.go	1.89 KB	-rw-r--r--
cgo_windows.go	398 B	-rw-r--r--
conf.go	8.88 KB	-rw-r--r--
conf_netcgo.go	369 B	-rw-r--r--
conf_test.go	9.59 KB	-rw-r--r--
conn_test.go	1.77 KB	-rw-r--r--
dial.go	22.44 KB	-rw-r--r--
dial_test.go	27 KB	-rw-r--r--
dial_unix_test.go	2.74 KB	-rw-r--r--
dnsclient.go	5.34 KB	-rw-r--r--
dnsclient_test.go	1.54 KB	-rw-r--r--
dnsclient_unix.go	21.86 KB	-rw-r--r--
dnsclient_unix_test.go	45.17 KB	-rw-r--r--
dnsconfig_unix.go	5.47 KB	-rw-r--r--
dnsconfig_unix_test.go	6.73 KB	-rw-r--r--
dnsname_test.go	1.98 KB	-rw-r--r--
error_plan9.go	224 B	-rw-r--r--
error_plan9_test.go	398 B	-rw-r--r--
error_posix.go	583 B	-rw-r--r--
error_posix_test.go	980 B	-rw-r--r--
error_test.go	19.39 KB	-rw-r--r--
error_unix.go	421 B	-rw-r--r--
error_unix_test.go	672 B	-rw-r--r--
error_windows.go	355 B	-rw-r--r--
error_windows_test.go	483 B	-rw-r--r--
example_test.go	3.16 KB	-rw-r--r--
external_test.go	4.07 KB	-rw-r--r--
fd_plan9.go	3.56 KB	-rw-r--r--
fd_unix.go	7.36 KB	-rw-r--r--
fd_windows.go	6.49 KB	-rw-r--r--
file.go	1.69 KB	-rw-r--r--
file_plan9.go	2.68 KB	-rw-r--r--
file_stub.go	485 B	-rw-r--r--
file_test.go	6.53 KB	-rw-r--r--
file_unix.go	2.51 KB	-rw-r--r--
file_windows.go	521 B	-rw-r--r--
hook.go	628 B	-rw-r--r--
hook_plan9.go	283 B	-rw-r--r--
hook_unix.go	734 B	-rw-r--r--
hook_windows.go	875 B	-rw-r--r--
hosts.go	3.1 KB	-rw-r--r--
hosts_test.go	4.65 KB	-rw-r--r--
interface.go	7.14 KB	-rw-r--r--
interface_aix.go	4.41 KB	-rw-r--r--
interface_bsd.go	2.74 KB	-rw-r--r--
interface_bsd_test.go	1.42 KB	-rw-r--r--
interface_bsdvar.go	711 B	-rw-r--r--
interface_darwin.go	1.29 KB	-rw-r--r--
interface_freebsd.go	1.42 KB	-rw-r--r--
interface_linux.go	6.9 KB	-rw-r--r--
interface_linux_test.go	3.65 KB	-rw-r--r--
interface_plan9.go	4.59 KB	-rw-r--r--
interface_solaris.go	2.46 KB	-rw-r--r--
interface_stub.go	808 B	-rw-r--r--
interface_test.go	9.67 KB	-rw-r--r--
interface_unix_test.go	4.69 KB	-rw-r--r--
interface_windows.go	5.41 KB	-rw-r--r--
ip.go	16.61 KB	-rw-r--r--
ip_test.go	23.96 KB	-rw-r--r--
iprawsock.go	7.08 KB	-rw-r--r--
iprawsock_plan9.go	874 B	-rw-r--r--
iprawsock_posix.go	3.45 KB	-rw-r--r--
iprawsock_test.go	5.62 KB	-rw-r--r--
ipsock.go	8.77 KB	-rw-r--r--
ipsock_plan9.go	6.25 KB	-rw-r--r--
ipsock_posix.go	6.16 KB	-rw-r--r--
ipsock_test.go	6.81 KB	-rw-r--r--
listen_test.go	21.32 KB	-rw-r--r--
lookup.go	15.45 KB	-rw-r--r--
lookup_fake.go	1.64 KB	-rw-r--r--
lookup_plan9.go	7.68 KB	-rw-r--r--
lookup_test.go	29.14 KB	-rw-r--r--
lookup_unix.go	8.78 KB	-rw-r--r--
lookup_windows.go	11.74 KB	-rw-r--r--
lookup_windows_test.go	8 KB	-rw-r--r--
mac.go	1.88 KB	-rw-r--r--
mac_test.go	3.26 KB	-rw-r--r--
main_cloexec_test.go	669 B	-rw-r--r--
main_conf_test.go	915 B	-rw-r--r--
main_noconf_test.go	493 B	-rw-r--r--
main_plan9_test.go	392 B	-rw-r--r--
main_posix_test.go	1.37 KB	-rw-r--r--
main_test.go	7.11 KB	-rw-r--r--
main_unix_test.go	1.24 KB	-rw-r--r--
main_windows_test.go	1.08 KB	-rw-r--r--
mockserver_test.go	11.23 KB	-rw-r--r--
net.go	20.9 KB	-rw-r--r--
net_fake.go	5.34 KB	-rw-r--r--
net_test.go	12.1 KB	-rw-r--r--
net_windows_test.go	15.94 KB	-rw-r--r--
netgo_unix_test.go	631 B	-rw-r--r--
nss.go	3.71 KB	-rw-r--r--
nss_test.go	3.33 KB	-rw-r--r--
packetconn_test.go	3.56 KB	-rw-r--r--
parse.go	7.82 KB	-rw-r--r--
parse_test.go	2.14 KB	-rw-r--r--
pipe.go	5.59 KB	-rw-r--r--
pipe_test.go	1.2 KB	-rw-r--r--
platform_test.go	4.59 KB	-rw-r--r--
port.go	1.46 KB	-rw-r--r--
port_test.go	1.34 KB	-rw-r--r--
port_unix.go	1.28 KB	-rw-r--r--
protoconn_test.go	7.22 KB	-rw-r--r--
rawconn.go	1.89 KB	-rw-r--r--
rawconn_stub_test.go	622 B	-rw-r--r--
rawconn_test.go	4.52 KB	-rw-r--r--
rawconn_unix_test.go	3.15 KB	-rw-r--r--
rawconn_windows_test.go	3.26 KB	-rw-r--r--
sendfile_linux.go	1.1 KB	-rw-r--r--
sendfile_stub.go	329 B	-rw-r--r--
sendfile_test.go	5.69 KB	-rw-r--r--
sendfile_unix_alt.go	1.98 KB	-rw-r--r--
sendfile_windows.go	1.02 KB	-rw-r--r--
server_test.go	11.55 KB	-rw-r--r--
sock_bsd.go	898 B	-rw-r--r--
sock_cloexec.go	1.46 KB	-rw-r--r--
sock_linux.go	644 B	-rw-r--r--
sock_plan9.go	262 B	-rw-r--r--
sock_posix.go	6.83 KB	-rw-r--r--
sock_stub.go	378 B	-rw-r--r--
sock_windows.go	1.16 KB	-rw-r--r--
sockaddr_posix.go	955 B	-rw-r--r--
sockopt_aix.go	1.32 KB	-rw-r--r--
sockopt_bsd.go	2.09 KB	-rw-r--r--
sockopt_linux.go	1.14 KB	-rw-r--r--
sockopt_plan9.go	406 B	-rw-r--r--
sockopt_posix.go	2.67 KB	-rw-r--r--
sockopt_solaris.go	1.14 KB	-rw-r--r--
sockopt_stub.go	738 B	-rw-r--r--
sockopt_windows.go	1.34 KB	-rw-r--r--
sockoptip_bsdvar.go	848 B	-rw-r--r--
sockoptip_linux.go	735 B	-rw-r--r--
sockoptip_posix.go	1.43 KB	-rw-r--r--
sockoptip_stub.go	949 B	-rw-r--r--
sockoptip_windows.go	819 B	-rw-r--r--
splice_linux.go	1.09 KB	-rw-r--r--
splice_stub.go	286 B	-rw-r--r--
splice_test.go	10.51 KB	-rw-r--r--
sys_cloexec.go	977 B	-rw-r--r--
tcpsock.go	9.85 KB	-rw-r--r--
tcpsock_plan9.go	2.13 KB	-rw-r--r--
tcpsock_posix.go	5.27 KB	-rw-r--r--
tcpsock_test.go	17.51 KB	-rw-r--r--
tcpsock_unix_test.go	2.38 KB	-rw-r--r--
tcpsockopt_darwin.go	770 B	-rw-r--r--
tcpsockopt_dragonfly.go	698 B	-rw-r--r--
tcpsockopt_openbsd.go	365 B	-rw-r--r--
tcpsockopt_plan9.go	503 B	-rw-r--r--
tcpsockopt_posix.go	491 B	-rw-r--r--
tcpsockopt_solaris.go	1.15 KB	-rw-r--r--
tcpsockopt_stub.go	393 B	-rw-r--r--
tcpsockopt_unix.go	712 B	-rw-r--r--
tcpsockopt_windows.go	741 B	-rw-r--r--
timeout_test.go	23.18 KB	-rw-r--r--
udpsock.go	8.7 KB	-rw-r--r--
udpsock_plan9.go	3.77 KB	-rw-r--r--
udpsock_plan9_test.go	1.31 KB	-rw-r--r--
udpsock_posix.go	4.09 KB	-rw-r--r--
udpsock_test.go	11.18 KB	-rw-r--r--
unixsock.go	10.17 KB	-rw-r--r--
unixsock_linux_test.go	2.29 KB	-rw-r--r--
unixsock_plan9.go	1.24 KB	-rw-r--r--
unixsock_posix.go	5.81 KB	-rw-r--r--
unixsock_test.go	10.58 KB	-rw-r--r--
unixsock_windows_test.go	2.07 KB	-rw-r--r--
write_unix_test.go	1.59 KB	-rw-r--r--
writev_test.go	5.01 KB	-rw-r--r--
writev_unix.go	706 B	-rw-r--r--

Code Editor : 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.

// +build !js

package net

import (
	"bufio"
	"context"
	"internal/poll"
	"internal/testenv"
	"io"
	"os"
	"runtime"
	"strings"
	"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 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")
	}

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)
	}

// 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, network string, laddr, raddr *TCPAddr) (*TCPConn, error) {
	sd := &sysDialer{network: network, address: raddr.String()}
	c, err := sd.doDialTCP(ctx, 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(t *testing.T) (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 if runtime.GOOS == "darwin" {
		expected = 150 * time.Millisecond
	} else {
		expected = 95 * time.Millisecond
	}

l, err := Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Logf("dialClosedPort: Listen failed: %v", err)
		return 999 * time.Hour, expected
	}
	addr := l.Addr().String()
	l.Close()
	// On OpenBSD, interference from TestTCPSelfConnect 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 {
			t.Logf("dialClosedPort: measured delay %v", elapsed)
			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(t)
	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()
		sd := &sysDialer{
			Dialer:  d,
			network: "tcp",
			address: "?",
		}
		c, err := sd.dialParallel(context.Background(), 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)
		}

// We used to always use 95 milliseconds as the slop,
		// but that was flaky on Windows.  See issue 35616.
		slop := 95 * time.Millisecond
		if fifth := tt.expectElapsed / 5; fifth > slop {
			slop = fifth
		}
		expectElapsedMin := tt.expectElapsed - slop
		expectElapsedMax := tt.expectElapsed + slop
		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 = sd.dialParallel(ctx, 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, string) ([]IPAddr, error), network, 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, network, 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 cancellation.
		// 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:
		sd := &sysDialer{network: net, address: raddr.String()}
		return sd.doDialTCP(context.Background(), laddr, raddr)
	}

d := Dialer{
		FallbackDelay: fallbackDelay,
	}
	sd := &sysDialer{
		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 := sd.dialParallel(context.Background(), 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, poll.ErrTimeout},
		{now.Add(1 * time.Millisecond), now, 1, noDeadline, poll.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.Equal(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 {
			// A suspected kernel bug in macOS 10.12 occasionally results in
			// timeout errors when dialing address ::1. The errors have not
			// been observed on newer versions of the OS, so we don't plan to work
			// around them. See https://golang.org/issue/22019.
			if tt.raddr == "::1" && os.Getenv("GO_BUILDER_NAME") == "darwin-amd64-10_12" && os.IsTimeout(err) {
				t.Logf("ignoring timeout error on Darwin; see https://golang.org/issue/22019")
			} else {
				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) {
	testenv.SkipFlaky(t, 13324)

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

closedPortDelay, expectClosedPortDelay := dialClosedPort(t)
	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(time.Duration) {} }()

tests := []struct {
		ka       time.Duration
		expected time.Duration
	}{
		{-1, -1},
		{0, 15 * time.Second},
		{5 * time.Second, 5 * time.Second},
		{30 * time.Second, 30 * time.Second},
	}

for _, test := range tests {
		var got time.Duration = -1
		testHookSetKeepAlive = func(d time.Duration) { got = d }
		d := Dialer{KeepAlive: test.ka}
		c, err := d.Dial("tcp", ls.Listener.Addr().String())
		if err != nil {
			t.Fatal(err)
		}
		c.Close()
		if got != test.expected {
			t.Errorf("Dialer.KeepAlive = %v: SetKeepAlive set to %v, want %v", d.KeepAlive, got, test.expected)
		}
	}
}

func TestDialCancel(t *testing.T) {
	mustHaveExternalNetwork(t)

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 {
				// Using strings.Contains is ugly but
				// may work on plan9 and windows.
				if strings.Contains(err.Error(), "connection refused") {
					t.Skipf("connection to %v failed fast with %v", blackholeIPPort, err)
				}
				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 cancellation 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()
	}
}

// Issue 18806: it should always be possible to net.Dial a
// net.Listener().Addr().String when the listen address was ":n", even
// if the machine has halfway configured IPv6 such that it can bind on
// "::" not connect back to that same address.
func TestDialListenerAddr(t *testing.T) {
	mustHaveExternalNetwork(t)
	ln, err := Listen("tcp", ":0")
	if err != nil {
		t.Fatal(err)
	}
	defer ln.Close()
	addr := ln.Addr().String()
	c, err := Dial("tcp", addr)
	if err != nil {
		t.Fatalf("for addr %q, dial error: %v", addr, err)
	}
	c.Close()
}

func TestDialerControl(t *testing.T) {
	switch runtime.GOOS {
	case "plan9":
		t.Skipf("not supported on %s", runtime.GOOS)
	}

t.Run("StreamDial", func(t *testing.T) {
		for _, network := range []string{"tcp", "tcp4", "tcp6", "unix", "unixpacket"} {
			if !testableNetwork(network) {
				continue
			}
			ln, err := newLocalListener(network)
			if err != nil {
				t.Error(err)
				continue
			}
			defer ln.Close()
			d := Dialer{Control: controlOnConnSetup}
			c, err := d.Dial(network, ln.Addr().String())
			if err != nil {
				t.Error(err)
				continue
			}
			c.Close()
		}
	})
	t.Run("PacketDial", func(t *testing.T) {
		for _, network := range []string{"udp", "udp4", "udp6", "unixgram"} {
			if !testableNetwork(network) {
				continue
			}
			c1, err := newLocalPacketListener(network)
			if err != nil {
				t.Error(err)
				continue
			}
			if network == "unixgram" {
				defer os.Remove(c1.LocalAddr().String())
			}
			defer c1.Close()
			d := Dialer{Control: controlOnConnSetup}
			c2, err := d.Dial(network, c1.LocalAddr().String())
			if err != nil {
				t.Error(err)
				continue
			}
			c2.Close()
		}
	})
}

// mustHaveExternalNetwork is like testenv.MustHaveExternalNetwork
// except that it won't skip testing on non-mobile builders.
func mustHaveExternalNetwork(t *testing.T) {
	t.Helper()
	mobile := runtime.GOOS == "android" || runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64")
	if testenv.Builder() == "" || mobile {
		testenv.MustHaveExternalNetwork(t)
	}
}

type contextWithNonZeroDeadline struct {
	context.Context
}

func (contextWithNonZeroDeadline) Deadline() (time.Time, bool) {
	// Return non-zero time.Time value with false indicating that no deadline is set.
	return time.Unix(0, 0), false
}

func TestDialWithNonZeroDeadline(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)
	}

ctx := contextWithNonZeroDeadline{Context: context.Background()}
	var dialer Dialer
	c, err := dialer.DialContext(ctx, "tcp", JoinHostPort("", port))
	if err != nil {
		t.Fatal(err)
	}
	c.Close()
}

${this.title}

Code Editor : dial_test.go