* Task output caching will be disabled if the outputs contain file trees.
 * </p>
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface OutputFiles {

    enum OutputKind {
        OUTPUT,
        PARENT_OF_OUTPUT
    }
    private final IndexedCache<String, OutputKind> outputFiles;

    public DefaultOutputFilesRepository(PersistentCache cacheAccess, InMemoryCacheDecoratorFactory inMemoryCacheDecoratorFactory) {
        this.cacheAccess = cacheAccess;
        this.outputFiles = cacheAccess.createIndexedCache(cacheParameters(inMemoryCacheDecoratorFactory));
    }

    @Override

        Map<String, ? extends File> outputFiles,
        Map<String, ? extends File> outputDirs,
        Collection<? extends TestFile> create,

        InputFingerprinter inputFingerprinter,
        ExecutionHistoryStore executionHistoryStore
    ) {
        this.inputProperties = inputProperties
        this.inputFiles = inputFiles
        this.outputFiles = outputFiles
        this.outputDirs = outputDirs

        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 {

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

        } else {
            FileCollectionInternal outputFiles = fileCollectionFactory.resolving(unpackedValue);
            DefaultCacheableOutputFilePropertySpec filePropertySpec = new DefaultCacheableOutputFilePropertySpec(propertyName, null, outputFiles, filePropertyType.getOutputType());
            consumer.accept(filePropertySpec);
        }
    }

                @Internal
                FileCollection outputFiles

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

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

    public DefaultCacheableOutputFilePropertySpec(
        String propertyName,
        @Nullable String propertySuffix,
        FileCollectionInternal outputFiles,
        TreeType outputType
    ) {
        super(propertyName, OutputNormalizer.INSTANCE, outputFiles);
        this.propertySuffix = propertySuffix;
        this.outputType = outputType;
    }

    @Override
    public String getPropertyName() {

 */
package org.gradle.api.internal.tasks.properties.annotations;

import org.gradle.api.tasks.OutputFiles;
import org.gradle.internal.properties.OutputFilePropertyType;

public class OutputFilesPropertyAnnotationHandler extends AbstractOutputPropertyAnnotationHandler {
    public OutputFilesPropertyAnnotationHandler() {
        super(OutputFiles.class, OutputFilePropertyType.FILES);
    }

        File file1 = file('someDir/test1.txt')
        File outputFile = file('someDir/test2.txt')
        def outputFiles = TestFiles.fixed(outputFile)


        when:
        registry.registerOutputs(dir1)
        registry.registerOutputs(file1)
        registry.registerOutputs(outputFiles)
        registry.resolveOutputs()

        then:
        registry.isOutputOwnedByBuild(dir1)