then:
        1 * connector.accept(_, false) >> { acceptAction = it[0]; return acceptor }

        when:
        acceptAction.execute(completion)

        then:
        1 * executorFactory.create("${completion} workers") >> executor
        1 * connectAction.execute(_) >> { ObjectConnection c -> connection = c }

        when:
        connection.connect()

        then:

    
            session.transport.connect();

            unc = "\\\\" + session.transport.tconHostName + '\\' + share;
    
            /* IBM iSeries doesn't like specifying a service. Always reset
             * the service to whatever was determined in the constructor.
             */
            service = service0;
    
            /*
             * Tree Connect And X Request / Response
             */
    

func (r *ProxyREST) NewConnectOptions() (runtime.Object, bool, string) {
	return &api.NodeProxyOptions{}, true, "path"
}

// Connect returns a handler for the node proxy
func (r *ProxyREST) Connect(ctx context.Context, id string, opts runtime.Object, responder rest.Responder) (http.Handler, error) {
	proxyOpts, ok := opts.(*api.NodeProxyOptions)
	if !ok {

 2. It attempts to retrieve a connection with that address from the **connection pool**.
 3. If it doesn't find a connection in the pool, it selects a **route** to attempt. This usually means making a DNS request to get the server's IP addresses. It then selects a TLS version and proxy server if necessary.

            hub.addHandler(channel, handler)
        }

        def connectTo(Participant other) {
            def connector = new TestConnector()
            hub.addConnection(connector.connectionA)
            other.hub.addConnection(connector.connectionB)
        }

        def stop() {
            hub.stop()
        }
    }

package org.gradle.launcher.daemon.server;

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.remote.Address;

/**
 * Opens a server connection for clients to connect to communicate with a daemon.
 * <p>
 * A server connector should only be used by one daemon, and has a single use lifecycle.
 * Implementations must be threadsafe so that start/stop can be called from different threads.
 */

	origListen      = listenFunc
	origAccept      = poll.AcceptFunc
)

func installTestHooks() {
	wsaSocketFunc = sw.WSASocket
	poll.CloseFunc = sw.Closesocket
	connectFunc = sw.Connect
	poll.ConnectExFunc = sw.ConnectEx
	listenFunc = sw.Listen
	poll.AcceptFunc = sw.AcceptEx
}

func uninstallTestHooks() {
	wsaSocketFunc = origWSASocket
	poll.CloseFunc = origClosesocket
	connectFunc = origConnect

        return String.format("Unsupported method: %s."
                + "\nThe version of Gradle you connect to does not support that method."
                + "\nTo resolve the problem you can change/upgrade the target version of Gradle you connect to."
                + "\nAlternatively, you can ignore this exception and read other information from the model.",
            method);
    }

		// from connect.
		done := make(chan struct{})
		interruptRes := make(chan error)
		defer func() {
			close(done)
			if ctxErr := <-interruptRes; ctxErr != nil && ret == nil {
				// The interrupter goroutine called SetWriteDeadline,
				// but the connect code below had returned from
				// waitWrite already and did a successful connect (ret

		if w.forwarder == nil {
			// We only want to do reconnects here, if we never connected let the main flow handle it.
			return
		}
		// Only reconnect if the pod is ready
		if !isPodReady(w.pod) {
			return
		}
		con := !w.isConnected()
		if con {
			log.Warnf("pod: %s/%s port forward terminated", w.pod.Namespace, w.pod.Name)
			err := w.connect(w.pod)
			if err != nil {