<table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr><td>delete</td></tr>
            <tr><td>targetFiles</td></tr>
            <tr><td>followSymlinks</td></tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>

        then:
        def clean = project.tasks[CLEAN_TASK_NAME]
        clean instanceOf(Delete)
        clean dependsOn()
        clean.group == BUILD_GROUP
        clean.targetFiles.files == [project.buildDir] as Set

        and:
        def assemble = project.tasks[ASSEMBLE_TASK_NAME]
        assemble.group == BUILD_GROUP
        assemble instanceOf(DefaultTask)

        and:

        when:
        project.pluginManager.apply(BasePlugin)

        then:
        def clean = project.tasks[BasePlugin.CLEAN_TASK_NAME]
        clean instanceOf(Delete)
        clean dependsOn()
        clean.targetFiles.files == [project.buildDir] as Set

        and:
        def assemble = project.tasks[BasePlugin.ASSEMBLE_TASK_NAME]
        assemble instanceOf(DefaultTask)
    }

    }

    private void downloadResource(URI source, File targetFile, ExternalResource resource) {
        final File downloadFile = new File(targetFile.getAbsoluteFile() + ".part");
        try {
            resource.withContent(inputStream -> {
                LOGGER.info("Downloading {} to {}", resource.getDisplayName(), targetFile);
                copyIntoFile(source, inputStream, downloadFile);
            });

            println("${change.changeType}: ${change.normalizedPath}")
            val targetFile = outputDir.file(change.normalizedPath).get().asFile
            if (change.changeType == ChangeType.REMOVED) {
                targetFile.delete()
            } else {
                targetFile.writeText(change.file.readText().reversed())
            }
        }
        // end::process-changed-inputs[]
    }
}

                return fileCollection.getSingleFile();
            }

            File targetFile = tempFileProvider.createTemporaryFile("fileCollection", ".txt", "resource");
            try {
                Files.asCharSource(fileCollection.getSingleFile(), charset).copyTo(Files.asCharSink(targetFile, targetCharsetObj));
            } catch (IOException e) {

public class OnDemandFileAccess extends AbstractFileAccess {
    private final String displayName;
    private final FileLockManager manager;
    private final File targetFile;

    public OnDemandFileAccess(File targetFile, String displayName, FileLockManager manager) {
        this.targetFile = targetFile;
        this.displayName = displayName;
        this.manager = manager;
    }

    @Override

    }

    def "writes file from template with binding support"() {
        setup:
        def targetFile = new File(temporaryFolder, "test.out")
        def templateURL = getClass().getResource("SimpleTemplateOperationSpec-binding.template")
        def templateOperation = new SimpleTemplateOperation(templateURL, targetFile, [someBindedValue: new TemplateValue("someTemplateValue")])

        when:
        templateOperation.generate()

            }
            targetFile = file;
        }

        File file = new File(targetFile, paths[paths.length - 1]);
        if (file.exists()) {
            for (int i = 0; i < maxDuplicatedPath; i++) {
                file = new File(targetFile, paths[paths.length - 1] + "_" + i);
                if (!file.exists()) {
                    targetFile = file;
                    break;
                }

        def targetFile = temporaryFolder.file("target.txt")
        def sourceSnapshot = createInitialRootNode(sourceFile.absolutePath, DIRECT)

        when:
        def targetSnapshot = sourceSnapshot.relocate(targetFile.absolutePath, stringInterner)

        then:
        targetSnapshot.present
        targetSnapshot.get().absolutePath == targetFile.absolutePath