package com.example;

import org.gradle.api.artifacts.dsl.Dependencies;
import org.gradle.api.artifacts.dsl.DependencyCollector;

// tag::custom-dependencies-type[]
/**
 * Custom dependencies block for the example plugin.
 */
public interface ExampleDependencies extends Dependencies {
// end::custom-dependencies-type[]

// tag::custom-dependencies-scopes[]
    /**
     * Dependency scope called "implementation"
     */

        dependencies.getImplementation().getDependencies().get() == [otherProjectDependency] as Set
    }

    def "can depend on self resolving dependencies"() {
        def localGroovyDependency = Mock(Dependency)
        def gradleApiDependency = Mock(Dependency)
        def gradleTestKitDependency = Mock(Dependency)

        when:
        dependencies {
            implementation localGroovy()

        //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'() {

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.

public abstract class Binding<T> {
    private final Set<Key<?>> dependencies;
    private Annotation scope;
    private int priority;
    private Key<?> originalKey;

    protected Binding(Key<? extends T> originalKey, Set<Key<?>> dependencies) {
        this(originalKey, dependencies, null, 0);
    }

    protected Binding(Key<?> originalKey, Set<Key<?>> dependencies, Annotation scope, int priority) {

.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]"]

/**
 * A request to resolve the dependencies of a project.
 *
 */
public interface DependencyResolutionRequest {

    /**
     * Gets the project to resolve dependencies for.
     *
     * @return The project to resolve dependencies for or {@code null} if not set.
     */
    MavenProject getMavenProject();

    /**
     * Sets the project to resolve dependencies for.
     *

        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"