assertSetContains(set, filenames as Set, [FileCollection.AntType.FileSet], false)
    }

    static def assertSetContainsForFileSet(FileCollection set, Set<String> filenames) {
        assertSetContains(set, filenames, [FileCollection.AntType.FileSet], false)
    }

    static def assertSetContainsForMatchingTask(FileCollection set, String... filenames) {

    private final TemporaryFileProvider tempFileProvider;
    private final FileCollection fileCollection;
    private final Charset charset;

    public FileCollectionBackedTextResource(TemporaryFileProvider tempFileProvider, FileCollection fileCollection, Charset charset) {
        this.tempFileProvider = tempFileProvider;
        this.fileCollection = fileCollection;
        this.charset = charset;
    }

    @Override

        ResolvableDependency dependency = Mock()
        FileCollectionInternal fileCollection = Mock()

        when:
        context.add(dependency)
        def files = context.resolve()

        then:
        1 * dependency.resolve(context) >> { context.add(fileCollection) }
        files instanceof UnionFileCollection
        files.sources as List == [fileCollection]
    }

    def resolvesADependencyInternal() {

        'FileCollection'             | 'array'          | 'project.layout.files([ "src/resource/file.txt" ] as Object[])'
        'FileCollection'             | 'FileCollection' | "project.layout.files(project.layout.files('src/resource/file.txt'))"
        'FileCollection'             | 'Callable'       | "project.layout.files($STRING_CALLABLE)"

        }
        0 * context._
    }

    def "resolves elements of array"() {
        def fileCollection = Mock(FileCollectionInternal)

        when:
        visitor.add([null, fileCollection] as FileCollection[])

        then:
        1 * context.accept(fileCollection)
        0 * context._
    }

    def "resolves Provider"() {
        def provider = Mock(ProviderInternal)

        when (fileCollection) {
            is SubtractingFileCollection -> {
                // TODO - when left and right are both static then we should serialize the current contents of the collection
                elements.add(SubtractingFileCollectionSpec(fileCollection.left, fileCollection.right))
                false
            }

        });
    }

    @Override
    public ResolutionHost getResolutionHost() {
        return fileCollection.getResolutionHost();
    }

    @Override
    public boolean isLenient() {
        return lenient;
    }

    @Override
    public FileCollection getArtifactFiles() {
        return fileCollection;
    }

    @Override
    public Set<ResolvedArtifactResult> getArtifacts() {
        ensureResolved();

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

                                                   final FileCollection fileCollection,
                                                   final String path, Charset charset) {
        super(tempFileProvider, new LazilyInitializedFileCollection(taskDependencyFactory) {
            @Override
            public String getDisplayName() {
                return String.format("entry '%s' in archive %s", path, fileCollection);
            }

            @Override

 * Sets the ConfigurableFileCollection to contain the source paths of passed collection.
 * This is the same as calling ConfigurableFileCollection.setFrom(fileCollection: FileCollection).
 *
 * @since 8.2
 */
fun ConfigurableFileCollection.assign(fileCollection: FileCollection) {
    this.setFrom(fileCollection)