cancel()
		}()
		go func(i int) {
			defer wg.Done()
			var dialer Dialer
			// Try to connect to a real host on a port
			// that it is not listening on.
			_, err := dialer.DialContext(ctx, "tcp", "golang.org:3")
			if err == nil {
				t.Errorf("Dial to unbound port succeeded on attempt %d", i)
			}
			<-sem
		}(i)
	}
	wg.Wait()

		}()
	}
	attempts := 10 * N
	fails := 0
	d := &Dialer{Timeout: 200 * time.Millisecond}
	for i := 0; i < attempts; i++ {
		c, err := d.Dial("tcp", ln.Addr().String())
		if err != nil {
			fails++
		} else {
			c.Close()
		}
	}
	ln.Close()
	wg.Wait()
	if fails > attempts/9 { // see issues 7400 and 7541
		t.Fatalf("too many Dial failed: %v", fails)
	}
	if fails > 0 {

}

// wantDial waits for the Transport to start a Dial.
func (dt *transportDialTester) wantDial() *transportDialTesterConn {
	c := <-dt.dials
	c.connID = dt.dialCount
	dt.dialCount++
	dt.t.Logf("Dial %v: started", c.connID)
	return c
}

// finish completes a Dial.
func (c *transportDialTesterConn) finish(err error) {
	c.t.Logf("Dial %v: finished (err:%v)", c.connID, err)
	c.ready <- err

	ctrlCtxFn := sd.Dialer.ControlContext
	if ctrlCtxFn == nil && sd.Dialer.Control != nil {
		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
			return sd.Dialer.Control(network, address, c)
		}
	}
	fd, err := internetSocket(ctx, sd.network, laddr, raddr, syscall.SOCK_STREAM, proto, "dial", ctrlCtxFn)

	defer ls.teardown()
	if err := ls.buildup(handler); err != nil {
		t.Fatal(err)
	}

	for _, cfg := range testConfigs {
		d := Dialer{
			KeepAlive:       defaultTCPKeepAliveIdle, // should be ignored
			KeepAliveConfig: cfg}
		c, err := d.Dial("tcp", ls.Listener.Addr().String())
		if err != nil {
			t.Fatal(err)
		}
		defer c.Close()

		if errHook != nil {
			t.Fatal(errHook)
		}

// DialContext is a function to make custom Dial for internode communications
type DialContext func(ctx context.Context, network, address string) (net.Conn, error)

// NewInternodeDialContext configures a custom dialer for internode communications
func NewInternodeDialContext(dialTimeout time.Duration, _ TCPOptions) DialContext {
	return func(ctx context.Context, network, addr string) (net.Conn, error) {
		dialer := &net.Dialer{
			Timeout: dialTimeout,

			}

			trch := make(chan error, 1)
			_, port, err := SplitHostPort(ls.PacketConn.LocalAddr().String())
			if err != nil {
				t.Fatal(err)
			}
			if tt.dial {
				d := Dialer{Timeout: someTimeout}
				c2, err := d.Dial(tt.tnet, JoinHostPort(tt.taddr, port))
				if err != nil {
					if perr := parseDialError(err); perr != nil {
						t.Error(perr)
					}
					t.Fatal(err)
				}

	// ConnectStart is called before a Dial, excluding Dials made
	// during DNS lookups. In the case of DualStack (Happy Eyeballs)
	// dialing, this may be called multiple times, from multiple
	// goroutines.
	ConnectStart func(network, addr string)

	// ConnectDone is called after a Dial with the results, excluding
	// Dials made during DNS lookups. It may also be called multiple
	// times, like ConnectStart.

		return dialer.(hbone.Dialer)
	}
	out := &net.Dialer{
		Timeout: common.ConnectionTimeout,
	}
	if cfg.forceDNSLookup {
		out.Resolver = newResolver(common.ConnectionTimeout, "", "")
	}
	return out
}

func newResolver(timeout time.Duration, protocol, dnsServer string) *net.Resolver {
	return &net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{

		}
	}
}

var dialGoogleTests = []struct {
	dial               func(string, string) (Conn, error)
	unreachableNetwork string
	networks           []string
	addrs              []string
}{
	{
		dial:     (&Dialer{DualStack: true}).Dial,
		networks: []string{"tcp", "tcp4", "tcp6"},
		addrs:    []string{"www.google.com:http"},
	},
	{
		dial:               Dial,
		unreachableNetwork: "tcp6",