}
        }
    }
}

tasks.withType<JavaCompile>().configureEach {
    options.errorprone {
        disableWarningsInGeneratedCode = true
        allErrorsAsWarnings = true
    }
}

val codeQuality = tasks.register("codeQuality") {
    dependsOn(tasks.withType<CodeNarc>())
    dependsOn(tasks.withType<Checkstyle>())
    dependsOn(tasks.withType<ValidatePlugins>())
}

     */
    abstract val targetJvmVersion: Property<Int>

    fun Project.from(sourceSet: SourceSet) {
        associate(tasks.named<JavaCompile>(sourceSet.getCompileTaskName("java")))
        plugins.withType<GroovyBasePlugin>() {
            associate(tasks.named<GroovyCompile>(sourceSet.getCompileTaskName("groovy")))
        }
        plugins.withId("org.jetbrains.kotlin.jvm") {

  }

  // https://publicobject.com/2023/04/16/read-a-project-file-in-a-kotlin-multiplatform-test/
  tasks.withType<Test>().configureEach {
    environment("OKHTTP_ROOT", rootDir)
  }
  tasks.withType<KotlinJvmTest>().configureEach {
    environment("OKHTTP_ROOT", rootDir)
  }

  tasks.withType<JavaCompile> {
    if (name.contains("Java9")) {
      sourceCompatibility = "9"
      targetCompatibility = "9"

  if (alpnBootVersion != null) {
    val alpnBootJar = configurations.detachedConfiguration(
      dependencies.create("org.mortbay.jetty.alpn:alpn-boot:$alpnBootVersion")
    ).singleFile
    tasks.withType<Test> {
      jvmArgs("-Xbootclasspath/p:${alpnBootJar}")
    }
  }
}

android {
  compileSdk = 35

  namespace = "okhttp.okhttp3"

  defaultConfig {
    minSdk = 21

    implementation("gradlebuild:gradle-plugin")

    testImplementation("org.junit.vintage:junit-vintage-engine")

    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        allWarningsAsErrors = true
    }
}

detekt {
    // overwrite the config file's location

plugins {
    id("gradlebuild.module-identity")
}

tasks.named<UpdateDaemonJvm>("updateDaemonJvm") {
    languageVersion = JavaLanguageVersion.of(17)
}

tasks.withType<UpdateReleasedVersions>().configureEach {
    releasedVersionsFile = releasedVersionsFile()
    group = "Versioning"
}

tasks.register<UpdateReleasedVersions>("updateReleasedVersions") {

    requires("java.logging")
  }
  module("com.squareup.okio:okio", "okio") {
    exportAllPackages()
  }
}

val testJavaVersion = System.getProperty("test.java.version", "21").toInt()

tasks.withType<Test> {
  useJUnitPlatform()

  enabled = testJavaVersion > 8

  javaLauncher.set(javaToolchains.launcherFor {
    languageVersion.set(JavaLanguageVersion.of(testJavaVersion))
  })
}

java {

configureSourcesVariant()
configureTests()

tasks.registerCITestDistributionLifecycleTasks()

fun configureCompileDefaults() {
    tasks.withType<JavaCompile>().configureEach {
        options.compilerArgs.add("-parameters")
        configureCompileTask(options)
    }
    tasks.withType<GroovyCompile>().configureEach {
        groovyOptions.encoding = "utf-8"
        configureCompileTask(options)
    }
}

/**

        publishNormalizedToLocalRepository()
    }
}

val pgpSigningKey: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY")
val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(
        project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,

    parameters.gradleVersion = gradleModule.identity.version.map { it.version }
    parameters.homeDir = intTestHomeDir
}

fun Gradle.rootBuild(): Gradle = parent.let { it?.rootBuild() ?: this }

tasks.withType<DistributionTest>().configureEach {
    shouldRunAfter("test")

    setJvmArgsOfTestJvm()
    setSystemPropertiesOfTestJVM("default")
    configureGradleTestEnvironment()
    addSetUpAndTearDownActions()
}