}
            }

            task ${taskName}(type: InputDirectoryContentToOutputFileAction) {
                inputDirectory = new File("${drive}\\\\")
                output = file("${TextUtil.escapeString(outputFile.absolutePath)}")
            }
        """
        when:
        buildScript script

        then:
        succeeds taskName
        outputFile.text.contains inputFileName

        cleanup:

            import java.util.concurrent.TimeUnit

            tasks.addRule("") { taskName ->
                if (taskName.startsWith("verifyMaxWorkers")) {
                    task(taskName) { task ->
                        doLast {
                            def count = (taskName - "verifyMaxWorkers") as int
                            def latch = new CountDownLatch(count)

        binary.inputs.withType(MarkdownSourceSet) { markdownSourceSet ->
            def taskName = binary.tasks.taskName("compile", markdownSourceSet.name)
            def outputDir = new File(binary.outputDir, markdownSourceSet.name)
            tasks.create(taskName, MarkdownHtmlCompile) { compileTask ->
                compileTask.source = markdownSourceSet.source

    def "returned service ref refers to service for that build"() {
        given:
        def taskName = "printInvocationId"
        buildFile << taskPrintBuildInvocationId(taskName)

        when:
        succeeds taskName, "--configuration-cache"
        def firstInvocationId = output.find(~/(?<=extension-buildInvocationId=).+(?=\n)/)
        succeeds taskName, "--configuration-cache"

        String taskRegistration(String taskName, String taskType);

        String taskConfiguration(String taskName, String taskType);

        String suiteRegistration(String taskName, String taskType);

        String suiteConfiguration(String taskName, String taskType);

        String referenceTask(String taskName);

        String referenceSuite(String taskName);

class TasksFromProjectDependencies implements TaskDependencyContainerInternal {
    private final TaskDependencyContainerInternal taskDependencyDelegate;

    public TasksFromProjectDependencies(
        String taskName,
        Supplier<Set<ProjectDependency>> projectDependencies,
        TaskDependencyFactory taskDependencyFactory,
        ProjectStateRegistry projectStateRegistry
    ) {

    }

    @Override
    public void apply(String taskName) {
        if (taskName.startsWith(PREFIX)) {
            String configurationName = StringUtils.uncapitalize(taskName.substring(PREFIX.length()));
            Configuration configuration = configurations.findByName(configurationName);

            if (configuration != null) {
                Task task = tasks.create(taskName);

        }
    }
    extra.set(propertyName, value)
}

fun isRequestedTask(taskName: String) = gradle.startParameter.taskNames.contains(taskName)

                    attributes('Main-Class': 'driver.Driver')
                }
            }
        """

        when:
        succeeds taskName

        then:
        file("out.txt").text == """helloworld"""

        where:
        method                    | taskName
        'JavaExec task'           | 'runWithTask'
        'project.javaexec'        | 'runWithJavaExec'

        return (BinaryTasksCollection) super.getDelegate();
    }

    @Override
    public String taskName(String verb) {
        return getDelegate().taskName(verb);
    }

    @Override
    public String taskName(String verb, String object) {
        return getDelegate().taskName(verb, object);
    }

    @Override
    public Task getBuild() {
        return getDelegate().getBuild();
    }