for (DaemonInfo daemon : daemons) {
            DaemonClientConnection connection = connector.maybeConnect(daemon);
            if (connection != null) {
                try {
                    final ReportStatus statusCommand = new ReportStatus(idGenerator.generateId(), daemon.getToken());
                    final Status status = reportStatusDispatcher.dispatch(connection, statusCommand);
                    if (status != null) {

        } catch (URISyntaxException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
        UrlExternalResource connector = new UrlExternalResource();
        return new AccessorBackedExternalResource(new ExternalResourceName(uri), connector, connector, connector, false);
    }

    @Nullable
    @Override

        when:
        toolingApi.withUserHome(userHomeDir)
        toolingApi.withConnector { connector ->
            connector.useGradleUserHomeDir(userHomeDir)
        }
        toolingApi.withConnection { connection ->
            BuildLauncher build = connection.newBuild()
            build.forTasks("gradleBuild");
            build.standardOutput = baos
            build.run()
        }

time="2020-07-12T20:45:50Z" level=info msg="config connector: mock"
time="2020-07-12T20:45:50Z" level=info msg="config connector: local passwords enabled"
time="2020-07-12T20:45:50Z" level=info msg="config response types accepted: [code token id_token]"
time="2020-07-12T20:45:50Z" level=info msg="config using password grant connector: local"
time="2020-07-12T20:45:50Z" level=info msg="config signing keys expire after: 3h0m0s"

        1 * connectAction.execute(_) >> { ObjectConnection c -> connection = c }

        when:
        connection.connect()

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

        when:
        connection.stop()

        then:
        1 * backingConnection.stop()
        1 * executor.stop()
        0 * _._
    }

        private EmbeddedGradleProvider() {}

        @Override
        public void applyTo(GradleConnector gradleConnector) {
            DefaultGradleConnector connector = (DefaultGradleConnector) gradleConnector;
            connector.embedded(true);
            connector.useClasspathDistribution();
        }

        @Override
        public void applyTo(GradleRunner gradleRunner) {
        }
    }

import spock.lang.Specification

class MessageHubBackedClientTest extends Specification {
    final OutgoingConnector connector = Mock()
    final ExecutorFactory executorFactory = Mock()
    final MessageHubBackedClient client = new MessageHubBackedClient(connector, executorFactory)

    def "creates connection and cleans up on stop"() {
        Address address = Stub()
        ConnectCompletion connectCompletion = Mock()

        Map<String, CustomModel> result = withConnection { connection -> connection.action(new UseGradleBuildToFetchProjectModel()).run() }

        then:
        result != null
        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)

import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.spi.connector.ArtifactDownload;
import org.eclipse.aether.spi.connector.ArtifactUpload;
import org.eclipse.aether.spi.connector.MetadataDownload;
import org.eclipse.aether.spi.connector.MetadataUpload;
import org.eclipse.aether.spi.connector.RepositoryConnector;
import org.eclipse.aether.transfer.ArtifactNotFoundException;

        def connector = toolingApi.connector(buildSrc)
        return withConnection(connector, c)
    }