maven { url '${mavenHttpRepo.uri}' }
                }
            }
            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
            }
        """
        failedResolve.prepare("compileClasspath")

        buildFile << """
            dependencies {
                implementation("org:foo:1.0")
            }
        """

        file("buildSrc/build.gradle.kts") << """
            plugins {
                `java-library`
            }
            dependencies {
                implementation("org:bar:1.0")
            }
            repositories {
                maven {

            params(7)
        }
        withModule<TargetJvmVersionRule>("commons-collections:commons-collections") {
            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

        setupExternalDependency()

        buildFile << """
            project(":consumer") {
                dependencies {
                    implementation files("file1.jar", "file2.jar")
                    implementation project(":producer")
                    implementation localGroovy()

                    artifactTypes {
                        jar {
                            attributes.attribute(color, 'blue')

                apply plugin: 'cpp-application'
                dependencies {
                    implementation project(':deck')
                }
            }
            project(':deck') {
                apply plugin: 'cpp-library'
                dependencies {
                    api project(':card')
                    implementation project(':shuffle')
                }
            }
            project(':card') {

The `api` configuration should be used to declare dependencies which are exported by the library API, whereas the `implementation` configuration should be used to declare dependencies which are internal to the component.

.Declaring API and implementation dependencies
====

        given:
        project.pluginManager.apply(JavaPlugin)

        when:
        def implementation = project.configurations.getByName(JvmConstants.IMPLEMENTATION_CONFIGURATION_NAME)

        then:
        implementation.extendsFrom == toSet()
        !implementation.visible
        !implementation.canBeConsumed
        !implementation.canBeResolved

        when:

        given:
        buildFile << """
            project(':app') {
                apply plugin: 'swift-application'
                dependencies {
                    implementation project(':cppGreeter')
                }
                application.binaries.configureEach {
                    if (targetMachine.operatingSystemFamily.macOs) {
                        linkTask.get().linkerArgs.add("-lc++")

        windowsClasspath('sample') == ['sample.jar', 'utils.jar', 'core.jar', 'implementation-1.0.jar'] as Set
    }

    def "includes transitive runtime dependencies in runtime classpath"() {
        given:
        mavenRepo.module('org.gradle.test', 'implementation', '1.0').publish()
        buildFile << """
        allprojects {
            repositories {

}

project(':impl') {
    repositories {
        maven { url "${repoDir.toURI()}" }
    }

    dependencies {
        implementation 'groupOne:artifactTwo:1.0'
        implementation project(':someApiProject')
        implementation 'i.dont:Exist:1.0'
        implementation files('someDependency.jar')
    }
}
"""
        def content = getFile([print : true], 'impl/impl.iml').text

        //then