}

    def "arguments can be passed by using argument providers"() {
        given:
        def inputFile = file("input.txt")
        def outputFile = file("out.txt")
        buildFile << """
            abstract class MyApplicationJvmArguments implements CommandLineArgumentProvider {
                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                abstract RegularFileProperty getInputFile()

            class CustomTask extends DefaultTask {
                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                File inputFile

                @OutputFile File outputFile

                @TaskAction void doSomething() {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = inputFile.text + '$suffix'
                }
            }

        def inputFileName = "input.txt"
        def inputFile = file(inputFileName)
        inputFile << 'content'

        def outputDirectory = new File(drive)

        def taskName = 'outputFromFilesystemRoot'
        def script = """
            class InputFileToOutputDirectoryCopyAction extends DefaultTask {
                @InputFile File input
                @OutputDirectory File outputDirectory

                extension = "";
            }
        } else {
            filePrefix = "none";
            extension = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {
            inputFile = File.createTempFile("jodextin_" + filePrefix + "_", StringUtil.isNotBlank(extension) ? "." + extension : extension,
                    tempDir);

     */
    @PathSensitive(PathSensitivity.NONE)
    @InputFiles
    public ConfigurableFileCollection getExecutionData() {
        return executionData;
    }

    /**
     * Source sets that coverage should be reported for.
     */
    @IgnoreEmptyDirectories
    @PathSensitive(PathSensitivity.RELATIVE)
    @InputFiles
    public ConfigurableFileCollection getSourceDirectories() {

                PropertyValue value,
                InputFilePropertyType filePropertyType
            ) {
                inputFiles[propertyName] = value.call()
            }
        })
        return inputFiles
    }

public class FileUtilTest {

    URL url = ResourceUtil.getResource(getClass().getName().replace('.', '/') + ".txt");

    File inputFile = URLUtil.toFile(url);

    /**
     * @throws Exception
     */
    @Test
    public void testFileToFile() throws Exception {
        final byte[] bytes = readBytes(inputFile);
        assertThat(bytes, is("あいうえお".getBytes("UTF-8")));
    }

    /**
     * @throws Exception
     */

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void run() {
                    outputFile.get().asFile.text = inputFiles.files.collect { it.text }.join()
                }
            }

    def "changes are detected when parent of input is symlinked"() {
        def targetDir = file("target")
        def inputFile = targetDir.file("input.txt")
        def linkedDir = file("linked-dir").createLink(targetDir)

        inputFile.text = "original"

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")

    def "filter predicates and matching patterns are evaluated lazily"() {
        given:
        buildFile """
            abstract class PrintInputs extends DefaultTask {

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

                @TaskAction
                def printInputs() {
                    getInputFiles().files.each {