File outputFile = new File(outputPath);
                        outputFiles.put(outputPath, OutputKind.OUTPUT);
                        File outputFileParent = outputFile.getParentFile();
                        while (outputFileParent != null) {
                            String parentPath = outputFileParent.getPath();
                            if (outputFiles.getIfPresent(parentPath) != null) {

        def outputFiles = []

        def outputDir = temporaryFolder.createDir("rootDir")
        outputFiles << outputDir.file("some-output.txt")

        def subDir = outputDir.createDir("subDir")
        outputFiles << subDir.file("in-subdir.txt")

        def outputFile = temporaryFolder.createFile("output.txt")
        outputFiles << outputFile

        outputFiles.each {

    }

    MutableUnitOfWorkBuilder withOutputFiles(File... outputFiles) {
        return withOutputFiles((outputFiles as List)
            .withIndex()
            .collectEntries { outputFile, index -> [('defaultFiles' + index): outputFile] }
        )
    }

    MutableUnitOfWorkBuilder withOutputFiles(Map<String, ? extends File> files) {
        this.outputFiles = files
        return this
    }

                @Internal
                FileCollection outputFiles

                public TaskWithOutputs() {
                    sources = project.files().from { input }
                    outputFiles = project.files().from { output }
                }

                @TaskAction
                void doSomething() {
                    outputFiles.each { outputFile ->

    def outputFiles = new TestInMemoryIndexedCache<String, DefaultOutputFilesRepository.OutputKind>(new BaseSerializerFactory().getSerializerFor(DefaultOutputFilesRepository.OutputKind))
    def cacheAccess = Stub(PersistentCache) {
        createIndexedCache(_) >> outputFiles
    }
    def cacheDecorator = Mock(CacheDecorator)

        outputDirectories.add(outputDir);
        return outputDir;
    }

    @Override
    public File file(Object path) {
        File outputFile = resolveAndRegister(path, location -> GFileUtils.mkdirs(location.getParentFile()));
        outputFiles.add(outputFile);
        return outputFile;
    }

    private File resolveAndRegister(Object path, Consumer<File> prepareOutputLocation) {
        File output = resolver.resolve(path);

        List<ExecutionOutput> outputFiles = new ArrayList<>();
        for (File executionDir : getOutputsDir().listFiles()) {
            if (executionDir.isDirectory()) {
                outputFiles.add(new ExecutionOutput(new File(executionDir, "output.txt"), new File(executionDir, "error.txt")));
            }
        }
        return outputFiles;
    }

    public List<ExecutionResult> succeeds() {

            if (backendErrors.isNotEmpty()) {
                return KaCompilationResult.Failure(backendErrors)
            }

            val outputFiles = state.factory.asList().map(::KaCompiledFileForOutputFile)
            return KaCompilationResult.Success(outputFiles, capturedValues = emptyList())
        } finally {
            state.destroy()
        }
    }

    def "tasks inputs and outputs are wired correctly"() {
        when:
        container.a.required = aEnabled
        container.b.required = bEnabled

        then:
        outputFiles*.name == fileNames
        inputPropertyValue == names

        where:
        aEnabled | bEnabled | fileNames  | names
        true     | true     | ["a", "b"] | ["a", "b"]

 * are different to when the task was last run.</p>
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface OutputFile {