.setStandardOutput(out)
                .forTasks()
                .run()
        }

        then:
        !taskExecuted(out, ":nothing")
        !taskExecuted(out, ":nothing_")
        taskExecuted(out, ":nothing__")
    }

    private def taskExecuted(ByteArrayOutputStream out, String taskPath) {
        out.toString().contains("> Task $taskPath ")
    }

        child2.classpath[0].javadoc.name == 'child1-1.0-javadoc.jar'
        taskExecuted(out, ":eclipseClosedDependencies")
        taskExecuted(out, ":child1:javadocJar")
        taskExecuted(out, ":child1:sourceJar")

    }


    private static def taskExecuted(ByteArrayOutputStream out, String taskPath) {
        out.toString().find("(?m)> Task ${Pattern.quote(taskPath)}\$") != null

        }

        then:
        taskExecuted(':bar')
        !taskExecuted(':foo')
    }

    def "if selected test overlaps with launched task then the test filter still applies"() {
        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks(':help', ':test')
        }

        then:
        taskExecuted(':help')
    }

                .setStandardOutput(out)
                .forTasks()
                .run()
        }

        then:
        !taskExecuted(out, ":nothing")
        !taskExecuted(out, ":nothing_")
        taskExecuted(out, ":nothing__")
    }

    private def taskExecuted(ByteArrayOutputStream out, String taskPath) {
        out.toString().contains("> Task $taskPath ")
    }

        b1Model.projectDependencies.isEmpty()
        b1Model.classpath.collect { it.file.name } == ['buildC-1.0.jar']
        taskExecuted(out, ":eclipseClosedDependencies")
        taskExecuted(out, ":buildC:jar")
    }

    private static def taskExecuted(ByteArrayOutputStream out, String taskPath) {
        out.toString().contains("> Task $taskPath")
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.tasks;

import org.gradle.api.internal.TaskInternal;

public interface TaskExecuter {
    /**
     * Executes the given task. If the task fails with an exception, the exception is packaged in the provided task
     * state.
     */

 */
public class FinalizePropertiesTaskExecuter implements TaskExecuter {
    private final TaskExecuter taskExecuter;

    public FinalizePropertiesTaskExecuter(TaskExecuter taskExecuter) {
        this.taskExecuter = taskExecuter;
    }

    @Override
    public TaskExecuterResult execute(TaskInternal task, TaskStateInternal state, TaskExecutionContext context) {

public class SkipTaskWithNoActionsExecuter implements TaskExecuter {
    private static final Logger LOGGER = LoggerFactory.getLogger(SkipTaskWithNoActionsExecuter.class);
    private final TaskExecutionGraph taskExecutionGraph;
    private final TaskExecuter executer;

    public SkipTaskWithNoActionsExecuter(TaskExecutionGraph taskExecutionGraph, TaskExecuter executer) {
        this.taskExecutionGraph = taskExecutionGraph;
        this.executer = executer;

                typeValidationContext -> missingTaskDependencyDetector.detectMissingDependencies(localTaskNode, typeValidationContext)
            );
            TaskExecuter taskExecuter = context.getService(TaskExecuter.class);
            taskExecuter.execute(task, state, ctx);
            return true;
        } else {
            return false;
        }
    }

@NonNullApi
public class ResolveTaskExecutionModeExecuter implements TaskExecuter {
    private static final Logger LOGGER = LoggerFactory.getLogger(ResolveTaskExecutionModeExecuter.class);

    private final TaskExecuter executer;
    private final TaskExecutionModeResolver executionModeResolver;

    public ResolveTaskExecutionModeExecuter(TaskExecutionModeResolver executionModeResolver, TaskExecuter executer) {
        this.executer = executer;