import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderConvertible;

import javax.annotation.Nullable;
import java.util.Map;

/**
 * <p>A {@code DependencyHandler} is used to declare dependencies. Dependencies are grouped into
 * configurations (see {@link org.gradle.api.artifacts.Configuration}).</p>
 *

Laura Kassovic <******@****.***> 1701107622 -0800

        long contextId,
        Provider<CacheInstrumentationDataBuildService> buildService,
        DependencyHandler dependencyHandler
    ) {
        this.contextId = contextId;
        this.buildService = buildService;
        this.dependencyHandler = dependencyHandler;
    }

    public long getContextId() {
        return contextId;
    }

    public Provider<CacheInstrumentationDataBuildService> getBuildService() {

        handler.configurations

        then:
        1 * depMgmtServices.configurationContainer >> configurationContainer
        1 * depMgmtServices.dependencyHandler >> dependencyHandler
        1 * buildLogicBuilder.prepareDependencyHandler(dependencyHandler) >> resolutionContext
        1 * configurationContainer.migratingUnlocked('classpath', ConfigurationRolesForMigration.LEGACY_TO_RESOLVABLE_DEPENDENCY_SCOPE) >> configuration

        return new ScriptClassPathResolutionContext(contextId, service, dependencyHandler);
    }

    private void registerInstrumentationAndUpgradesPipeline(long contextId, DependencyHandler dependencyHandler, Provider<CacheInstrumentationDataBuildService> service) {
        dependencyHandler.registerTransform(
            InstrumentationAnalysisTransform.class,
            spec -> {

        when:
        dependencyHandler.unknown("someDep")

        then:
        def e = thrown(MissingMethodException)
        e.message.startsWith('Could not find method unknown() for arguments [someDep] on ')
    }

    void "dynamic method fails for no args"() {
        when:
        dependencyHandler.someConf()

        then:

    val dependencies: DependencyHandler
) : DependencyHandlerDelegate() {

    companion object {
        fun of(dependencies: DependencyHandler): DependencyHandlerScope =
            DependencyHandlerScope(dependencies)
    }

    override val delegate: DependencyHandler
        get() = dependencies

        val dependencyHandler = newDependencyHandlerMock {
            on { add(any(), any()) } doReturn mock<Dependency>()
        }

        val dependencies = DependencyHandlerScope.of(dependencyHandler)
        dependencies {
            "configuration"("notation")
        }

        verify(dependencyHandler).add("configuration", "notation")
    }

    @Test

     * @param dependencyConfiguration expression to use to configure the dependency.
     * @return The dependency.
     *
     * @see [DependencyHandler.create]
     * @see [DependencyHandler.add]
     */
    fun DependencyHandler.`api`(
        group: String,
        name: String,
        version: String? = null,
        configuration: String? = null,
        classifier: String? = null,

    ext
).also {
    action?.execute(it)
    dependencyHandler.add(targetConfiguration, it)
}


fun externalModuleDependencyFor(
    dependencyHandler: DependencyHandler,
    group: String,
    name: String,
    version: String?,
    configuration: String?,
    classifier: String?,
    ext: String?
): ExternalModuleDependency = dependencyHandler.create(
    mapOfNonNullValuesOf(