}

    private getModelWithProjectConnection(TestFile rootDir, Class modelType = GradleProject, boolean searchUpwards = true) {
        def connector = connector()
        connector.forProjectDirectory(rootDir)
        connector.searchUpwards(searchUpwards)
        return withConnection(connector) { it.getModel(modelType) }
    }

    }

    def "cannot create new project connection after disconnect"() {
        setup:
        def connector = toolingApi.connector()
        withConnection(connector) { connection ->
            connection.getModel(EclipseProject)
        }
        connector.disconnect()

        when:
        connector.connect()

        then:
        def e = thrown(RuntimeException)

    }

    def <T> T withConnection(@DelegatesTo(ProjectConnection) Closure<T> cl) {
        def connector = connector()
        withConnection(connector, cl)
    }

    def <T> T withConnection(connector, @DelegatesTo(ProjectConnection) Closure<T> cl) {
        return withConnectionRaw(connector, cl)
    }

        given:
        startIdleDaemon()
        assert !registry.all.empty

        connector.connector.connect(_ as Address) >> { throw new ConnectException("Problem!", new RuntimeException("foo")) }

        when:
        def connection = connector.maybeConnect( { true } as ExplainingSpec)

        then:
        !connection

        registry.all.empty
    }

        return new DaemonStopClient(connector, idGenerator);
    }

    @Provides
    NotifyDaemonAboutChangedPathsClient createNotifyDaemonAboutChangedPathsClient(DaemonConnector connector, IdGenerator<UUID> idGenerator, DaemonRegistry daemonRegistry) {
        return new NotifyDaemonAboutChangedPathsClient(connector, idGenerator, daemonRegistry);
    }

        def connector = connector()
        connector.forProjectDirectory(rootDir.absoluteFile)
        connector.searchUpwards(searchUpwards)
        def model = withConnection(connector) { it.getModel(modelType) }
        return toGradleProject(model)
    }

    private <T> T getModelWithProjectConnection(TestFile rootDir, Class<T> modelType) {
        def connector = connector()

        1 * connection.stop()
        0 * connection._
    }

    def "does not loop forever finding usable daemons"() {
        given:
        connector.connect(compatibilitySpec) >> connection
        connector.startDaemon(compatibilitySpec) >> connection
        connection.daemon >> Stub(DaemonConnectDetails)
        connection.receive() >> Mock(DaemonUnavailable)

        when:

        }
        file('gradle/wrapper/gradle-wrapper.properties') << 'distributionSha256Sum=bad'

        when:
        def connector = this.connector()
        connector.useBuildDistribution()
        withConnection(connector) { ProjectConnection connection ->
            connection.newBuild().forTasks("help").run()
        }

        then:
        def e = thrown(GradleConnectionException)

public class NotifyDaemonAboutChangedPathsClient {
    private final DaemonConnector connector;
    private final IdGenerator<UUID> idGenerator;
    private final DaemonRegistry daemonRegistry;

    public NotifyDaemonAboutChangedPathsClient(DaemonConnector connector, IdGenerator<UUID> idGenerator, DaemonRegistry daemonRegistry) {
        this.connector = connector;
        this.idGenerator = idGenerator;
        this.daemonRegistry = daemonRegistry;

                    GradleConnector connector = GradleConnector.newConnector();
                    connector.useGradleVersion(gradleVersion);

                    ProjectConnection connection = null;

                    try {
                        connection = connector.forProjectDirectory(projectLocation).useGradleUserHomeDir(gradleUserHome).connect();