package org.gradle.api.internal.file.collections;

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

/**
 * A minimal file set.
 */
public interface MinimalFileSet extends MinimalFileCollection {
    Set<File> getFiles();

            .setTestDirectories(buildSourceDirectories(ideaModule.getTestSources().getFiles(), ideaModule.getGeneratedSourceDirs()))
            .setResourceDirectories(buildSourceDirectories(ideaModule.getResourceDirs(), ideaModule.getGeneratedSourceDirs()))
            .setTestResourceDirectories(buildSourceDirectories(ideaModule.getTestResources().getFiles(), ideaModule.getGeneratedSourceDirs()))

    @TaskAction
    public void createHashes() {
        WorkQueue workQueue = getWorkerExecutor().noIsolation(); // <2>

        for (File sourceFile : getSource().getFiles()) {
            Provider<RegularFile> md5File = getDestinationDirectory().file(sourceFile.getName() + ".md5");
            workQueue.submit(GenerateMD5.class, parameters -> { // <3>

    @Override
    public void artifactInstalling(RepositoryEvent event) {
        logger.info("Installing {} to {}", event.getArtifact().getFile(), event.getFile());
    }

    @Override
    public void metadataInstalling(RepositoryEvent event) {
        logger.debug("Installing {} to {}", event.getMetadata(), event.getFile());
    }

    @Override
    public void metadataResolved(RepositoryEvent event) {

    }

    public File getFile() {
        return new FileVisitDetailsImpl(fileName, contentWriter, fileSystem).getFile();
    }

    private File createFileInstance(String fileName) {
        return new File(getTmpDir(), fileName);
    }

    @Override
    public DirectoryFileTree getMirror() {
        return new DirectoryFileTree(getFile(), new PatternSet(), fileSystem);
    }

    @Override

import java.io.File;

/**
 * Represents an artifact that can be resolved. Call {@link #getFile()} or {@link ResolvedArtifact#getFile()} to resolve.
 */
public interface ResolvableArtifact extends TaskDependencyContainer {
    ComponentArtifactIdentifier getId();

    /**
     * Should this artifact be resolved synchronously? For example, is the result of {@link #getFile()} available in memory or can it be calculated quickly without IO calls?
     */

        this(tree, fileCollection -> {}, taskDependencyFactory, patternSetFactory);
    }

    @Override
    public Set<File> getFiles() {
        listener.fileCollectionObserved(this);
        return super.getFiles();
    }

    public MinimalFileTree getTree() {
        return tree;
    }

    @Override
    public String getDisplayName() {

package org.gradle.nativeplatform.fixtures.app

import org.gradle.integtests.fixtures.SourceFile
import org.gradle.test.fixtures.file.TestFile

abstract class TestNativeComponent extends SourceElement {
    List<SourceFile> getFiles() {
        return sourceFiles + headerFiles
    }

    abstract List<SourceFile> getSourceFiles()

    abstract List<SourceFile> getHeaderFiles()

    void writeSources(TestFile sourceDir) {

        }

        @Override
        public Set<File> getFiles() {
            return Collections.emptySet();
        }

        @Override
        @Deprecated
        public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
            DeprecationLogger.deprecateMethod(LenientConfiguration.class, "getFiles(Spec)")

        server.expectPut(getPath(), username, password, getFile())
    }

    void expectPut(Integer statusCode = 200, PasswordCredentials credentials = null) {
        server.expectPut(getPath(), getFile(), statusCode, credentials)
    }

    void expectPutBroken(Integer statusCode = 500) {
        server.expectPut(getPath(), getFile(), statusCode, null)
    }

    abstract TestFile getFile();