ResultHandlerVersion1<GradleProject> adaptedHandler
        ResultHandler<GradleProject> handler = Mock()
        GradleProject result = Mock()

        when:
        executer.forTasks('a', 'b').run(handler)

        then:
        1 * asyncConnection.run(!null, !null) >> {args ->
            ConsumerAction<GradleProject> action = args[0]
            action.run(connection)

        when:
        toolingApi.withConnector { connector ->
            connector.useBuildDistribution()
        }
        toolingApi.withConnection { connection -> connection.newBuild().forTasks('check').run() }

        then:
        notThrown(Throwable)
    }

    def "tooling api searches up from the project directory to find the wrapper properties"() {
        settingsFile << "include 'child'"

        file("impl/build.gradle") << "task bar(dependsOn: ':api:foo')"
        file("other/build.gradle") << "assert false: 'should not be evaluated'"

        when:
        withBuild { it.forTasks(":impl:bar") }

        then:
        noExceptionThrown()
    }

import java.util.Collection;
import java.util.Comparator;
import java.util.Set;

public class SingleProjectTaskReportModel implements TaskReportModel {

    public static SingleProjectTaskReportModel forTasks(Collection<? extends Task> tasks, TaskDetailsFactory factory) {
        final SetMultimap<String, TaskDetails> groups = TreeMultimap.create(String::compareToIgnoreCase, Comparator.comparing(TaskDetails::getPath));

            task alpha() { doLast { throw new RuntimeException() } }
        """

        when:
        BuildEnvironment model = toolingApi.withConnection {
            it.model(BuildEnvironment)
                .forTasks(new String[0])
                .get()
        }

        then:
        model != null
        result.assertTasksExecutedInOrder()
    }

        buildFile getProblemReportTaskString(taskActionMethodBody)
    }

    def runTask() {
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')
                .addProgressListener(listener)
                .run()
        }
        return listener.problems
    }

    def "Failing executions produce problems"() {
        setup:

        when:
        def events = ProgressEvents.create()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            collectOutputs(build)
            build.forTasks("resolve")
            build.addProgressListener(events, OperationType.FILE_DOWNLOAD)
                .run()
        }

        then:
        thrown(BuildException)

        events.operations.size() >= 4

                    System.out.println 'foo'
                }
            }
        """

        when:
        withConnection {
            TestLauncher testLauncher = newTestLauncher()
            testLauncher.forTasks(':foo').run()
        }

        then:
        result.assertTaskExecuted(':foo')
    }

        } else {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.STRICT_CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        }

        if (explicitlyRequestPreparationTasks) {
            modelBuilder.forTasks(KotlinDslModelsParameters.PREPARATION_TASK_NAME)
        }
        def correlationId = newCorrelationId()

        def arguments =

        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)
            modelBuilder.forTasks([':other-build:sub:doSomething'])
            modelBuilder.get()
        }

        then:
        stdout.toString().contains("do something")
    }