//then
        def dependencies = parseIml("api/master-api.iml").dependencies
        assert dependencies.modules.size() == 2
        dependencies.assertHasModule('COMPILE', "shared-api")
        dependencies.assertHasModule("TEST", "model")

        dependencies = parseIml("shared/model/model.iml").dependencies
        assert dependencies.modules.size() == 1
        dependencies.assertHasModule("TEST", "util")
    }

            "classifier" to "cls",
            "ext" to "x"
        )

        val dependencies = newDependencyHandlerMock()
        val dependency: ExternalModuleDependency = mock()
        whenever(dependencies.create(expectedModuleMap)).thenReturn(dependency)

        assertThat(
            dependencies.create(
                group = "g",
                name = "n",
                version = "v",

}
configurations {
    lockedConf
}

dependencies {
    lockedConf 'org:foo:1.+'
    lockedConf 'org:bar:1.+'
}
"""

        when:
        succeeds 'dependencies', '--write-locks'

        then:
        lockfileFixture.verifyLockfile('lockedConf', ['org:foo:1.0', 'org:bar:1.0'])
    }

    def 'includes transitive dependencies in the lock file'() {

.Dependencies between projects
image::dependency-management-project-dependencies.png[]

Gradle can model dependencies between modules.
Those dependencies are called _project dependencies_ because each module is represented by a Gradle project.

.Project dependencies
====
include::sample[dir="snippets/java/multiproject/kotlin/api",files="build.gradle.kts[tags=project-dependencies]"]

You can define dependencies that in turn can define dependencies themselves.

In the end, a hierarchical tree of dependencies is built, and the **Dependency Injection** system takes care of solving all these dependencies for you (and their sub-dependencies) and providing (injecting) the results at each step.

        when:
        succeeds "publish"

        then:
        // POM uses resolved variant coordinates
        def dependencies = repoModule.parsedPom.scopes.runtime.dependencies
        dependencies.size() == 1
        def dependency = dependencies.values().first()
        dependency.groupId == "org.jetbrains.kotlinx"
        dependency.artifactId == "kotlinx-coroutines-core-jvm"

        def dependencies = selectTargetConfigurationMetadata(metadataImplementation).dependencies

        then:
        if (supportedInMetadata(metadataType)) {
            assert dependencies.size() == 2
            assert dependencies[0].constraint == addAllDependenciesAsConstraints()
            assert dependencies[1].constraint == addAllDependenciesAsConstraints()
        } else {
            assert dependencies.empty
        }

}
// end::jaxen-rule-2[]

// tag::jaxen-dependencies[]
dependencies {
    components {
        withModule("jaxen:jaxen", JaxenDependenciesRule)
        withModule("jaxen:jaxen", JaxenCapabilitiesRule)
    }
    implementation("jaxen:jaxen:1.1.3")
    runtimeOnly("jaxen:jaxen:1.1.3") {
        capabilities { requireCapability("jaxen:jaxen-dom4j") }
    }
}
// end::jaxen-dependencies[]


// tag::guava-rule[]

sourceSets.main.output.dir "$buildDir/generated/main"
sourceSets.test.output.dir "$buildDir/ws/test"
'''
        //then
        def dependencies = parseIml("root.iml").dependencies
        assert dependencies.libraries.size() == 2
        dependencies.assertHasLibrary('RUNTIME', 'generated/main')
        dependencies.assertHasLibrary('TEST', 'ws/test')
    }

    @Test
    @ToBeFixedForConfigurationCache

        when:
        parsePom()

        then:
        metadata.dependencies.size() == 1
        metadata.dependencies[0].constraint
        metadata.dependencies[0].selector.module == 'module-b'
        metadata.dependencies[0].selector.version == '1.0'
    }

    def "a bom can have a parent pom - dependencyManagement entries are combined"() {
        given: