/**
     * Returns the working directory for the process. Defaults to the project directory.
     *
     * @return The working directory. Never returns null.
     */
    File getWorkingDir();

    /**
     * Sets the working directory for the process.
     *
     * @param dir The working directory. Must not be null.
     * @since 4.0
     */
    void setWorkingDir(File dir);

//
//  6. The payload is written to the new timestamped directory.
//
//  7. Permissions are set (if setPerms is not nil) on the new timestamped directory and files.
//
//  8. A symlink to the new timestamped directory ..data_tmp is created that will
//     become the new data directory.
//
//  9. The new data directory symlink is renamed to the data directory; rename is atomic.
//

/**
 * Configuration object for the local directory build cache.
 *
 * @since 3.5
 */
public abstract class DirectoryBuildCache extends AbstractBuildCache {
    private Object directory;
    private int removeUnusedEntriesAfterDays = 7;

    /**
     * Returns the directory to use to store the build cache.
     */
    @Nullable
    public Object getDirectory() {
        return directory;
    }

    /**

	}

	return &QueueStore[I]{
		directory:  directory,
		entryLimit: limit,
		fileExt:    ext,
		entries:    make(map[string]int64, limit),
	}
}

// Open - Creates the directory if not present.
func (store *QueueStore[_]) Open() error {
	store.Lock()
	defer store.Unlock()

	if err := os.MkdirAll(store.directory, os.FileMode(0o770)); err != nil {
		return err
	}

	files, err := store.list()

    private final S3Server server
    private final TestFile directory
    private String bucket
    private final String path

    S3DirectoryResource(S3Server server, String bucket, TestFile directory) {
        this.bucket = bucket
        this.directory = directory
        this.server = server
        def directoryUri = directory.toURI().toString()

        while (true) {
            File directory = directoriesToDelete.poll();
            if (directory == null) {
                break;
            }
            if (existsAndIsEmpty(directory)) {
                LOGGER.debug("Deleting stale empty output directory '{}'.", directory);
                Files.delete(directory.toPath());
                didWork = true;

     * Check most classical urls inheritance: directory structure where parent POM in parent directory
     * and child directory == artifactId
     * @throws IOException Model read problem
     */
    @Test
    void testUrls() throws Exception {
        testInheritance("urls");
    }

    /**
     * Flat directory structure: parent & child POMs in sibling directories, child directory == artifactId.

import java.io.File;
import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the
     * platform-specific file separator if a base directory is given. Otherwise, the input path will be returned
     * unaltered.
     *

import javax.annotation.Nullable;
import java.util.List;

/**
 * A source directory in an Eclipse project.
 */
public interface EclipseSourceDirectory extends SourceDirectory, EclipseClasspathEntry {
    /**
     * Returns the relative path for this source directory.
     *
     * @return The path for this source directory. Does not return null.
     */
    String getPath();

    /**

            // No build definition, use a cache dir in the user home directory to avoid generating garbage in the root directory
            cacheDir = new File(userHomeDirProvider.getGradleUserHomeDirectory(), UNDEFINED_BUILD + Hashing.hashString(buildLayout.getRootDirectory().getAbsolutePath()));
        } else {
            // Use the .gradle directory in the build root directory
            cacheDir = new File(buildLayout.getRootDirectory(), ".gradle");