plugins {
    `kotlin-dsl`
}

group = "gradlebuild"

description = "Provides a plugin for publishing some of Gradle's subprojects to Artifactory or the Plugin Portal"

dependencies {
    implementation(projects.basics)
    implementation(projects.moduleIdentity)

    implementation(buildLibs.publishPlugin)

                    <classpathScope>test</classpathScope>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.jetbrains.teamcity</groupId>
            <artifactId>server-api</artifactId>
            <version>${teamcity.dsl.version}</version>
            <scope>test</scope>

    public void shouldInterpolateDependencyVersionToSetSameAsProjectVersion() throws Exception {
        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .version("3.8.1")
                .dependencies(Collections.singletonList(org.apache.maven.api.model.Dependency.newBuilder()
                        .version("${project.version}")
                        .build()))
                .build());

// TODO consider splitting `java-gradle-plugin` to provide only what's necessary here
configurations.all {
    withDependencies {
        remove(project.dependencies.gradleApi())
        remove(project.dependencies.gradleTestKit())
    }
}

publishing.publications.withType<MavenPublication>().configureEach {
    if (name == "pluginMaven") {
        groupId = project.group.toString()

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Verifies exclusions listed in dependencyManagement are valid for
 * transitive dependencies.
 *
 */
@Deprecated
@SuppressWarnings("checkstyle:UnusedLocalVariable")
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {

    obtain the OAuth2 scopes required by all the dependencies in the same chain.

    This way, multiple dependencies can have different scopes, even when used in the
    same *path operation*. And with this, you can access all the scopes required in
    all those dependencies in a single place.

    Read more about it in the

from fastapi.dependencies.utils import get_typed_annotation


def test_get_typed_annotation():
    # For coverage
    annotation = "None"
    typed_annotation = get_typed_annotation(annotation, globals())

plugins {
  kotlin("jvm")
  id("okhttp.jvm-conventions")
  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
}

dependencies {
  testImplementation(libs.square.okio)
  testImplementation(libs.square.moshi)
  testImplementation(libs.square.moshi.kotlin)
  testImplementation(projects.okhttp)
  testImplementation(projects.okhttpTestingSupport)
  testImplementation(projects.mockwebserver)
  testImplementation(libs.junit)

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
    id("gradlebuild.build-logic.groovy-dsl-gradle-plugin")
}

description = "Provides plugins that create update tasks for the Gradle build"

dependencies {
    implementation(projects.jvm)
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")
    implementation(buildLibs.gson)
    implementation(buildLibs.jsoup)

  id("com.gradleup.shadow")
}

tasks.compileJava {
  options.isWarnings = false
}

tasks.jar {
  manifest {
    attributes("Main-Class" to "okhttp3.sample.SampleServer")
  }
}

dependencies {
  implementation(projects.okhttp)
  implementation(projects.mockwebserver)
}

tasks.shadowJar {
  mergeServiceFiles()