delete { delete(transformDir) }
            }
    }
}


private
val scriptCacheDirNames =
    // TODO Remove gradle-kotlin-dsl* after a while
    listOf("scripts", "scripts-remapped", "gradle-kotlin-dsl", "gradle-kotlin-dsl-accessors", "kotlin-dsl")


private
fun scriptsCacheDirsUnder(cacheDir: File) =
    scriptCacheDirNames
        .map { File(cacheDir, it) }

            doesNotEqual("skip.build", "true")
        }
    }
}

fun buildToolGradleParameters(
    isContinue: Boolean = true,
    maxParallelForks: String = "%maxParallelForks%",
): List<String> =
    listOf(
        // We pass the 'maxParallelForks' setting as 'workers.max' to limit the maximum number of executers even

  var proxyAuthenticator: Authenticator = RecordingOkAuthenticator("password", null)
  var connectionSpecs: List<ConnectionSpec> =
    listOf(
      ConnectionSpec.MODERN_TLS,
      ConnectionSpec.COMPATIBLE_TLS,
      ConnectionSpec.CLEARTEXT,
    )
  var protocols: List<Protocol> =
    listOf(
      Protocol.HTTP_1_1,
    )
  var handshakeCertificates: HandshakeCertificates = localhost()

        val buildScanTagForGroovyMajor = buildScanTagParam("Groovy$bundleGroovyMajor")
        val buildScanTags =
            if (bundleGroovyMajor != null) listOf(buildScanTagForType, buildScanTagForGroovyMajor) else listOf(buildScanTagForType)
        val extraSysProp = mutableListOf<String>()
        val extraTasks = mutableListOf<String>()
        if (bundleGroovyMajor != null) {

                        OperatingSystem.current().isWindows -> requirements = listOf("os=windows", dogfoodingTag)
                        OperatingSystem.current().isMacOsX -> requirements = listOf("os=macos", dogfoodingTag)
                    }
                } else {
                    requirements = listOf(dogfoodingTag)
                }
            }

    private
    fun Task.findTraceJson(): List<File> {
        if (this !is Test) {
            return emptyList()
        }
        // e.g. build/test-results/embeddedIntegTest/trace.json
        return listOf(project.layout.buildDirectory.file("test-results/$name/trace.json").get().asFile)
    }

    private
    fun Task.genericHtmlReports() = when (this) {
        is Reporting<*> -> listOf(this.reports["html"].outputLocation.get().asFile)

        fun added(thing: String, desc: String): List<String> =
            listOf(
                "$thing ${describe(thing, desc)}: Is not annotated with @Incubating.",
                "$thing ${describe(thing, desc)}: Is not annotated with @since 2.0."
            )

        fun addedWithInvalidSince(thing: String, desc: String): List<String> =
            listOf(

    assertThat(effectiveFragment, "fragment").isEqualTo(testData.fragment)
  }

  companion object {
    private val HTTP_URL_SCHEMES = listOf("http", "https")
    private val KNOWN_FAILURES =
      listOf(
        "Parsing: <http://example\t.\norg> against <http://example.org/foo/bar>",
        "Parsing: <http://f:0/c> against <http://example.org/foo/bar>",

    os: Os = Os.LINUX,
    arch: Arch = Arch.AMD64,
    testJavaVersion: String = os.perfTestJavaVersion.major.toString(),
    testJavaVendor: String = os.perfTestJavaVendor.name.lowercase(),
) = listOf(
    "$task${if (extraParameters.isEmpty()) "" else " $extraParameters"}",
    "-PperformanceBaselines=$baselines",
    "-PtestJavaVersion=$testJavaVersion",
    "-PtestJavaVendor=$testJavaVendor",

        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() =
            scenarios.flatMap { scenario ->
                Os.values().flatMap { os ->
                    val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                    if (os == Os.WINDOWS) {
                        listOf("jprofiler")
                    } else {