withConnection {
            it.action(new SimpleAction())
                .forTasks([])
                .run()
        }

        then:
        assertHasBuildSuccessfulLogging()
        result.assertTasksExecuted(":thing")
    }

    @TargetGradleVersion(">=3.0 <3.5")
    def "BuildExecuter.forTasks() should fail when it is not supported by target"() {
        when:
        withConnection {

        result.assertTasksExecuted(":help")

        where:
        description                 | action
        "empty array of task names" | { BuildActionExecuter b -> b.forTasks() }
        "empty list of task names"  | { BuildActionExecuter b -> b.forTasks([]) }
    }

    def "#description means run default tasks when they are defined"() {
        file('build.gradle') << """
            defaultTasks = ["thing"]

    }

    @Override
    public BuildLauncher forTasks(String... tasks) {
        operationParamsBuilder.setTasks(Arrays.asList(tasks));
        return this;
    }

    @Override
    public BuildLauncher forTasks(Task... tasks) {
        forTasks(Arrays.asList(tasks));
        return this;
    }

    @Override
    public BuildLauncher forTasks(Iterable<? extends Task> tasks) {
        forLaunchables(tasks);

        when:
        buildScript """
            apply from: "fooTask.gradle"
            task check {
                doLast {
                    assert getTasksByName("foo", false).toList().first().name == "foo"
                }
            }
        """

        file("fooTask.gradle") << """
            model {
                tasks { create("foo") }
            }

        ProjectConnection connection2 = connector.connect()

        def build = connection1.newBuild()
        build.forTasks('hang')
        build.run(resultHandler)

        def build2 = connection2.newBuild()
        build2.forTasks('hang')
        build2.run(resultHandler)

        sync.waitForAllPendingCalls(resultHandler)
        then:
        assertNumberOfRunningDaemons(2)

        where:
        description                 | action
        "no task names specified"   | { ModelBuilder b -> }
        "empty array of task names" | { ModelBuilder b -> b.forTasks() }
        "empty list of task names"  | { ModelBuilder b -> b.forTasks([]) }
    }

    def "#description means do not run any tasks even when build logic injects tasks to execute"() {
        file('build.gradle') << """

        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->
                connection.model(BuildInvocations).forTasks('assemble').addProgressListener(events, EnumSet.of(OperationType.TASK)).get()
        }

        then: "task progress events must be forwarded to the attached listeners"
        !events.tasks.empty

        buildFile << buildFileContent('')
        expectDownload()

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection -> connection.newBuild().forTasks('resolve').addProgressListener(events).run()
        }

        then:
        events.assertIsABuild()

        and:

        setupProject()

        when:
        def events = ProgressEvents.create()
        withConnection {
            it.newBuild().forTasks(taskName)
                .addProgressListener(events, OperationType.BUILD_PHASE)
                .run()
        }

        then:
        def progressEvents = events.getAll()
        progressEvents.size() == 6

        when:
        ByteArrayOutputStream out = new ByteArrayOutputStream()
        withConnection { ProjectConnection connection ->
            connection.newBuild().setEnvironmentVariables(["var": "val"]).setStandardOutput(out).forTasks('printEnv').run()
        }

        then:
        out.toString().contains("<${["var": "val"]}>")
    }

    @TargetGradleVersion(">=4.11")