configDump, err := io.ReadAll(configDumpFile)
	if err != nil {
		t.Errorf("error reading test data file: %v", err)
	}

	outFile, err := os.Open("testdata/secret/output")
	if err != nil {
		t.Errorf("error opening test data output file: %v", err)
	}
	defer outFile.Close()
	expectedOut, err := io.ReadAll(outFile)
	if err != nil {
		t.Errorf("error reading test data output file: %v", err)
	}

	gotOut := &bytes.Buffer{}

                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")

openssl x509 -req -in client.csr -CA caCert.pem -CAkey caKey.pem -CAcreateserial -out clientCert.pem -days 100000 -extensions v3_req -extfile client.conf

outfile=certs_test.go

cat > $outfile << EOF
/*
Copyright 2016 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.

            import ${OutputFile.name}

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

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

    @Override
    void taskWithNestedBeanDefinition() {

                @Inject abstract ArchiveOperations getArchives()
                @TaskAction def action() {
                    def outFile = outputFile.get().asFile
                    outFile.parentFile.mkdirs()
                    outFile.text = archives.${archiveType}(inputFile.get().asFile).read().text
                }
            }

            tasks.register("myTask", MyTask) {

        buildFile << """
            task foo {
                def outFile = project.file("out.txt")
                outputs.file(outFile)
                doLast {
                    if (outFile.exists()) {
                        throw new RuntimeException("Boo!")
                    }
                    outFile << "xxx"
                }
            }
        """

        expect:

            import ${OutputFile.name}

            class ProducerTask extends DefaultTask {
                @OutputFile
                final RegularFileProperty outFile = project.objects.fileProperty()

                @TaskAction
                def run() {
                    outFile.get().asFile.text = "content"
                }
            }
        """
    }

    @Override
    boolean nestedGetterIsFinal() {
        true

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.register("producer", ProducerTask) {
                        outFile = project.layout.buildDirectory.file("intermediate.txt")
                    }
                }
            }
        """
        taskDefinition()
    }

    @Override

            import ${OutputFile.name}

            open class ProducerTask: DefaultTask() {
                @OutputFile
                val outFile: RegularFileProperty = project.objects.fileProperty()

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

    @Override