task producer(type: InputFileTask) {
                inFile = file("in.txt")
                outFile = layout.buildDirectory.file("out.txt")
            }
            task transformer(type: InputTask) {
                inValue = producer.outFile.map { f -> f.asFile.text as Integer }.map { i -> i + 2 }
                outFile = file("out.txt")
            }
        """
        def input = file("in.txt")

                final Property<Integer> inValue = project.objects.property(Integer)
                @OutputFile
                final RegularFileProperty outFile = project.objects.fileProperty()
                @TaskAction
                def go() {
                    outFile.get().asFile.text = (inValue.get() + 10) as String
                }
            }
        """
    }

    def taskTypeWithInputListProperty() {

                private final RegularFileProperty outFile = getProject().getObjects().fileProperty();

                @OutputFile
                public RegularFileProperty getOutFile() {
                    return outFile;
                }

                @TaskAction
                public void run() throws IOException {
                    Files.write(outFile.get().getAsFile().toPath(), "content".getBytes());
                }

			}
			select {
			case <-ctx.Done():
			case gotFile, ok := <-resps[i]:
				if !ok {
					continue
				}
				if gotFile.Error != "" || !gotFile.Exists {
					continue
				}
				if gotFile.File != wantFile || gotFile.Bucket != req.Bucket || gotFile.Prefix != req.Prefix {
					continue
				}
				quorum++
				if toAdd.Modtime.After(gotFile.Modtime) || len(gotFile.Data) < len(toAdd.Data) {

            class SomePlugin: Plugin<Project> {
                override fun apply(project: Project) {
                    project.tasks.register("producer", ProducerTask::class.java) {
                        outFile.set(project.layout.buildDirectory.file("intermediate.txt"))
                    }
                }
            }
        """
        taskDefinition()
    }

    @Override

                if (entry.isDirectory()) {
                    continue;
                }
                File outFile = new File(unzipDir, safePathName(entry.getName()));
                Files.createParentDirs(outFile);
                try (FileOutputStream outputStream = new FileOutputStream(outFile)) {
                    IOUtils.copyLarge(inputStream, outputStream);
                }
            }
        }
    }

        taskTypeWithInputFileProperty()
        buildFile << """
            apply plugin: SomePlugin
            task consumer(type: InputFileTask) {
                inFile = producer.outFile
                outFile = file("out.txt")
            }
        """

        when:
        run("consumer")

        then:
        result.ignoreBuildSrc.assertTasksExecuted(":producer", ":consumer")

            import ${OutputFile.name}

            abstract class ProducerTask: DefaultTask() {
                @get:OutputFile
                abstract val outFile: RegularFileProperty

                @TaskAction
                fun run() {
                    outFile.get().asFile.writeText("content")
                }
            }
        """
    }

    @Override
    void taskWithNestedBeanDefinition() {

        taskTypeWithIntInputProperty()
        buildFile << """
            tasks.register("b", InputTask) {
                inValue = outFile.locationOnly.map { it.asFile.name.length() }
                outFile = file("out.txt")
            }
        """

        when:
        run("b")

        then:
        result.assertTasksExecuted(":b")

        outFile.text == "abc"
    }

    def "can ignore missing file when copying to file"() {
        def file = tmpDir.file("missing")
        def outFile = tmpDir.file("out")

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())
        def result = resource.writeToIfPresent(outFile)
        result == null
        !outFile.exists()
    }