// use lazy API to not attempt to find platform project during script compilation
        platformImplementation.dependencies.addLater(provider {
            project.dependencies.platform(project.dependencies.create(project(":distributions-dependencies")))
        })
    }
}

fun addCompileAllTasks() {
    tasks.register("compileAll") {

app = FastAPI()


async def response_status_setter(response: Response):
    response.status_code = 201


async def parent_dep(result=Depends(response_status_setter)):
    return result


@app.get("/", dependencies=[Depends(parent_dep)])
async def get_main():
    return {"msg": "Hello World"}


client = TestClient(app)


def test_dependency_set_status_code():
    response = client.get("/")

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

description = "Provides plugins to configure Kotlin DSL and patch the Kotlin compiler for use in Kotlin subprojects"

dependencies {
    implementation("gradlebuild:basics")

    implementation(projects.dependencyModules)
    implementation(projects.jvm)
    implementation(projects.kotlinDslSharedRuntime)

    implementation(kotlin("gradle-plugin"))

import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.model.ModelBase;

/**
 * <p>A <dfn>remote repository</dfn> is a central or distributed location
 * from which Maven can download project dependencies, plugins, and other
 * build artifacts. When Maven cannot find an artifact in the local
 * repository, it attempts to retrieve it from one or more remote
 * repositories.</p>
 *

 * {@linkplain LocalRepository local repositories} and
 * {@linkplain RemoteRepository remote repositories}.</p>
 *
 * <h2>Repository Resolution Process</h2>
 *
 * <p>When resolving dependencies, Maven follows this order:</p><ol>
 * <li>Check Local Repository: Maven first checks if the artifact is available in the local repository.</li>

    <module>maven-repository-mercury</module>
  </modules>
  <!--start-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junitVersion}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <dependencyManagement>
    <!--end-->
    <dependencies>
      <!--  Maven Modules -->
      <!--start-->
      <dependency>

}

project.applyOsgi(
  "Export-Package: okhttp3.java.net.cookiejar",
  "Bundle-SymbolicName: com.squareup.okhttp3.java.net.cookiejar"
)

project.applyJavaModules("okhttp3.java.net.cookiejar")

dependencies {
  "friendsApi"(projects.okhttp)
  compileOnly(libs.animalsniffer.annotations)
}

mavenPublishing {
  configure(KotlinJvm(javadocJar = JavadocJar.Empty()))

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

testing {
    suites {
        val test by getting(JvmTestSuite::class) {
            useSpock()
            dependencies {
                implementation(platform("gradlebuild:build-platform"))
            }
        }
    }

async def verify_key(x_key: str = Header()):
    if x_key != "fake-super-secret-key":
        raise HTTPException(status_code=400, detail="X-Key header invalid")
    return x_key


@app.get("/items/", dependencies=[Depends(verify_token), Depends(verify_key)])
async def read_items():

  id("binary-compatibility-validator")
}

project.applyOsgi(
  "Export-Package: okhttp3.logging",
  "Bundle-SymbolicName: com.squareup.okhttp3.logging"
)

project.applyJavaModules("okhttp3.logging")

dependencies {
  "friendsApi"(projects.okhttp)

  testImplementation(libs.junit)
  testImplementation(projects.mockwebserver3)
  testImplementation(projects.mockwebserver3Junit5)
  testImplementation(projects.okhttpTestingSupport)