@Override
    public PersistedToolchains build(File userToolchainsFile) throws MisconfiguredToolchainException {
        PersistedToolchains toolchains = null;

        if (userToolchainsFile != null && userToolchainsFile.isFile()) {
            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {
                toolchains = new PersistedToolchains(new MavenToolchainsStaxReader().read(in));
            } catch (Exception e) {

     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =
        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: error("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private
    val KtFile.normalizedPath: String?

    val lowestInterestingVersion: GradleVersion = GradleVersion.version("0.8")
    val lowestTestedVersion: GradleVersion = GradleVersion.version("4.0")

    init {
        val releasedVersions = releasedVersionsFile.asFile.reader().use {
            Gson().fromJson(it, ReleasedVersions::class.java)
        }

        val latestFinalRelease = releasedVersions.finalReleases.first()
        val latestRelease =

    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val apiChangesDirectory: DirectoryProperty

    protected
    fun loadChanges(): Map<File, List<AcceptedApiChange>> {
        return apiChangesDirectory.get().asFile.listFiles()
            ?.filter {
                it.name.endsWith(".json")
            }?.associate {
                it to it.readAcceptedChanges()
            }?.filterValues {

      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it
      .listFiles()
      .orEmpty()
      .filter { f -> f.isFile }
      .toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles
      .map {

    @Suppress("UnstableApiUsage")
    private
    fun git(vararg args: String): Provider<String> {
        val projectDir = parameters.rootProjectDir.asFile.get()
        val execOutput = providers.exec {
            workingDir = projectDir
            isIgnoreExitValue = true
            commandLine = listOf("git", *args)
            if (OperatingSystem.current().isWindows) {

        updateProperties(fetchedVersions)
    }

    private
    fun getPluginIds(): List<String> {
        val props = Properties()
        propertiesFile.get().asFile.reader().use { input ->
            props.load(input)
        }
        return props.keys.map { it as String }.sorted()
    }

    private
    fun fetchLatestVersions(pluginIds: List<String>): List<TestedVersion> =

		logger.Fatal(err, "Failed to connect to KMS")
	}
	GlobalKMS = KMS
}

func getTLSConfig() (x509Certs []*x509.Certificate, manager *certs.Manager, secureConn bool, err error) {
	if !isFile(getPublicCertFile()) || !isFile(getPrivateKeyFile()) {
		return nil, nil, false, nil
	}

	if x509Certs, err = config.ParsePublicCertFile(getPublicCertFile()); err != nil {
		return nil, nil, false, err
	}

                throw new FileAccessException("ECL0110", new Object[] { file.getAbsolutePath() });
            }
            properties = new Properties();
            store();
        } else if (!this.propertiesFile.isFile()) {
            throw new FileAccessException("ECL0111", new Object[] { file.getAbsolutePath() });
        }
        load();
    }

    /**
     * Reloads the properties from the specified path.
     *

        String path = getPathForLocalArtifact(request.getArtifact());
        File file = new File(getRepository().getBasedir(), path);

        LocalArtifactResult result = new LocalArtifactResult(request);
        if (file.isFile()) {
            result.setFile(file);
            result.setAvailable(true);
        }

        return result;
    }

    @Override