repositories {
    maven { url 'https://repo.gradle.org/gradle/libs-releases' }
}

dependencies {
    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'

}

// tag::consumer[]
dependencies {
    // This project requires the main producer component
    implementation("org.gradle.demo:producer:1.0")

    // But we also want to use its MongoDB support
    runtimeOnly("org.gradle.demo:producer:1.0") {
        capabilities {
            requireCapability("org.gradle.demo:producer-mongodb-support")
        }
    }
}

plugins {
    id '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.shouldResolveConsistentlyWith(compileClasspath)
    }

}

// tag::consumer[]
dependencies {
    // This project requires the main producer component
    implementation('org.gradle.demo:producer:1.0')

    // But we also want to use its MongoDB support
    runtimeOnly('org.gradle.demo:producer:1.0') {
        capabilities {
            requireCapability("org.gradle.demo:producer-mongodb-support")
        }
    }
}

group = 'org.gradle.sample'

repositories {
    mavenCentral()
}

testing {
    suites {
        // tag::version-catalogs-deps[]
        test {
            dependencies {
                runtimeOnly libs.guava
                implementation libs.commons.lang3
                implementation.bundle(libs.bundles.groovy)
            }
        }
        // end::version-catalogs-deps[]
    }

            </thead>
            <tr>
                <td>implementation</td>
            </tr>
            <tr>
                <td>compileOnly</td>
            </tr>
            <tr>
                <td>runtimeOnly</td>
            </tr>
            <tr>
                <td>annotationProcessor</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

}

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'

    implementation "org.codehaus:groovy:groovy-all:2.4.15"
    implementation "commons-codec:commons-codec:1.2"
    testImplementation 'junit:junit:4.13'
    testImplementation 'org.testng:testng:6.4'
    runtimeOnly 'com.googlecode:reflectasm:1.01'

    <% if (dependencies) { dependencies.each { %>
        implementation "${it.shortNotation()}" <% } %>
    <% } %>
}

test {
    if (!JavaVersion.current().java8Compatible) {

 *     <li><code>implementation</code> dependencies are used at compilation and runtime.</li>
 *     <li><code>compileOnly</code> dependencies are used only at compilation and are not available at runtime.</li>
 *     <li><code>runtimeOnly</code> dependencies are not available at compilation and are used only at runtime.</li>
 *     <li><code>annotationProcessor</code> dependencies are used only at compilation for the annotation processor classpath</li>
 * </ul>
 *

    }

    String getImplementationConfiguration() {
        baseVersion() >= V6_9 ? "implementation" : "compile"
    }

    String getRuntimeConfiguration() {
        baseVersion() >= V6_9 ? "runtimeOnly" : "runtime"
    }

    String getTestImplementationConfiguration() {
        "test${implementationConfiguration.capitalize()}"
    }

    String getTestRuntimeConfiguration() {