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

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

        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. " +

                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)

        dir.eachFileRecurse(FileType.FILES) {
            if (isIncluded(it)) {
                if (criteria.test(it)) {
                    if (qualified) {
                        String relative = dir.toPath().relativize(it.toPath()).toString()
                        changed << TextUtil.normaliseFileSeparators(removeExtension(relative)).replace('/', '.')
                    } else {
                        changed << removeExtension(it.name)

			return labelsMap, fmt.Errorf("invalid selector: %s", l)
		}
		key := strings.TrimSpace(l[0])
		if err := validateLabelKey(key, field.ToPath(opts...)); err != nil {
			return labelsMap, err
		}
		value := strings.TrimSpace(l[1])
		if err := validateLabelValue(key, value, field.ToPath(opts...)); err != nil {
			return labelsMap, err
		}
		labelsMap[key] = value
	}
	return labelsMap, nil

        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);
    }

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)

    @Override
    public void setLastAccessTime(File file, long millis) {
        try {
            Files.setLastModifiedTime(file.toPath(), FileTime.fromMillis(millis));
        } catch (IOException e) {
            LOGGER.debug("Ignoring failure to set last access time of " + file, e);
        }
    }

    @Override

@Singleton
public class DefaultPathTranslator implements PathTranslator {

    @Override
    public String alignToBaseDirectory(String path, File basedir) {
        return alignToBaseDirectory(path, basedir != null ? basedir.toPath() : null);
    }

    @Override
    public String alignToBaseDirectory(String path, Path basedir) {
        String result = path;

        if (path != null && basedir != null) {

                    def outputDir = shortName.startsWith('gradle-') ? gradleJars : dependencies
                    def out = new File(outputDir, shortName)
                    Files.copy(zin, out.toPath())
                    zin.closeEntry()
                }
            }
        }
    }