where:
        descriptorContents                              | warningMessage
        ''                                              | NO_DESCRIPTOR_WARNING
        'implementation-class='                         | INVALID_DESCRIPTOR_WARNING_PREFIX
        'implementation-class=com.xxx.WrongPluginClass' | BAD_IMPL_CLASS_WARNING_PREFIX
    }

        }
        buildFile << """
            configurations {
                conf
            }
            dependencies {
                implementation "org:foo:1.0"
                implementation "org:foo:1.0:classy"
                conf "org:foo:1.0@zip"
            }
        """

        when:
        writeVerificationMetadata()
        run ":compileJava"

project(':java') {
    apply plugin: 'java'
    java {
        withJavadocJar()
        withSourcesJar()
    }
    dependencies {
        implementation project(':other-java')
        implementation files('file-dep.jar')
        compileOnly 'test:compile-only:1.0'
        implementation 'test:implementation:1.0'
        runtimeOnly 'test:runtime-only:1.0'
    }
}

project(':consumer') {
    configurations { consume }

                implementation.exclude(group: "implementation-group", module: "implementation-module")
                runtimeOnly.exclude(group: "runtimeOnly-group", module: "runtimeOnly-module")
            }

            dependencies {
                api "org.test:a:1.0"
                implementation "org.test:b:2.0"
                api project(':subproject')
            }

    }

    def "recompiles source when annotation processor implementation on annotation processor classpath changes"() {
        given:
        settingsFile << "include 'c'"

        buildFile << """
            project(':b') {
                dependencies {
                    implementation project(':a')
                }
            }
            project(':c') {

                apply plugin: 'java-library'
                dependencies {
                    api project(":api")
                    implementation project(":impl")
                }
            }

            project(":application") {
                dependencies {
                    implementation project(":library")
                }
            }
        """

        //when

        assertOutputFile("""$COMMON_START
 */

dependencies {
    // Use slf4j
    implementation 'org.slf4j:slf4j-api:2.7'
    implementation 'org.slf4j:slf4j-simple:2.7'

    implementation 'a:b:1.2'
    implementation 'a:c:4.5'
    implementation 'a:d:4.5'

    // Use Scala to compile
    implementation 'org.scala-lang:scala-library:2.10'
}
""")
    }

            params(7)
        }
        withModule("commons-collections:commons-collections", TargetJvmVersionRule) {
            params(8)
        }
    }
    implementation("commons-io:commons-io:2.6")
    implementation("commons-collections:commons-collections:3.2.2")
}
// end::config-component-metadata-rule[]


// tag::jaxen-rule-1[]
@CacheableRule

        buildFile << """
            dependencies {
                implementation 'org.foo:hiphop:1.0'
                implementation 'org.foo:unknown:1.0' //does not exist
                implementation project(":child")

                implementation 'org.foo:rock:1.0' //contains unresolved transitive dependency
            }

            task validate {
                doLast {

            apply plugin: 'java-library'

            dependencies {
                implementation libs.com.company.libs.a
                implementation libs.com.companylibs.b
                implementation libs.com.companyLibs.c

                implementation libs.bundles.com.company.libs.bundle
                implementation libs.bundles.com.companylibs.bundle
            }

            tasks.register('checkVersions') {