def beforeExecutionState = Mock(BeforeExecutionState)
    def outputSnapshotter = Mock(OutputSnapshotter)
    def outputFilter = Mock(AfterExecutionOutputFilter)
    def delegateResult = Stub(Result)

    def step = new CaptureOutputsAfterExecutionStep<>(buildOperationRunner, buildInvocationScopeId, outputSnapshotter, outputFilter, delegate)

    def "no state is captured if cache key calculated state is unavailable"() {

                ext = outputExtension;
            }
            outputFile = File.createTempFile("cmdextout_" + filePrefix + "_", ext, tempDir);

            // store to a file
            CopyUtil.copy(in, inputFile);

            executeCommand(inputFile, outputFile);

            final ExtractData extractData = new ExtractData(new String(FileUtil.readBytes(outputFile), outputEncoding));

    inputFiles.add(producerOne.get().outputFile)
    inputFiles.add(producerTwo.get().outputFile)
}

// Set values for the producer tasks lazily
// Don't need to update the consumer.inputFiles property. This is automatically updated as producer.outputFile changes
producerOne.configure { outputFile = layout.buildDirectory.file('one.txt') }
producerTwo.configure { outputFile = layout.buildDirectory.file('two.txt') }

    inputFile = producer.flatMap { it.outputFile }
}

producer {
    // Set values for the producer lazily
    // Don't need to update the consumer.inputFile property. This is automatically updated as producer.outputFile changes
    outputFile = layout.buildDirectory.file("file.txt")
}

// Change the build directory.

        buildFile << '''
            task customTask(type: CustomTask) {
                outputFile = file("$buildDir/outputFile")
                content = providers.gradleProperty('content').getOrElse(null)
            }

            class CustomTask extends DefaultTask {
                @OutputFile
                File outputFile

                @Input
                String content

                @TaskAction

    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.readText() }

                ext.outputFile = file('customDocs.html')
                def outputFile = outputFile
                doLast {
                    outputFile << '<html/>'
                }
            }

            task regularFileTask {
                ext.outputFile = project.objects.fileProperty()
                outputs.file(outputFile)
                outputFile.set(file('regularFile-1.0.reg'))

                        parameters.compressedFile.set(inputFile)
                        parameters.textFile.set(outputFile)
                    }
                }
            }

            tasks.register("myTask", MyTask) {
                inputFile.set(createArchive.flatMap { it.outputFile })
                outputFile.set(layout.buildDirectory.file("unpacked/file.txt"))
            }
        """

        when:

    def taskTypeWithMultipleOutputFiles() {
        buildFile << """
            // Not using properties
            class OutputFilesTask extends DefaultTask {
                @OutputFile
                File out1
                @OutputFile
                File out2
                @TaskAction
                def go() {
                    out1.text = "1"
                    out2.text = "2"
                }

    private File binaryFile;
    private File outputFile;

    @Override
    public File getBinaryFile() {
        return binaryFile;
    }

    @Override
    public void setBinaryFile(File binaryFile) {
        this.binaryFile = binaryFile;
    }

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

    @Override