}
    }

    def 'paths ignored in file system checks are included in the configuration cache fingerprint'() {
        when:
        configurationCacheRun()
        configurationCacheRun("-D$IGNORE_FS_CHECKS_PROPERTY=test")

        then:
        outputContains("the set of paths ignored in file-system-check input tracking has changed")
    }

     * The ordered list of the flattened dependency nodes.
     */
    private final List<Node> nodes;

    /**
     * The file paths of all dependencies, regardless on which Java tool option those paths should be placed.
     */
    private final List<Path> paths;

    /**
     * The file paths of all dependencies, dispatched according the Java options where to place them.
     */

    kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment,
    paths: Collection<Path>,
): List<T> {
    val fs = kotlinCoreProjectEnvironment.environment.localFileSystem
    val psiManager = PsiManager.getInstance(kotlinCoreProjectEnvironment.project)
    return buildList {
        for (path in paths) {
            val vFile = fs.findFileByNioFile(path.toAbsolutePath()) ?: continue

        MavenSession ms = new MavenSession(null, rss, mer, null);
        ms.getRequest().setRootDirectory(Paths.get("myRootDirectory"));
        DefaultSession session =
                new DefaultSession(ms, mock(RepositorySystem.class), Collections.emptyList(), null, null, null);

        assertEquals(Paths.get("myRootDirectory"), session.getRootDirectory());
    }

        then:
        directories.size() == 1
        directories[0].location == expectedFile
        directories[0].source == "Gradle property 'org.gradle.java.installations.paths'"
    }

    def "supplies multiple installations for multiple paths"() {
        when:
        def expectedFile1 = tmpDir.createDir("foo/bar")
        def expectedFile2 = tmpDir.createDir("foo/123")

            if (StringUtil.isNotBlank(getIncludedDocPaths())) {
                final List<Pattern> pathPatterList = new ArrayList<>();
                final String[] paths = getIncludedDocPaths().split("[\r\n]");
                for (final String u : paths) {
                    final String v = systemHelper.normalizeConfigPath(u);
                    if (StringUtil.isNotBlank(v)) {

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.model.path;

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

    }

    @Override
    public ConfigurableFileCollection files(Object... paths) {
        return fileOperations.configurableFiles(paths);
    }

    @Override
    public ConfigurableFileCollection files(Object paths, Closure configureClosure) {
        return ConfigureUtil.configure(configureClosure, files(paths));
    }

    @Override
    public String relativePath(Object path) {

                    DefaultJvm(JvmVersion.java22, JvmVendor.openjdk),
                )
        }.joinToString(",") { javaHome(it, this, arch) }
        return """"-Porg.gradle.java.installations.paths=$paths""""
    }

                }
            }
        }
    }

    private
    fun maybeCreateJointRegexForPatterns(paths: String?, isCaseSensitive: Boolean) =
        if (paths.isNullOrEmpty()) {
            null
        } else {
            paths.split(PATHS_SEPARATOR).joinToString("|") {
                wildcardsToRegexPatternString(normalizeFilePattern(it))