expect:
        def connection = connector.maybeConnect({it.pid == 1} as DummyExplainingSpec)
        connection && connection.connection.num == 1
    }

    def "connect() returns connection to any existing daemon that matches spec"() {
        given:
        startIdleDaemon()
        startIdleDaemon()

        expect:
        def connection = connector.connect({it.pid < 12} as ExplainingSpec)

        when:
        withConnection { connection ->
            fetchCustomModelsWithRestrictedMemoryAction(connection)
        }

        then:
        notThrown(GradleConnectionException)
        assertHasConfigureSuccessfulLogging()
    }

    private fetchCustomModelsWithRestrictedMemoryAction(ProjectConnection connection) {
        connection.action(new FetchProjectsCustomModelsAction())

    private final AsyncConsumerActionExecutor connection;

    public DefaultBuildActionExecuter(BuildAction<T> buildAction, AsyncConsumerActionExecutor connection, ConnectionParameters parameters) {
        super(parameters);
        operationParamsBuilder.setEntryPoint("BuildActionExecuter API");
        this.buildAction = buildAction;
        this.connection = connection;
    }

    @Override

        withConnection { connection ->
            connection.newBuild().forTasks("wrapper").run()
        }
        file('gradle/wrapper/gradle-wrapper.properties') << 'distributionSha256Sum=bad'

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

    private final Class<T> modelType;
    private final AsyncConsumerActionExecutor connection;

    public DefaultModelBuilder(Class<T> modelType, AsyncConsumerActionExecutor connection, ConnectionParameters parameters) {
        super(parameters);
        this.modelType = modelType;
        this.connection = connection;
        operationParamsBuilder.setEntryPoint("ModelBuilder API");
    }

    @Override

        def buildFinishedHandler = new IntermediateResultHandlerCollector<EclipseModel>()
        def out = new ByteArrayOutputStream()

        when:
        withConnection { connection ->
            connection.action().projectsLoaded(new TellGradleToRunSyncTasks(), projectsLoadedHandler)
                .buildFinished(new LoadEclipseModel(), buildFinishedHandler)
                .build()

        EclipseProject model = withConnection { connection ->
            connection.action(new LoadEclipseModel()).run()
        }

        then:
        collectProjects(model).collect({ it.name }).contains("a")
    }

    def "buildscript names are deduplicated"() {
        when:
        EclipseProject model = withConnection { connection ->

    public void apply(Project project) {
    }
}
"""
    }

    def "retains underlying object identity in model returned to client"() {
        when:
        def model = withConnection { connection ->
            connection.model(CustomModel).get()
        }

        then:
        model.thing.is(model.thing)
        model.things[0].is(model.thing)
        model.thingsByName.child.is(model.thing)

    }

    def "build fails if debugger is not ready"() {
        setup:
        // port is assigned but not connected
        def port = jdwpClient.port

        when:
        withConnection { connection ->
            connection.newTestLauncher()
                .withJvmTestClasses("example.MyTest")
                .debugTestsOn(port)
                .run()
        }

        then:
        thrown(BuildException)
    }

                }
            """
        }
    }

    @TargetGradleVersion(">=4.4")
    def "can get models with parameters"() {
        when:
        def model = withConnection { connection ->
            connection.action(new ParameterAction()).run()
        }

        then:
        model.isBuiltWithParameter()
        model.getParameterValue() == "myParameter"
    }