void execute(ComponentMetadataContext context) {
                    ["compile", "runtime"].each { base ->
                        context.details.withVariant(base) {
                            withDependencies {
                                dependencies.each {
                                    add(it)
                                }
                            }
                        }
                    }

                return dependency.withRequested(newSelector);
        });
        return this.withDependencies(transformed);
    }

    private IvyModuleResolveMetadata withDependencies(List<IvyDependencyDescriptor> transformed) {
        return new DefaultIvyModuleResolveMetadata(this, transformed);
    }

    @Override

    get().defaultDependencies(action)


/**
 * See [Configuration.withDependencies].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().withDependencies(action)"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.withDependencies(action: DependencySet.() -> Unit) =
    get().withDependencies(action)


/**
 * See [Configuration.all].
 */

        }
        return this.withDependencies(transformedDescriptors);
    }

    @Override
    public ImmutableList<IvyDependencyDescriptor> getDependencies() {
        return dependencies;
    }

    private IvyModuleResolveMetadata withDependencies(Map<IvyDependencyDescriptor, IvyDependencyDescriptor> transformed) {

            dependencies {
                components {
                    withModule('org:bar') { ComponentMetadataDetails details ->
                        details.allVariants {
                            withDependencies {
                                it.each {
                                    it.version { strictly(it.requiredVersion) }
                                }
                            }
                        }

val agentsRuntimeOnly by bucket()
agentsRuntimeOnly.description = "To define dependencies to the Gradle modules that represent Java agents packaged in the distribution (lib/agents/*.jar)"

coreRuntimeOnly.withDependencies {
    // use 'withDependencies' to not attempt to find platform project during script compilation
    add(project.dependencies.create(dependencies.platform(project(":distributions-dependencies"))))
}

    }

    @Override
    public List<? extends ModuleDependencyMetadata> getDependencies() {
        return getConfigDependencies();
    }

    public RealisedConfigurationMetadata withDependencies(ImmutableList<ModuleDependencyMetadata> dependencies) {
        return new RealisedConfigurationMetadata(
            getComponentId(),
            getName(),
            isTransitive(),
            isVisible(),

        this.dependencyMetadataNotationParser = dependencyMetadataNotationParser;
        this.dependencyConstraintMetadataNotationParser = dependencyConstraintMetadataNotationParser;
    }

    @Override
    public void withDependencies(Action<? super DirectDependenciesMetadata> action) {

            VariantAwareResolutionWithConfigurationAttributesIntegrationTest.withVariants(buildDotGradle)
            VariantAwareResolutionWithConfigurationAttributesIntegrationTest.withDependencies(buildDotGradle, 'implementation project(":core")')
            src {
                main {
                    resources {
                        'client.txt'('client')
                    }

            }
        }
        buildFile << """

class AssertingRule implements ComponentMetadataRule {

    void execute(ComponentMetadataContext context) {
        context.details.allVariants {
            withDependencies {
                it.each { dep ->
                    println "selectorSize:" + dep.artifactSelectors.size
                    println "classifier:" + dep.artifactSelectors[0]?.classifier