import org.gradle.api.artifacts.component.ComponentIdentifier
import org.gradle.api.internal.file.FileCollectionInternal
import org.gradle.api.tasks.TaskDependency
import spock.lang.Specification

class DefaultFileCollectionDependencyTest extends Specification {
    private final FileCollectionInternal source = Mock()
    private final ComponentIdentifier targetComponent = Mock()

        result.converted(dependency);
    }

    private FileCollectionDependency create(final DependencyFactoryInternal.ClassPathNotation notation) {
        FileCollectionInternal fileCollectionInternal;
        if (notation.equals(GRADLE_API)) {
            fileCollectionInternal = fileCollectionFactory.create(new GeneratedFileCollection(notation.displayName) {
                @Override
                Set<File> generateFileCollection() {

                public void visit(ArtifactVisitor visitor) {
                    if (visitor.prepareForVisit(FileCollectionInternal.OTHER) == FileCollectionStructureVisitor.VisitType.Visit) {
                        ((ArtifactVisitorToResolvedFileVisitorAdapter) visitor).visitFile(file);
                        visitor.endVisitCollection(FileCollectionInternal.OTHER);
                    }
                }
            });
        }

    private final ComponentIdentifier targetComponentId;
    private final FileCollectionInternal source;

    public DefaultFileCollectionDependency(FileCollectionInternal source) {
        this.targetComponentId = null;
        this.source = source;
    }

    public DefaultFileCollectionDependency(ComponentIdentifier targetComponentId, FileCollectionInternal source) {
        this.targetComponentId = targetComponentId;

    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        // Assume no dependencies
    }

    @Override
    public FileCollectionInternal replace(FileCollectionInternal original, Supplier<FileCollectionInternal> supplier) {
        if (original == this) {
            return supplier.get();
        }
        return this;
    }

    @Override

    def "EmptyFileCollections with default display name produce the same execution time value"() {
        given:
        def collection1 = new EmptyFileCollection(FileCollectionInternal.DEFAULT_COLLECTION_DISPLAY_NAME)
        def collection2 = new EmptyFileCollection(FileCollectionInternal.DEFAULT_COLLECTION_DISPLAY_NAME)

        when:
        def executionTimeValue1 = collection1.calculateExecutionTimeValue()

import com.google.common.collect.ImmutableSet;

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

final class EmptyFileCollection extends AbstractFileCollection {
    public static final FileCollectionInternal INSTANCE = new EmptyFileCollection(DEFAULT_COLLECTION_DISPLAY_NAME);

    private final String displayName;

    public EmptyFileCollection(String displayName) {
        this.displayName = displayName;
    }

import org.gradle.api.file.FileCollection
import org.gradle.api.internal.artifacts.transform.DefaultTransformUpstreamDependenciesResolver
import org.gradle.api.internal.file.FileCollectionInternal
import org.gradle.api.internal.tasks.TaskDependencyResolveContext
import org.gradle.internal.serialize.graph.Codec
import org.gradle.internal.serialize.graph.ReadContext

import org.gradle.api.internal.artifacts.configurations.ArtifactCollectionInternal;
import org.gradle.api.internal.artifacts.configurations.ResolutionResultProvider;
import org.gradle.api.internal.file.FileCollectionInternal;
import org.gradle.api.provider.Provider;

/**
 * Internal counterpart of {@link ResolutionOutputs} that exposes the results as

    }

    private
    inner class FileTreeVisitor : FileCollectionStructureVisitor {
        var roots = mutableListOf<FileTreeSpec>()

        override fun startVisit(source: FileCollectionInternal.Source, fileCollection: FileCollectionInternal): Boolean = when {
            fileCollection is FileTreeAdapter -> {
                toSpecOrNull(fileCollection.tree)?.let {
                    roots.add(it)
                    false