super(taskDependencyFactory);
    }

    private FileCollectionInternal delegate;

    @Override
    protected void visitChildren(Consumer<FileCollectionInternal> visitor) {
        if (delegate == null) {
            delegate = (FileCollectionInternal) createDelegate();
        }
        visitor.accept(delegate);
    }

        if (sources instanceof FileCollectionInternal) {
            return (FileCollectionInternal) sources;
        }
        if (isEmptyArray(sources)) {
            return FileCollectionFactory.empty();
        }
        return resolving(FileCollectionInternal.DEFAULT_COLLECTION_DISPLAY_NAME, providerResolutionStrategy, sources);
    }

    @Override
    public FileCollectionInternal fixed(File... files) {

                if (expected instanceof FileCollectionInternal) {
                    FileCollectionInternal collection = (CompositeFileCollection) expected;
                    List<Object> collections = new ArrayList<>();
                    collection.visitStructure(new FileCollectionStructureVisitor() {
                        @Override
                        public void visitCollection(FileCollectionInternal.Source source, Iterable<File> contents) {

import org.gradle.api.internal.file.FileCollectionInternal;

import java.util.function.Consumer;

public class PropertyFileCollection extends CompositeFileCollection {
    private final String ownerDisplayName;
    private final String type;
    private final String propertyName;
    private final FileCollectionInternal files;
    private String displayName;

import org.gradle.api.internal.file.FileCollectionInternal;
import org.gradle.internal.operations.BuildOperationQueue;
import org.gradle.internal.operations.RunnableBuildOperation;

public class EndCollection implements ResolvedArtifactSet.Artifacts {
    private final FileCollectionInternal.Source source;

    public EndCollection(FileCollectionInternal.Source source) {
        this.source = source;
    }

    }

    def "can replace one of the source collections"() {
        def source1 = Mock(FileCollectionInternal)
        def source2 = Mock(FileCollectionInternal)
        def source3 = Mock(FileCollectionInternal)
        def source4 = Mock(FileCollectionInternal)

        def collection = newUnionFileCollection(source1, source2)

        when:

    private class DependencyGraph implements DirectedGraph<Object, FileCollectionInternal> {
        @Override
        public void getNodeValues(Object node, Collection<? super FileCollectionInternal> values, Collection<? super Object> connectedNodes) {
            if (node instanceof FileCollectionInternal) {
                FileCollectionInternal fileCollection = (FileCollectionInternal) node;
                values.add(fileCollection);

import org.gradle.api.artifacts.component.ProjectComponentIdentifier
import org.gradle.api.internal.attributes.AttributeContainerInternal
import org.gradle.api.internal.file.FileCollectionInternal
import org.gradle.api.internal.tasks.TaskDependencyResolveContext
import org.gradle.internal.Describables
import org.gradle.internal.Try
import org.gradle.internal.component.external.model.ImmutableCapabilities

        1 * resolver.resolve(path) >> file
        1 * context.accept(_) >> { FileCollectionInternal collection ->
            collection.files == [file] as Set
        }
        0 * context._
    }

    def "recursively resolves return value of a Closure"() {
        def fileCollection = Mock(FileCollectionInternal)

        when:
        visitor.add { fileCollection }

        then:
        1 * context.accept(fileCollection)

 */

package org.gradle.api.internal.artifacts.ivyservice;

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedFileVisitor;
import org.gradle.api.internal.file.FileCollectionInternal;
import org.gradle.api.internal.file.FileCollectionStructureVisitor;

import java.io.File;
import java.util.LinkedHashSet;
import java.util.Set;