toolingApi.withConnection { ProjectConnection connection ->
            def buildAction = connection.action(new LoadCompositeModel(GradleProject))
            collectOutputs(buildAction)
            buildAction.forTasks([':other-build:sub:doSomething'])
            buildAction.run()
        }

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

        ValidatingProgressEventListener validatingListener = new ValidatingProgressEventListener()

        when:
        withConnection {
            it.newBuild().forTasks('myTestTask').addProgressListener(validatingListener).run()
        }

        then:
        validatingListener.receivedCustomTestTaskProgressEvents()
    }

        when:
        createBuildFileForConfigurationPhaseCheck(exceptionNestingLevel)
        withConnection { connection ->
            connection.newBuild().forTasks("assemble").run()
        }

        then:
        def e = thrown(GradleConnectionException)
        def exceptionString = getStackTraceAsString(e)

        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)

        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()
    }

                    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")
    }