}

    /**
     * Clean up the given stale output files under the given directories.
     *
     * Any files and directories are removed that are descendants of any of the {@code directoriesToClean}.
     * Files and directories outside {@code directoriesToClean} and {@code directoriesToClean} themselves are not deleted.
     *

        buildOptions.installationsFromPaths >> []
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies single installations for single path"() {
        when:
        def expectedFile = tmpDir.createDir("foo/bar")
        buildOptions.installationsFromPaths >> [expectedFile.absolutePath]
        def directories = supplier.get()

        then:

    /**
     * Gets the class directories that coverage will be reported for. All classes in these directories will be included in the report.
     *
     * @return class dirs to report coverage of
     */
    @Internal
    public FileCollection getAllClassDirs() {
        return classDirectories.plus(getAdditionalClassDirs());
    }

    /**

     *
     * <p>
     *     For files in the root of the file collection, the file name is used as the normalized path.
     *     For directories in the root of the file collection, an empty string is used as normalized path.
     *     For files in directories in the root of the file collection, the normalized path is the relative path of the file to the root directory containing it.
     * </p>
     *
     * <br>

     */
    File getRootDirectory();

    /**
     * The set of source directories.
     */
    DomainObjectSet<? extends IdeaSourceDirectory> getSourceDirectories();

    /**
     * The set of test source directories.
     */
    DomainObjectSet<? extends IdeaSourceDirectory> getTestDirectories();

    /**
     * The set of resource directories.

import java.util.function.Predicate;

/**
 * Specifies how a fingerprinter should handle directories that are found in a filecollection.
 */
public enum DirectorySensitivity {
    /**
     * Whatever the default behavior is for the given fingerprinter.  For some fingerprinters, the
     * default behavior is to fingerprint directories, for others, they ignore directories by default.
     */
    DEFAULT(snapshot -> true),
    /**

import java.util.PriorityQueue;
import java.util.function.Predicate;

/**
 * Cleans outputs, removing empty directories.
 *
 * This class should be used when cleaning output directories when only a subset of the files can be deleted.
 * After cleaning up a few output directories, the method {@link #cleanupDirectories()} cleans the directories which became empty.
 *
 * IMPORTANT: This class is stateful, so it can't be used as a service.
 */

     */
    Property<String> getBaseName();

    /**
     * Defines the source files or directories of this component. You can add files or directories to this collection. When a directory is added, all source files are included for compilation.
     *
     * <p>When this collection is empty, the directory {@code src/main/cpp} is used by default.</p>

            require(sourceDirs.isNotEmpty()) {
                "Expected source directories but got none"
            }

            val subprojectSourcePath = "org/gradle/StartParameter.java"
            val subprojectFound = sourceDirs.find { it.resolve(subprojectSourcePath).isFile }
            require(subprojectFound != null) {
                "Source directories do not contain subproject file '${'$'}subprojectSourcePath'. Searched in:\n  " +

            .with { line ->
                def matcher = line =~ /Watched directory hierarchies: \[(.*)]/
                String directories = matcher[0][1]
                return (directories.empty
                    ? []
                    : directories.split(', ').collect { new File(it) }
                ) as Set
            }

        assert watchedHierarchies == (expected as Set)
    }