// ConnectExFunc is used to hook the ConnectEx call.

			}
		}
	}
	var rsa syscall.Sockaddr  // remote address from the user
	var crsa syscall.Sockaddr // remote address we actually connected to
	if raddr != nil {
		if rsa, err = raddr.sockaddr(fd.family); err != nil {
			return err
		}
		if crsa, err = fd.connect(ctx, lsa, rsa); err != nil {
			return err
		}
		fd.isConnected = true
	} else {
		if err := fd.init(); err != nil {
			return err
		}

        when:
        def objectConnection = client.getConnection(address)

        then:
        1 * connector.connect(address) >> connectCompletion
        1 * executorFactory.create("${connectCompletion} workers") >> executor

        when:
        objectConnection.connect()

        then:
        1 * connectCompletion.create(_) >> backingConnection

        when:
        objectConnection.stop()

import spock.lang.Specification

class MessageHubBackedServerTest extends Specification {
    final IncomingConnector connector = Mock()
    final ExecutorFactory executorFactory = Mock()
    final MessageHubBackedServer server = new MessageHubBackedServer(connector, executorFactory)

    def "creates connection and cleans up on stop"() {
        ConnectionAcceptor acceptor = Mock()

	return f.kubeClient
}

func (f *FakeDiscoveryServer) PushContext() *model.PushContext {
	return f.Env().PushContext()
}

// ConnectADS starts an ADS connection to the server. It will automatically be cleaned up when the test ends
func (f *FakeDiscoveryServer) ConnectADS() *xds.AdsTest {
	conn, err := grpc.Dial("buffcon",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithBlock(),

internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

        result.keySet() == ['test', 'a', 'b', 'c'] as Set
        result.values()*.value as Set == [':', ':a', ':b', ':b:c'] as Set

        when:
        withConnector { connector ->
            connector.searchUpwards(true)
            connector.forProjectDirectory(file("b"))
        }
        result = withConnection { connection -> connection.action(new UseGradleBuildToFetchProjectModel()).run() }

        then:

/**
 * Thrown when the tooling API client attempts to use a method that does not exist
 * in the version of Gradle that the tooling API is connected to.
 * <p>
 * Typically, to resolve such a problem you change/upgrade the target version of Gradle that
 * the tooling API is connected to. Alternatively, you can handle and ignore this exception.
 *
 * @since 1.0-milestone-8
 */

 */

package org.gradle.internal.resource.transport.file;

import com.google.common.collect.Sets;
import org.gradle.authentication.Authentication;
import org.gradle.internal.resource.connector.ResourceConnectorFactory;
import org.gradle.internal.resource.connector.ResourceConnectorSpecification;
import org.gradle.internal.resource.transfer.ExternalResourceConnector;

import java.util.HashSet;
import java.util.Set;

import org.apache.maven.api.services.ChecksumAlgorithmService;
import org.apache.maven.api.services.ChecksumAlgorithmServiceException;
import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;

import static org.apache.maven.internal.impl.Utils.nonNull;

@Named
@Singleton