* 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");

    }

    /**
     * The base directory for all reports
     * <p>
     * This value can be changed, so any files derived from this should be calculated on demand.
     *
     * @return The base directory for all reports
     */
    public File getBaseDir() {
        return baseDirectory.getAsFile().get();
    }

    /**
     * Sets the base directory to use for all reports
     *

    private File directory;

    private boolean generated;

    public File getDirectory() {
        return directory;
    }

    public boolean isGenerated() {
        return generated;
    }

    public DefaultIdeaSourceDirectory setDirectory(File directory) {
        this.directory = directory;
        return this;
    }

[[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()