}
        }
    }

    def "can add api dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.api("a:b:c")

        then:
        1 * dependencyFactory.create("a:b:c") >> dep
        1 * deps.add(dep)
    }

    def "can add and configure api dependency"() {
        def dep = Stub(ExternalModuleDependency)
        def action = Mock(Action)

        when:

import org.example.*

// tag::failed-inferred-task-dep[]
plugins {
// end::failed-inferred-task-dep[]
    id 'base'
// tag::failed-inferred-task-dep[]
    id 'java-library'
}
// end::failed-inferred-task-dep[]

repositories {
    mavenCentral()
}

dependencies {
    implementation group: 'commons-collections', name: 'commons-collections', version: '3.2.2'
    testImplementation group: 'junit', name: 'junit', version: '4.+'
}

import org.example.*

// tag::failed-inferred-task-dep[]
plugins {
    // end::failed-inferred-task-dep[]
    base
// tag::failed-inferred-task-dep[]
    id("java-library")
}
// end::failed-inferred-task-dep[]

repositories {
    mavenCentral()
}

dependencies {
    implementation(group = "commons-collections", name = "commons-collections", version = "3.2.2")
    testImplementation(group = "junit", name = "junit", version = "4.+")

        given:
        settingsFile << "include 'dep'"
        buildFile << """
            dependencies {
                conf(project(':dep')) {
                    attributes {
                        attribute(Attribute.of('color', String), '$color')
                    }
                }
            }
        """
        file("dep/build.gradle") << blueAndRedVariants()

        when:

}
"""
        and:
        mavenRepo.module("org.test", "dep", "1.0").publish()
        mavenRepo.module("org.test", "dep", "1.5").publish()
        mavenRepo.module("org.test", "dep", "2.0-dev1").publish()
        mavenRepo.module("org.test", "dep", "2.0-final").publish()
        mavenRepo.module("org.test", "dep", "2.0").publish()
        mavenRepo.module("org.test", "dep", "2.1").publish()

        for (UnresolvedDependencyResult dep : deps) {
            log(dep);
        }
    }

    public void log(UnresolvedDependencyResult dep) {
        logger.warn("Could not resolve: " + dep.getAttempted());
        logger.debug("Could not resolve: " + dep.getAttempted(), dep.getFailure());
    }

    public File asFile(UnresolvedDependencyResult dep, File parent) {

        def differentConstraint = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, true)

        then:
        dep.is(same)
        !dep.is(differentFrom)
        !dep.is(differentRequested)
        !dep.is(differentSelected)
        !dep.is(differentConstraint)
    }

    def "creates and caches resolved dependencies with attributes"() {
        def fromModule = newModule('from')

        }
    }

    def "can add implementation dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.implementation("a:b:c")

        then:
        1 * dependencyFactory.create("a:b:c") >> dep
        1 * deps.add(dep)
    }

    def "can add and configure implementation dependency"() {
        def dep = Stub(ExternalModuleDependency)
        def action = Mock(Action)

        when:

from typing_extensions import Annotated

app = FastAPI()

T = TypeVar("T")

Dep = Annotated[T, Depends()]


class A:
    pass


class B:
    pass


@app.get("/a")
async def a(dep: Dep[A]):
    return {"cls": dep.__class__.__name__}


@app.get("/b")
async def b(dep: Dep[B]):
    return {"cls": dep.__class__.__name__}


client = TestClient(app)

                                    if (dep.type) {
                                        type(dep.type)
                                    }
                                    if (dep.scope) {
                                        scope(dep.scope)
                                    }
                                    if (dep.classifier) {
                                        classifier(dep.classifier)