assertTrue(globalSettingsFile.isFile(), globalSettingsFile.getAbsolutePath());

        try (InputStream is = Files.newInputStream(globalSettingsFile.toPath())) {
            new SettingsStaxReader().read(is, true, new InputSource(globalSettingsFile.getAbsolutePath()));
        }
    }

                List<Path> xsbtiJarsAsPath = Arrays.stream(scalaInstance.allJars()).map(File::toPath).collect(Collectors.toList());
                scala.collection.Iterable<Path> xsbtiJars = JavaConverters.collectionAsScalaIterable(xsbtiJarsAsPath);
                AnalyzingCompiler$.MODULE$.compileSources(sourceJars, bridgeJar.toPath(), xsbtiJars, "compiler-bridge", rawCompiler, logger);

        this.writableCache = writableCache;
    }

    @Override
    public void store(String key, File artifactFile, @Nullable ExternalResourceMetaData metaData) {
        if (artifactFile.toPath().startsWith(readOnlyCachePath)) {
            // skip writing because the file comes from the RO cache
            return;
        }
        writableCache.store(key, artifactFile, metaData);
    }

    @Override

        def javaHome = InstallationLocation.userDefined(jvm.getJavaHome(), "test")
        def metadata = detector.getMetadata(javaHome)

        then:
        metadata.javaHome == jvm.javaHome.toPath()
        metadata.languageVersion == jvm.javaVersion
    }

internal fun compileToNativeKLib(kLibSourcesRoot: Path): Path {
    val ktFiles = Files.walk(kLibSourcesRoot).asSequence().filter { it.extension == "kt" }.toList()
    val testKlib = KtTestUtil.tmpDir("testLibrary").resolve("library.klib").toPath()

    val arguments = buildList {
        ktFiles.mapTo(this) { it.absolutePathString() }
        addAll(listOf("-produce", "library"))
        addAll(listOf("-output", testKlib.absolutePathString()))
    }

class DefaultCachedExternalResourceIndexTest extends Specification {

    @Rule TestNameTestDirectoryProvider folder = new TestNameTestDirectoryProvider(getClass())

    def commonPath = folder.createDir("common").toPath()

    def "value serializer can relativize path"() {
        given:
        def serializer = new DefaultCachedExternalResourceIndex.CachedExternalResourceSerializer(commonPath)
        def encoder = Mock(Encoder)

        buildFile << """
            tasks.withType(JavaExec) {
                executable = new File(".").getCanonicalFile().toPath().relativize(new File("${executable}").toPath()).toString()
            }
        """

        when:
        executer.expectDocumentedDeprecationWarning("Configuring a Java executable via a relative path. " +

        this.writableCache = writableCache;
    }

    @Override
    public void store(ArtifactAtRepositoryKey key, File artifactFile, HashCode moduleDescriptorHash) {
        if (artifactFile.toPath().startsWith(readOnlyCachePath)) {
            // skip writing because the file comes from the RO cache
            return;
        }
        writableCache.store(key, artifactFile,  moduleDescriptorHash);
    }

            if (!temp.renameTo(destination)) {
                try {
                    Files.copy(
                            temp.toPath(),
                            destination.toPath(),
                            StandardCopyOption.REPLACE_EXISTING,
                            StandardCopyOption.COPY_ATTRIBUTES);

                    if (!temp.delete()) {

                addBinaryRoots(libraryRoots.map { it.toPath() })
                libraryName = "Library for $moduleName"
            }
        )
        compilerConfig.get(JVMConfigurationKeys.JDK_HOME)?.let { jdkHome ->
            addRegularDependency(
                buildKtSdkModule {
                    this.platform = platform
                    addBinaryRootsFromJdkHome(jdkHome.toPath(), isJre = false)