implementation(libs.jsr305)
    implementation(libs.slf4jApi)

    compileOnly("antlr:antlr:2.7.7") {
        because("this dependency is downloaded by the antlr plugin")
    }

    runtimeOnly(project(":language-jvm"))
    runtimeOnly(project(":workers"))

    testImplementation(project(":base-services-groovy"))
    testImplementation(testFixtures(project(":core")))
    testImplementation(project(":file-collections"))

apply(plugin = "java-library")
dependencies {
    "implementation"("com.example:lib:1.1")
    "runtimeOnly"("com.example:runtime:1.0")
    "testImplementation"("com.example:test-support:1.3") {
        exclude(module = "junit")
    }
    "testRuntimeOnly"("com.example:test-junit-jupiter-runtime:1.3")

    implementation(project(":scala"))
    implementation(project(":test-suites-base"))
    implementation(project(":war"))

    implementation(libs.commonsLang)

    runtimeOnly(project(":language-jvm"))
    runtimeOnly(project(":testing-base"))

    testImplementation(testFixtures(project(":core")))
    testImplementation(testFixtures(project(":dependency-management")))

            java.lang.AssertionError: typeSig ERROR""")
    }

    runtimeOnly(libs.mavenResolverImpl) {
        because("For ApiMavenResolver. Implements maven-resolver-api")
    }
    runtimeOnly(libs.mavenResolverConnectorBasic) {
        because("For ApiMavenResolver. To use resolver transporters")
    }
    runtimeOnly(libs.mavenResolverTransportFile) {
        because("For ApiMavenResolver. To resolve file:// URLs")

}

dependencies {
    implementation("org.gradle:gradle-tooling-api:$toolingApiVersion")
    // The tooling API need an SLF4J implementation available at runtime, replace this with any other implementation
    runtimeOnly("org.slf4j:slf4j-simple:1.7.10")
}
// end::use-tooling-api[]

application {
    mainClass = "org.gradle.sample.Main"

    /* consumed confs */
    compileClasspath [fillcolor=lightblue]
    runtimeClasspath [fillcolor=lightblue]

    /* configurations */
    compileClasspath -> {compileOnly implementation}
    runtimeClasspath -> {runtimeOnly implementation}

    /* tasks */
    compileJava -> compileClasspath [style=dashed label="uses"]

                ${configurationFor(sourceSet, 'runtimeOnly')} 'org.junit.jupiter:junit-jupiter-engine:${MultiVersionIntegrationSpec.version}'
                ${configurationFor(sourceSet, 'runtimeOnly')} 'org.junit.platform:junit-platform-launcher'
            """
        }

        @Override

plugins {
    `java-library`
}

repositories {
    mavenCentral()
}

// tag::dependencies[]
dependencies {
    implementation("org.codehaus.groovy:groovy:3.0.1")
    runtimeOnly("io.vertx:vertx-lang-groovy:3.9.4")
}
// end::dependencies[]

if (project.hasProperty("explicitRule")) {
    // tag::explicit-configuration[]
    configurations {
        runtimeClasspath.get().shouldResolveConsistentlyWith(compileClasspath.get())

}

dependencies {
    implementation 'org.gradle.sample:plugin:1.0'
    implementation "org.gradle:gradle-tooling-api:${toolingApiVersion}"
    // Need an SLF4J implementation at runtime
    runtimeOnly 'org.slf4j:slf4j-simple:1.7.10'
}

application {
    mainClass = 'org.gradle.sample.Main'

configurations {
    instrumentedJars {
        canBeConsumed = true
        canBeResolved = false
        // If you want this configuration to share the same dependencies, otherwise omit this line
        extendsFrom implementation, runtimeOnly
    }
}
// end::declare-outgoing-configuration[]

def instrumentedJar = tasks.register("instrumentedJar", Jar) {
    archiveClassifier = "instrumented"
}

// tag::attach-outgoing-artifact[]
artifacts {