result.assertTasksExecutedInOrder(":api:foo", ":impl:bar")
    }

    def "supports buildSrc"() {
        file("buildSrc/src/main/java/FooTask.java") << """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;

            public class FooTask extends DefaultTask {
                @TaskAction public void logStuff(){

        TestOperationCollector collector = new TestOperationCollector()
        withConnection { connection ->
            def build = connection.newBuild()
            build.addProgressListener(collector)
            build.forTasks(":other-build:sub:test").run()
        }
        TestOperationDescriptor descriptor = collector.descriptors.find { it.name == "myTestMethod" }

        when:
        withConnection { connection ->

    def "executing task which depends on source set classes does not build resources"() {
        buildFile("""
            plugins {
                id 'java'
            }

            def fooTask = tasks.register("foo") {
                outputs.file(project.layout.buildDirectory.dir("fooOut"))
            }

            tasks.register("bar") {
                inputs.files(java.sourceSets.main.output.classesDirs)

                        ByteArrayOutputStream err = new ByteArrayOutputStream();

                        connection.newBuild()
                            .forTasks("help")
                            .setStandardOutput(out)
                            .setStandardError(err)
                            .setJavaHome(javaHome)
                            .run();

            def error = new ByteArrayOutputStream()
            def args = executer.allArgs
            args.remove("--no-daemon")

            model = connection.model(type)
                .forTasks(tasks)
                .withArguments(args)
                .setStandardOutput(new TeeOutputStream(output, System.out))
                .setStandardError(new TeeOutputStream(error, System.err))
                .get()

            plugins {
                id("base")
            }

            def fooTask = tasks.register("foo", Zip) {
                throw new RuntimeException("Realized artifact task")
            }

            configurations {
                consumable("conf") {
                    outgoing {
                        artifact(fooTask)
                    }
                    attributes {

        OutputStream stdout = Stub()
        OutputStream stderr = Stub()

        when:
        launcher.standardOutput = stdout
        launcher.standardError = stderr
        launcher.forTasks(task1, task2)
        launcher.run(handler)

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

        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .setStandardOutput(System.out)
                    .forTasks('runInProcess', 'runForked')
                    .addProgressListener(events)
                    .run()
        }

        then:
        events.assertIsABuild()

        and:

        withConnection {
            def launcher = newBuild()
                .forTasks(task)
                .addProgressListener(events, operationTypes)
            collectOutputs(launcher)
            config.execute(launcher)
            launcher.run()
        }
    }

     * For example, the project directory or Gradle user home directory that are configured
     * in the {@link GradleConnector}.
     * Also, the task names configured by {@link BuildLauncher#forTasks(String...)} can be overridden
     * if you happen to specify other tasks via the build arguments.
     * <p>
     * See the example in the docs for {@link BuildLauncher}
     *