public File getOutputFile() {
                    return outputFile;
                }

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

                @Nested
                public Action<File> getAction() {
                    return action;
                }

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")
                inputs.dir("symlink1")
                inputs.dir("symlink2")
                outputs.file(outputFile)

                doLast {
                    outputFile.text = "Hello world"
                }
            }
        """

        when:

                    updateThumbnailField(thumbnailId, StringUtil.EMPTY);
                    if (outputFile.exists() && !outputFile.delete()) {
                        logger.warn("Failed to delete {}", outputFile.getAbsolutePath());
                    }
                }
            }
            return outputFile.exists();
        });

    }

                private LoggingOutput loggingOutput

                OutputProgressService() {
                    // Ensure parameters.outputFile is set before adding ourselves as a listener
                    if (!parameters.outputFile.present) {
                        throw new IllegalStateException("parameters.outputFile is not set")
                    }
                    loggingOutput = objects.newInstance(InternalServices).loggingOutput

    outputFile = layout.buildDirectory.file('file.txt')
}
tasks.register('consumer', Consumer) {
    // Connect the producer task output to the consumer task input
    // Don't need to add a task dependency to the consumer task. This is automatically added
    message = producer.flatMap { it.outputFile }.map { it.asFile.text }

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

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;
    }