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

    public static class TaskWithOutputFiles extends TaskWithAction {
        List<File> outputFiles;

        @Inject
        public TaskWithOutputFiles(List<File> outputFiles) {
            this.outputFiles = outputFiles;
        }

        @OutputFiles
        public List<File> getOutputFiles() {
            return outputFiles;
        }
    }

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

                @OutputFiles
                final SetProperty<RegularFile> outputFiles = project.objects.setProperty(RegularFile)

                @TaskAction
                void go() {
                    def content = inputFile.get().asFile.text
                    outputFiles.get().each { outputFile ->
                        outputFile.asFile.text = content

 */
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)

    private final TransformExecutionResult.OutputTypeInferringBuilder resultBuilder;
    private final Set<File> outputDirectories = new HashSet<>();
    private final Set<File> outputFiles = new HashSet<>();
    private final PathToFileResolver resolver;
    private final File inputArtifact;
    private final File outputDir;

        touch(task.outputFiles.get(0).getParentFile())

        when:
        execute(task)

        then:
        def e = thrown WorkValidationException
        validateException(task, e, cannotCreateParentDirectories {
            property('outputFiles')
                .file(task.outputFiles[0])
                .ancestorIsNotDirectory(task.outputFiles[0].parentFile)
                .includeLink()