val codeQualityDir = File(projectRoot, "code-quality")
        val distributionDir = File(projectRoot, "distribution")
        listOf(coreDir, codeQualityDir, distributionDir).forEach { it.mkdirs() }
        File(projectRoot, "settings.gradle").writeText("""
            rootProject.name = "instrumentation-metadata-test"
            include("core")
            include("code-quality")
            include("distribution")
        """)

     */
    fun buildSrcRootsOf(projectRoot: File): Collection<File> =
        projectRoot.resolve("buildSrc/$buildSrcSourceRootsFilePath")
            .takeIf { it.isFile }
            ?.readLines()
            ?.map { projectRoot.resolve("buildSrc/$it") }
            ?: buildSrcRootsFallbackFor(projectRoot)

    private
    fun buildSrcRootsFallbackFor(projectRoot: File) =

        @Override
        TestFile getBuildDir(String projectPath, TestFile projectRoot) {
            if (projectPath == ':') {
                return projectRoot.file("build")
            } else {
                if (subprojects == null) {
                    ArrayNode arr = (ArrayNode) projectRoot.file(".teamcity/subprojects.json").withInputStream {
                        new ObjectMapper().readTree(it)

    protected
    val repositoriesBlock
        get() = """
            repositories {
                gradlePluginPortal()
            }
        """

    protected
    val projectRoot: File
        get() = customProjectRoot ?: testDirectory

    private
    var customProjectRoot: File? = null

    protected
    fun <T> withProjectRoot(dir: File, action: () -> T): T {

    private void loadJdk() {
        Node projectRoot = findProjectRootManager();
        boolean assertKeyword = Boolean.parseBoolean((String) projectRoot.attribute("assert-keyword"));
        boolean jdk15 = Boolean.parseBoolean((String) projectRoot.attribute("jdk-15"));
        String languageLevel = (String) projectRoot.attribute("languageLevel");
        String jdkName = (String) projectRoot.attribute("project-jdk-name");

    private
    lateinit var temporaryFolder: File

    private
    lateinit var target: File

    private
    lateinit var projectRoot: File

    @BeforeEach
    fun setup() {
        target = File(temporaryFolder, "target")
        target.mkdir()

        projectRoot = File(temporaryFolder, "gradle")

        createMinimalDistribution()
    }

    @Test
    fun `installs into empty dir`() {

 */
internal
typealias Environment = Map<String, Any?>


/**
 * Path of the root directory of the IntelliJ project.
 */
internal
val Environment.projectRoot: File
    get() = get("projectRoot") as File


/**
 * Path of the local Gradle installation as configured in IntelliJ.
 */
internal
val Environment.gradleHome: File?
    get() = get("gradleHome") as? File


/**

 */
class PublicSuffixListGenerator(
  projectRoot: Path = ".".toPath(),
  val fileSystem: FileSystem = FileSystem.SYSTEM,
  val client: OkHttpClient = OkHttpClient(),
) {
  private val resources = projectRoot / "okhttp/src/main/resources/okhttp3/internal/publicsuffix"
  private val testResources = projectRoot / "okhttp/src/test/resources/okhttp3/internal/publicsuffix"

                @JvmField @Rule val temporaryFolder = TemporaryFolder()

                val projectRoot by lazy {
                    File(temporaryFolder.root, "test").apply { mkdirs() }
                }

                @Test
                fun `my test`() {
                    // given:
                    File(projectRoot, "build.gradle.kts")
                        .writeText("plugins { id(\"my-plugin\") }")

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.caching.fixtures

import java.io.File


internal
fun compilationTrace(projectRoot: File, action: CompileTrace.() -> Unit) {
    val file = File(projectRoot, "operation-trace-log.txt")
    action(CompileTrace(file.readLines()))
}


internal
class CompileTrace(private val operations: List<String>) {