this.objectFiles.add(objectFile);
        }
    }

    @Override
    public File getOutputFile() {
        return outputFile;
    }

    @Override
    public void setOutputFile(File outputFile) {
        this.outputFile = outputFile;
    }

public class UnitOfWork implements Runnable {
    private final int index;
    private final File outputFile;

    @Inject
    public UnitOfWork(int index, File outputFile) {
        this.index = index;
        this.outputFile = outputFile;
    }

    @Override
    public void run() {
        try (FileWriter fw = new FileWriter(outputFile)) {
            fw.append("index is " + index + "\n");
        } catch (IOException e) {

        render(model, new ReportRenderer<T, HtmlReportBuilder>() {
            @Override
            public void render(T model, HtmlReportBuilder output) throws IOException {
                output.renderHtmlPage(outputFile.getName(), model, renderer);
            }
        }, outputFile.getParentFile());
    }

    /**

import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction

@CacheableTask
class MyCacheableTask extends DefaultTask {
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    File inputFile
    @OutputFile
    File outputFile

    @TaskAction
    void doSomething() {

    private final Provider<? extends FileSystemLocation> outputFile;
    private final String architectureName;

    public XcodeBinary(String buildConfigurationName, Provider<? extends FileSystemLocation> outputFile, String architectureName) {
        this.buildConfigurationName = buildConfigurationName;
        this.outputFile = outputFile;
        this.architectureName = architectureName;
    }

package org.gradle.internal.operations.logging;

import java.io.File;

class BuildOperationLogInfo {
    private final File outputFile;
    private final int maximumFailures;
    private final String taskName;

    BuildOperationLogInfo(String taskName, File outputFile, int maximumFailures) {
        this.outputFile = outputFile;
        this.maximumFailures = maximumFailures;
        this.taskName = taskName;
    }

            visitor.visitOutputProperty("file", TreeType.FILE, UnitOfWork.OutputFileValueSupplier.fromStatic(outputFile, TestFiles.fixed(outputFile)))
            visitor.visitLocalState(localStateFile)
            visitor.visitDestroyable(destroyableFile)
        }

        then:
        outputDir.assertIsEmptyDir()
        outputFile.parentFile.assertIsEmptyDir()
        localStateFile.parentFile.assertIsEmptyDir()

                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

            abstract class GoodTask extends DefaultTask {
                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction

    ) {
        try {
            ReportRenderer renderer = getRenderer();
            renderer.setClientMetaData(getClientMetaData());
            File outputFile = getOutputFile();
            if (outputFile != null) {
                renderer.setOutputFile(outputFile);
            } else {
                renderer.setOutput(getTextOutputFactory().create(getClass()));
            }
            projectReportHeaderGenerator.execute();

        def outputFile = temporaryFolder.file("output.txt")
        def outputDir = temporaryFolder.file("outputDir")
        def outputDirFile = outputDir.file("file.txt")
        def input = temporaryFolder.createFile("input")
        def entity = entity(
            prop("outputDir", DIRECTORY, outputDir),
            prop("outputFile", FILE, outputFile)
        )