isTransitive = false
}

configurations.configureEach {
  if (name == "implementation") {
    extendsFrom(friendsApi, friendsImplementation)
  }
  if (name == "api") {
    extendsFrom(friendsApi)
  }
  if (name == "testImplementation") {
    extendsFrom(friendsTestImplementation)
  }
}

tasks.withType<KotlinCompile>().configureEach {
  friendPaths.from(friendsApi.incoming.artifactView { }.files)

        platform = OS.current().name().toLowerCase()
        architecture = Architecture.current().name().toLowerCase()
    }
}

configure(allprojects) {
    project.tasks.withType(Test).configureEach { Test test ->
        if (BuildParams.getIsRuntimeJavaHomeSet()) {
            test.executable = "${BuildParams.runtimeJavaHome}/bin/java"
        } else {
            test.dependsOn(rootProject.jdks.provisioned_runtime)

        maybeSkipTasks(tasks, dockerSupport, ComposePull.class);
        maybeSkipTasks(tasks, dockerSupport, ComposeDown.class);

        tasks.withType(Test.class).configureEach(task -> extension.fixtures.all(fixtureProject -> {
            task.dependsOn(fixtureProject.getTasks().named("postProcessFixture"));
            task.finalizedBy(fixtureProject.getTasks().named("composeDown"));

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

allprojects {
    tasks.withType(JavaCompile).configureEach {
        outputs.doNotCacheIf("CodeQL scanning", { true })
    }

pluginManager.withPlugin("gradlebuild.code-quality") {
    tasks {
        named("codeQuality") {
            dependsOn(tasks.withType<Javadoc>())
        }
    }
}

tasks.withType<Javadoc>().configureEach {
    assert(name != "javadocAll") // This plugin should not be applied to the :docs project.

    onlyIf("Do not run the task if there are no java sources") {

    exceptionFormat = TestExceptionFormat.FULL
  }

  systemProperty("okhttp.platform", platform)
  systemProperty("junit.jupiter.extensions.autodetection.enabled", "true")
}

tasks.withType<Test>().configureEach {
  environment("OKHTTP_ROOT", rootDir)
}

plugins.withId("org.jetbrains.kotlin.jvm") {
  val test = tasks.named("test")
  tasks.register("jvmTest") {

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

signing {
    useInMemoryPgpKeys(
        project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,
        project.providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE").orNull
    )
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }

        ext.set("licenseFile", null);
        ext.set("noticeFile", null);
        // add license/notice files
        project.afterEvaluate(p -> p.getTasks().withType(Jar.class).configureEach(jar -> {
            if (ext.has("licenseFile") == false
                || ext.get("licenseFile") == null
                || ext.has("noticeFile") == false
                || ext.get("noticeFile") == null) {

            t.setSignatureFile(resourcesDir.resolve("forbidden/third-party-audit.txt").toFile());
        });
        project.getTasks().withType(ThirdPartyAuditTask.class).configureEach(t -> t.setJdkJarHellClasspath(jdkJarHellConfig));
        return audit;
    }

        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
        final SourceSet testSourceSet = sourceSets.create("test");

        project.getTasks().withType(Test.class).configureEach(test -> {
            test.setTestClassesDirs(testSourceSet.getOutput().getClassesDirs());
            test.setClasspath(testSourceSet.getRuntimeClasspath());
        });