then:
        file.length() == 5
        file.seek(0)
        file.readInt() == 123
        file.readByte() == 12

        when:
        stream = output.start(0)
        stream.writeInt(321)
        output.done()

        then:
        file.length() == 5
        file.seek(0)
        file.readInt() == 321
        file.readByte() == 12
    }

    def "can start writing beyond end of file"() {
        when:

    TestFile missingFile

    def setup() {
        jarFile1 = file("dir/libs/library-a.jar")
        jarFile1 << "JAR file #1"
        jarFile2 = file("dir/libs/library-b.jar")
        jarFile2 << "JAR file #2"
        resources = file("dir/resources")
        resources.file("input.txt") << "main input"
        resources.file("a/input-1.txt") << "input #1"
        resources.file("b/input-2.txt") << "input #2"
        emptyRootDir = file("empty-dir")

                    throw new InvalidUserDataException(String.format("File '%s' does not exist.", file));
                }
                if (!file.isFile()) {
                    throw new InvalidUserDataException(String.format("File '%s' is not a file.", file));
                }
                break;
            case DIRECTORY:
                if (!file.exists()) {

        public void stopVisiting() {
            // only one file
        }

        @Override
        public File getFile() {
            if (file == null) {
                file = createFileInstance(fileName);
                if (!file.exists()) {
                    fileGenerationListener.execute(file);
                    copyTo(file);
                } else {

    }

    def "can set value using absolute file provider"() {
        given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()
        prop.fileProvider(Providers.of(file))

        expect:
        prop.get().asFile == file
    }

    def "can set value using relative file provider"() {
        given:
        def file = new File("thing")

        List<File> sortedFiles = Lists.newArrayList(files);
        Collections.sort(sortedFiles, FILE_SEGMENT_COMPARATOR);
        List<File> result = Lists.newArrayListWithExpectedSize(sortedFiles.size());

        File currentRoot = null;
        for (File file : sortedFiles) {
            if (currentRoot == null || !doesPathStartWith(file.getPath(), currentRoot.getPath())) {

        TestFile file1 = testDir.file("f1").createFile()
        TestFile dir1 = testDir.file("dir1").createDir()
        TestFile file2 = dir1.file("f2").createFile()
        TestFile missing = testDir.file("f3")
        testDir.file("f2").createFile()
        testDir.file("ignored1").createFile()
        dir1.file("f1").createFile()
        dir1.file("ignored1").createFile()

        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")
                inputs.file("linked-dir/input.txt")
                outputs.file(outputFile)

                doLast {

    }

    public static ClassPath of(Iterable<File> files) {
        if (files == null) {
            return EMPTY;
        } else if (files instanceof Collection) {
            return of((Collection<File>) files);
        } else {
            List<File> list = new ArrayList<File>();
            for (File file : files) {
                list.add(file);
            }
            return of(list);
        }
    }

                sources = file("sources")
                outputDir = file("build/output")
            }

            task consumer(type: Consumer) {
                inputDirectory = sourceTask.outputDir
                outputFile = file("build/consumer.txt")
            }
        """

        def sourcesDir = file("sources")
        def sourceFile = sourcesDir.file("source.txt").createFile()