[[project_root]]
== Project Root directory

The project root directory contains all source files from your project.

It also contains files and directories Gradle generates, such as `.gradle` and `build`.

/**
 * Utility class for dealing with cache directories.
 */
class CacheDirUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(CacheDirUtil.class);

    /**
     * Mark a directory as a cache directory. This typically involves setting attributes or creating files in it.
     */
    public static void tryMarkCacheDirectoryByTag(Path dir) {
        if (!Files.isDirectory(dir)) {
            return;
        }

    /**
     * Returns the directory to generate TAR and ZIP archives into.
     *
     * @return The directory. Never returns null.
     *
     * @since 6.0
     */
    public abstract DirectoryProperty getDistsDirectory();

    /**
     * Returns the directory to generate JAR and WAR archives into.
     *
     * @return The directory. Never returns null.
     *
     * @since 6.0
     */

                settings.buildCache {
                    local {
                        directory = '$cacheDir'
                    }
                }
            }
        """
        settingsFile << """
            buildCache {
                local {
                    directory = "wrong"
                }
            }
        """
        buildFile << customTaskCode()

        this.path = path;
        this.directory = directory;
        this.excludes = excludes;
        this.includes = includes;
        this.output = output;
    }

    @Override
    public String toString() {
        return "source directory '" + path + "'";
    }

    public File getDirectory() {
        return directory;
    }

    public String getPath() {
        return path;

/**
 * A builder for {@link DirectorySnapshot}.
 *
 * In order to build a directory snapshot, you need to call the methods for entering/leaving a directory
 * and for visiting leaf elements.
 * The visit methods need to be called in depth-first order.
 * When leaving a directory, the builder will create a {@link DirectorySnapshot} for the directory,
 * calculating the combined hash of the entries.
 */

        0 * _

        where:
        type      | preExistsAs
        FILE      | "file"
        FILE      | "dir"
        FILE      | "none"
        DIRECTORY | "file"
        DIRECTORY | "dir"
        DIRECTORY | "none"
    }

    def "can pack single tree file with #type name"() {
        def sourceOutputFile = temporaryFolder.file("source.txt")
        sourceOutputFile << "output"

 * to the same expanded directory.
 *
 * Multiple threads are allowed to extract into different expanded directories concurrently.
 * <p>
 * There currently are no checks on modifications to files in the expanded directory. This can cause problems if the expanded directory is used

    String JAR_TYPE = "jar";

    /**
     * Represents a directory tree containing class files.
     *
     * @since 4.0
     */
    String JVM_CLASS_DIRECTORY = "java-classes-directory";

    /**
     * Represents a directory tree containing jvm classpath resource files.
     *
     * @since 4.0
     */
    String JVM_RESOURCES_DIRECTORY = "java-resources-directory";

    /**
     * Represents a zip file
     *

        result.local.config.removeUnusedEntriesAfter == "7 days"
        result.local.type == 'directory'
        result.local.push == true

        result.remote == null
    }

    def "custom build cache connector configuration is exposed"() {
        given:
        def type = 'CustomBuildCache Desc'
        def directory = 'someLocation'
        settingsFile << """